package com.lemans.ds.bulk.part

import com.lemans.ds.bulk.BulkProcessingHelperService
import com.lemans.ds.oemnumber.OemPart
import com.lemans.ds.oemnumber.OemPartManagerService
import com.lemans.ds.part.Part
import com.lemans.ds.part.PartAssociation
import com.lemans.ds.part.PartAssociationManagerService
import com.lemans.ds.part.PartLocale
import org.apache.commons.lang.StringUtils
import org.apache.poi.xssf.usermodel.XSSFCell
import org.springframework.dao.DuplicateKeyException

class BulkPartService extends BulkProcessingHelperService {

    OemPartManagerService oemPartManagerService

    PartAssociationManagerService partAssociationManagerService

    List updateOrCreateParts(List data, String username) {
        List partsWithErrors = []
        List partIDs = data*.partNumber
        List validDBPartNumbers = (Part.findAllByIdInListAndDateDeletedIsNull(partIDs))*.id
        data.each { Map eachRow ->
            String partNumber = eachRow.partNumber
            if (partNumber in validDBPartNumbers) {
                updateOrCreatePartsLocales(eachRow, username, partNumber, partsWithErrors)
            } else {
                Map errorsInMap = [:]
                collectErrorsForReport(eachRow, '', errorsInMap, ["Invalid Part Number : $partNumber"])
                errorsInMap ?. (partsWithErrors << errorsInMap)
            }
        }
        partsWithErrors
    }

    @SuppressWarnings(['CatchException'])
    private void updateOrCreatePartsLocales(Map eachRow, String username, String partNumber, List partsWithErrors) {
        List explicitLocales = findLocales(eachRow)
        if (explicitLocales) {
            PartLocale.withTransaction {
                List partLocaleObjects = PartLocale.findAllByPartNumberAndLocaleInListAndDateDeletedIsNull(partNumber, explicitLocales)
                explicitLocales.each { String locale ->
                    List errors = []
                    Map errorsInMap = [:]
                    try {
                        PartLocale partLocale = partLocaleObjects.find { it.locale.equalsIgnoreCase(locale) }
                        partLocale ? updatePartLocale(eachRow, partLocale, username, locale, errors) :
                        addPartLocale(eachRow, username, locale, partNumber, errors)
                        if (errors != []) {
                            partsWithErrors << collectErrorsForReport(eachRow, locale, errorsInMap, errors)
                        }
                    } catch (DuplicateKeyException e) {
                        log.error(e.message)
                        partsWithErrors << collectErrorsForReport(eachRow, locale, errorsInMap, ['duplicate part found'])
                    } catch (Exception e) {
                        log.error(e.message)
                        partsWithErrors << collectErrorsForReport(eachRow, locale, errorsInMap,
                                                             ['Exception occurred! If persists, contact HelpDesk'])
                    }
                }
            }
        }
        partsWithErrors
    }


    List createPartOem(List data, String username) {
        List partsWithErrors = []
        List partIDs = data*.partNumber
        List validDBPartNumbers = (Part.findAllByIdInListAndDateDeletedIsNull(partIDs))*.id
        data.each { Map eachRow ->
            String partNumber = eachRow.partNumber
            if (partNumber in validDBPartNumbers) {
                OemPart oemPart = addPartOem(eachRow, username, partNumber)
                if (oemPart.hasErrors()) {
                    eachRow.report = oemPart?.errors?.allErrors?.defaultMessage
                    partsWithErrors << eachRow
                }
            } else {
                Map errorsInMap = [:]
                collectErrorsForReport(eachRow, '', errorsInMap, ["Invalid Part Number : $partNumber"])
                errorsInMap ?. (partsWithErrors << errorsInMap)
            }
        }
        partsWithErrors
    }

    List createRelatedParts(List data, String username) {
        List partsWithErrors = []
        List partIDs = data.collect { it.partNumber }
        List relatedPartNumbers = data.collect { it.relatedPartNumber }
        List validDBPartNumbers = Part.findAllByIdInListAndDateDeletedIsNull(partIDs).collect { it.id }
        List validRelatedPartNumbers = Part.findAllByIdInListAndDateDeletedIsNull(relatedPartNumbers).collect { it.id }
        data.each { eachRow ->
            String partNumber = eachRow.partNumber
            if (!(partNumber in validDBPartNumbers)) {
                eachRow.report = "Invalid Part Number : $partNumber"
                partsWithErrors << eachRow
                return
            }
            if (eachRow?.relatedPartNumber?.toString() in validRelatedPartNumbers) {
                PartAssociation partAssociation = addAssociations(eachRow, partNumber, username)
                if (partAssociation.hasErrors()) {
                    eachRow.report = partAssociation.errors.allErrors.defaultMessage
                    partsWithErrors << eachRow
                }
            } else {
                eachRow.report = "Invalid Related Part Number : ${eachRow?.relatedPartNumber}"
                partsWithErrors << eachRow
            }
        }
        partsWithErrors
    }

    private OemPart addPartOem(Map data, String username, String partNumber) {
        XSSFCell oemPartNumber = data?.oemPartNumber
        XSSFCell makeId = data?.makeId
        oemPartManagerService.addOemPart([partNumber: partNumber, oemPartNumber: oemPartNumber?.getStringCellValue(), makeId: makeId?.stringCellValue?.toInteger()], username)
    }

    private PartAssociation addAssociations(Map data, String partNumber, String username) {
        String associationType = data?.associationType
        String relatedPartNumber = data?.relatedPartNumber
        Integer typeId = sql().rows("""SELECT DISTINCT typeId FROM Common.dbo.TypeXref WITH(NOLOCK) WHERE typeDisplayName = ${associationType} AND type = 'PartAssociationType' AND dateDeleted IS NULL""")?.typeId[0]
        partAssociationManagerService.addPartAssociation(partNumber, [associationTypeId: typeId, relatedPartNumber: relatedPartNumber], username)
    }


    private Map collectErrorsForReport(Map eachRow, String locale, Map errorsInMap, List errors) {
        collectErrorsIntoMap(eachRow, locale, errorsInMap, errors)
        if (errorsInMap) { errorsInMap }
    }

    private void updatePartLocale(Map eachRow, PartLocale partLocale, String username, String locale, List errors) {
        assignValues(partLocale, eachRow, locale)
        partLocale.validate()
        saveOrDiscardDomain(partLocale, username)
        if (!partLocale.hasErrors()) { partLocale.save(flush: true) }
        collectIfErrors(partLocale, errors)
    }

    private void addPartLocale(Map eachRow, String username, String locale, String partNumber, List errors) {
        PartLocale partLocale = new PartLocale()
        partLocale.locale = locale
        partLocale.partNumber = partNumber
        assignValues(partLocale, eachRow, locale)
        partLocale.validate()
        saveOrDiscardDomain(partLocale, username)
        if (!partLocale.hasErrors()) { partLocale.save(flush: true) }
        collectIfErrors(partLocale, errors)
    }

    private void assignValues(PartLocale partLocale, Map eachRow, String locale) {
        List assignableKeys = eachRow.collect { String key, value ->
            if (key.endsWith("[$locale]")) {
                if (value.toString()) { key.replace("${LOCALE_COUNTRY_MAPPING[locale]}[${locale}]", '') }
            }
        }
        List validPartLocaleFields = assignableKeys.findAll { it != null }.unique()
        validPartLocaleFields.each { String value ->
            partLocale."$value" =  eachRow."$value${LOCALE_COUNTRY_MAPPING[locale]}[${locale}]"
        }
    }

    private List findLocales(Map eachRow) {
        List locales = eachRow.collect { String key, value ->
            if (key.startsWith('marketingDescr') || key.startsWith('specialInstructions')
                                  || key.startsWith('partSpecificText')) {
                if (value.toString()) {  StringUtils.substringBetween(key, '[', ']') }
            }
        }
        locales.unique().findAll { it != null }
    }

    private void collectErrorsIntoMap(Map eachRow, String locale, Map errorsInMap, List errors) {
        errorsInMap.put('Part Number', eachRow.partNumber)
        errorsInMap.put('Locale', locale)
        errorsInMap.put('report', errors)
    }
}