a

package org.jleaf.erp.purch.bo.invoice;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.validator.GenericValidator;
import org.jleaf.common.ComboIdConstants;
import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.CoreException;
import org.jleaf.core.DefaultBusinessTransaction;
import org.jleaf.core.Dto;
import org.jleaf.core.GeneralConstants;
import org.jleaf.core.annotation.ErrorList;
import org.jleaf.core.annotation.Info;
import org.jleaf.core.annotation.InfoIn;
import org.jleaf.core.annotation.InfoOut;
import org.jleaf.erp.purch.PurchasingConstants;
import org.jleaf.erp.purch.PurchasingConstantsForDlg;
import org.jleaf.erp.purch.PurchasingExceptionConstants;
import org.jleaf.erp.purch.dao.InvoiceAdditionalForDlgDao;
import org.jleaf.erp.purch.dao.InvoiceCostDao;
import org.jleaf.erp.purch.dao.InvoiceDao;
import org.jleaf.erp.purch.dao.InvoiceTaxDao;
import org.jleaf.erp.purch.entity.Invoice;
import org.jleaf.erp.purch.entity.InvoiceAdditionalForDlg;
import org.jleaf.erp.purch.entity.InvoiceCost;
import org.jleaf.erp.purch.entity.InvoiceTax;
import org.jleaf.util.Calc;
import org.jleaf.util.DtoUtil;
import org.jleaf.util.GsonUtil;
import org.jleaf.util.ValidationUtil;
import org.jleaf.validator.CommonBusinessValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 *
 * @author Didit Setya Bahari, Jul 14, 2015
 *
 * Fitra 28 Jun 2018, menambah validasi extDocNo(supplier doc no) unique per invoice per supplier dan tax no unique per invoice
 *
 **/

//@formatter:off
@Service("editInvoice")
@InfoIn(value = {
        @Info(name = "id", description = "invoice id", type = Long.class),
        @Info(name = "extDocNo", description = "external document no", type = String.class),
        @Info(name = "extDocDate", description = "external document date", type = String.class),
        @Info(name = "invoiceReceiptDate", description = "invoice receipt date", type = String.class),
        @Info(name = "dueDate", description = "due date", type = String.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "ouLegalId", description = "ou legal id", type = Long.class),
        @Info(name = "costId", description = "cost id", type = Long.class),
        @Info(name = "additionalDiscAmount", description = "additional disc amount", type = Double.class),
        @Info(name = "costVersion", description = "cost version", type = Long.class),
        @Info(name = "allocType", description = "alloc type", type = String.class),
        @Info(name = "flgIncludeTaxAdditionalDisc", description = "flg include tax additional disc", type = String.class),
        @Info(name = "additionalVersion", description = "invoice additional version", type = Long.class),
        @Info(name = "invoiceTaxList", description = "invoice tax list (id, taxNo, taxDate, govTaxAmount, version)", type = List.class),
        @Info(name = "version", description = "version", type = Long.class),
        @Info(name = "tenantLoginId", description = "tenant login id", type = Long.class),
        @Info(name = "userLoginId", description = "user login id", type = Long.class),
        @Info(name = "roleLoginId", description = "role login id", type = Long.class),
        @Info(name = "datetime", description = "datetime", type = String.class)
})
@InfoOut(value = {
        @Info(name = "id", description = "invoice id", type = Long.class)
})
@ErrorList(errorKeys = {
        CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.DATA_CANT_CHANGE_CAUSE_TENANT,
        CommonExceptionConstants.OULEGAL_ID_NOT_FOUND,
        CommonExceptionConstants.OU_ID_NOT_FOUND,
        CommonExceptionConstants.OU_NOT_LEGAL_ENTITY,
        PurchasingExceptionConstants.INVOICE_ID_NOT_FOUND,
        PurchasingExceptionConstants.INVOICE_TAX_ID_NOT_FOUND,
        PurchasingExceptionConstants.DOC_ALREADY_SUBMITTED,
        PurchasingExceptionConstants.INVOICE_TAX_ERROR
})
//@formatter:on
public class EditInvoiceForDlg extends DefaultBusinessTransaction implements BusinessTransaction {
    private static final Logger log = LoggerFactory.getLogger(EditInvoiceForDlg.class);

    @Autowired
    private InvoiceDao invoiceDao;

    @Autowired
    private InvoiceAdditionalForDlgDao invoiceAdditionalForDlgDao;

    @Autowired
    private InvoiceTaxDao invoiceTaxDao;

    @Autowired
    private InvoiceCostDao invoiceCostDao;

    @Autowired
    @Qualifier("findInvoiceById")
    private BusinessFunction findInvoiceById;

    @Autowired
    @Qualifier("findInvoiceCostById")
    private BusinessFunction findInvoiceCostById;

    @Autowired
    @Qualifier("findInvoiceAdditionalForDlgById")
    private BusinessFunction findInvoiceAdditionalForDlgById;

    @Autowired
    @Qualifier("valTenantLoginCanUse")
    private BusinessFunction valTenantLoginCanUse;

    @Autowired
    @Qualifier("valOUAsLegal")
    private BusinessFunction valOUAsLegal;

    @Autowired
    @Qualifier("findOULegalById")
    private BusinessFunction findOULegalById;

    @Autowired
    @Qualifier("findInvoiceTaxById")
    private BusinessFunction findInvoiceTaxById;

    @Autowired
    @Qualifier("valComboValueByCode")
    private BusinessFunction valComboValueByCode;

    @Autowired
    @Qualifier("calculateAmountFromGrossPriceDiscForPo")
    private BusinessFunction calculateAmountFromGrossPriceDiscForPo;

    @Autowired
    @Qualifier("getRoundingParameter")
    private BusinessFunction getRoundingParameter;

    @Autowired
    @Qualifier("getDigitDecimalCurrencyByDocType")
    private BusinessFunction getDigitDecimalCurrencyByDocType;

    @Autowired
    @Qualifier("valInvoiceHasUniqueTaxNo")
    private BusinessFunction valInvoiceHasUniqueTaxNo;

    @Autowired
    @Qualifier("valInvoiceHasUniqueExtDocBySupplier")
    private BusinessFunction valInvoiceHasUniqueExtDocBySupplier;

    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        // Validation tenant login id can be use
        Dto loginDto = new Dto();
        loginDto.put("tenantLoginId", inputDto.getLong("tenantLoginId"));
        loginDto.put("userLoginId", inputDto.getLong("userLoginId"));
        loginDto.put("roleLoginId", inputDto.getLong("roleLoginId"));
        valTenantLoginCanUse.execute(loginDto);

        // Validation tidak boleh kosong / null / tanggal / etc
        ValidationUtil.valBlankOrNull(inputDto.getString("extDocNo"), "Ext Document No");
        ValidationUtil.valDate(inputDto.getString("extDocDate"), "Ext Document Date");
        ValidationUtil.valNumeric(inputDto, "costId");
        ValidationUtil.valNumber(inputDto, "additionalDiscAmount");
        ValidationUtil.valNumeric(inputDto, "costVersion");
        ValidationUtil.valBlankOrNull(inputDto, "allocType");
        ValidationUtil.valBlankOrNull(inputDto, "flgIncludeTaxAdditionalDisc");
        ValidationUtil.valNumeric(inputDto, "additionalVersion");


        Long costId = inputDto.getLong("costId");
        Long costVersion = inputDto.getLong("costVersion");
        String allocType = inputDto.getString("allocType");
        String flgIncludeTaxAdditionalDisc = inputDto.getString("flgIncludeTaxAdditionalDisc");
        Long additionalVersion = inputDto.getLong("additionalVersion");

        if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(inputDto.getLong("ouLegalId"))) {
            Dto ouLegalDto = findOULegalById.execute(new Dto().put("id", inputDto.getLong("ouLegalId")));
            valOUAsLegal.execute(new Dto().put("id", ouLegalDto.getLong("ouId")));
        }

        Dto invoiceDto = findInvoiceById.execute(inputDto);
        String docDate = invoiceDto.getString("docDate");
        String extDocDate = inputDto.getString("extDocDate");
        String invoiceReceiptDate = inputDto.getString("invoiceReceiptDate");

        //validasi supplier doc no harus unique per supplier
        Dto inputValInvoiceHasUniqueExtDocBySupplier = new Dto();
        inputValInvoiceHasUniqueExtDocBySupplier.put("id", inputDto.getLong("id"));
        inputValInvoiceHasUniqueExtDocBySupplier.put("extDocNo", inputDto.getString("extDocNo"));
        inputValInvoiceHasUniqueExtDocBySupplier.put("partnerId", invoiceDto.getLong("partnerId"));
        valInvoiceHasUniqueExtDocBySupplier.execute(inputValInvoiceHasUniqueExtDocBySupplier);

        Dto inputDtoForRoundingParameter = new Dto();
        inputDtoForRoundingParameter.put("tenantId", inputDto.getLong("tenantLoginId"));
        Dto resultDtoForRoundingParameter = getRoundingParameter.execute(inputDtoForRoundingParameter);
        int roundingModeNonTax = resultDtoForRoundingParameter.getInteger("roundingModeNonTax");
        int scaleTax = resultDtoForRoundingParameter.getInteger("scaleTax");
        int roundingModeTax = resultDtoForRoundingParameter.getInteger("roundingModeTax");

        Dto paramDigitDecimalCurrency = new Dto();
        paramDigitDecimalCurrency.put("tenantId", inputDto.getLong("tenantLoginId"));
        paramDigitDecimalCurrency.put("docTypeId", PurchasingConstants.DOCUMENT_PURCH_INVOICE);
        paramDigitDecimalCurrency.put("currCode", invoiceDto.getString("currCode"));
        Dto resultDigitDecimalCurrency = getDigitDecimalCurrencyByDocType.execute(paramDigitDecimalCurrency);

        Integer decimalForRounding = resultDigitDecimalCurrency.getInteger("digit");

        // Rounding additional discount diawal, agar saat diproses selanjutnya, sudah dengan hasil ter rounding
        Calc.rounding(inputDto, decimalForRounding, roundingModeNonTax, "additionalDiscAmount");
        Double additionalDiscAmount = inputDto.getDouble("additionalDiscAmount");

        // header version validation
        if (!invoiceDto.getLong("version").equals(inputDto.getLong("version"))) {
            throw new CoreException(PurchasingExceptionConstants.DOCUMENT_VERSION_NOT_UPTODATE, "Purchase Invoice");
        }

        if (!invoiceDto.getLong("tenantId").equals(inputDto.getLong("tenantLoginId"))) {
            throw new CoreException(CommonExceptionConstants.DATA_CANT_CHANGE_CAUSE_TENANT, "Invoice");
        }

        if (!PurchasingConstants.DRAFT_TRANSACTION.equals(invoiceDto.getString("statusDoc"))) {
            throw new CoreException(PurchasingExceptionConstants.DOC_ALREADY_SUBMITTED);
        }

        Dto invoiceCostDto = findInvoiceCostById.execute(new Dto().put("id", costId));
        if (!invoiceCostDto.getLong("version").equals(costVersion)) {
            throw new CoreException(PurchasingExceptionConstants.DOCUMENT_VERSION_NOT_UPTODATE, "Additional Discount");
        }

        if (!invoiceCostDto.getLong("tenantId").equals(inputDto.getLong("tenantLoginId"))) {
            throw new CoreException(CommonExceptionConstants.DATA_CANT_CHANGE_CAUSE_TENANT, "Additonal Discount");
        }

        Dto invoiceAdditionalDto = findInvoiceAdditionalForDlgById.execute(new Dto().put("id", invoiceDto.getLong("id")));
        if (!invoiceAdditionalDto.getLong("version").equals(additionalVersion)) {
            throw new CoreException(PurchasingExceptionConstants.DOCUMENT_VERSION_NOT_UPTODATE, "Additional Invoice");
        }

        // Validasi invoiceReceiptDate memenuhi extDocDate <= invoiceReceiptDate <= docDate
        // extDocDate <= invoiceReceitDate
        boolean valExtDoc = !GenericValidator.isBlankOrNull(extDocDate)
                || !GenericValidator.isBlankOrNull(invoiceReceiptDate);
        if (valExtDoc) {
            CommonBusinessValidator.valCompareDate(extDocDate, invoiceReceiptDate, CommonBusinessValidator.COMPARE_LESS_EQUAL, "Ext Doc Date", "Invoice Receipt Date");
        }

        // invoiceReceiptDate <= docDate
        boolean valExtDoc1 = !GenericValidator.isBlankOrNull(invoiceReceiptDate)
                || !GenericValidator.isBlankOrNull(docDate);
        if (valExtDoc1) {
            CommonBusinessValidator.valCompareDate(invoiceReceiptDate, docDate, CommonBusinessValidator.COMPARE_LESS_EQUAL, "Invoice Receipt Date", "Doc Date");
        }

        // validasi flgIncludeTaxAdditionalDisc (YES NO), harus terdaftar di combo
        Dto paramFlgDeliveryDto = new Dto();
        paramFlgDeliveryDto.put("comboId", ComboIdConstants.COMBO_YES_NO);
        paramFlgDeliveryDto.put("code", flgIncludeTaxAdditionalDisc);
        paramFlgDeliveryDto.put("varName", "Flag Include Tax Additional Disc");
        valComboValueByCode.execute(paramFlgDeliveryDto);

        // validasi allocType, harus terdaftar di combo
        paramFlgDeliveryDto = new Dto();
        paramFlgDeliveryDto.put("comboId", PurchasingConstantsForDlg.COMBO_PURCH_DISC_ALLOC_TYPE);
        paramFlgDeliveryDto.put("code", allocType);
        paramFlgDeliveryDto.put("varName", "Alloc Type");
        valComboValueByCode.execute(paramFlgDeliveryDto);

        invoiceDto.put("ouLegalId", inputDto.getLong("ouLegalId"));
        invoiceDto.put("extDocNo", inputDto.getString("extDocNo"));
        invoiceDto.put("extDocDate", inputDto.getString("extDocDate"));
        invoiceDto.put("dueDate", inputDto.getString("dueDate"));
        invoiceDto.put("remark", inputDto.getString("remark"));
        invoiceDto.put("version", inputDto.getLong("version"));
        this.prepareUpdateAudit(invoiceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

        invoiceAdditionalDto.put("invoiceReceiptDate", inputDto.get("invoiceReceiptDate"));
        invoiceAdditionalDto.put("allocType", allocType);
        invoiceAdditionalDto.put("flgIncludeTaxAdditionalDisc", flgIncludeTaxAdditionalDisc);
        invoiceAdditionalDto.put("addDiscAmount", additionalDiscAmount*-1);
        this.prepareUpdateAudit(invoiceAdditionalDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));


        // SIMPAN ORIGINAL ADD AMOUNT UNTUK PERHITUNGAN TAX
        Double originalAddDiscAmount = invoiceCostDto.getDouble("addAmount");
        if(originalAddDiscAmount.doubleValue() != 0) {
            originalAddDiscAmount = originalAddDiscAmount * -1;
        }

        // simpan add amount dengan nilai dari additional amount, dengan nilai minus (jika tidak ada tax)
        invoiceCostDto.put("addAmount", additionalDiscAmount*-1);

        @SuppressWarnings("unchecked")
        List<Dto> invoiceTaxList = inputDto.getList("invoiceTaxList");
        List<Dto> resultInvoiceTaxList = new ArrayList<Dto>();
        List<Dto> failList = new ArrayList<Dto>();
        List<Dto> successList = new ArrayList<Dto>();
        if (invoiceTaxList != null && !invoiceTaxList.isEmpty()) {
            for (Dto paramInvoiceTaxDto : invoiceTaxList) {
                try {
                    //validasi tax no harus unique
                    Dto inputValInvoiceHasUniqueTaxNo = new Dto();
                    inputValInvoiceHasUniqueTaxNo.put("id", inputDto.getLong("id"));
                    inputValInvoiceHasUniqueTaxNo.put("taxNo", paramInvoiceTaxDto.getString("taxNo"));
                    valInvoiceHasUniqueTaxNo.execute(inputValInvoiceHasUniqueTaxNo);

                    Dto invoiceTaxDto = findInvoiceTaxById.execute(new Dto().put("id", Long.valueOf(paramInvoiceTaxDto.getString("id"))));

                    Dto paramCalculatePriceDto = new Dto();
                    paramCalculatePriceDto.put("grossPriceBeforeDisc", additionalDiscAmount);
                    paramCalculatePriceDto.put("qty", 1D);
                    paramCalculatePriceDto.put("discountPercentage", 0D);
                    paramCalculatePriceDto.put("discountAmount", 0D);
                    paramCalculatePriceDto.put("decimalForRounding", decimalForRounding);
                    paramCalculatePriceDto.put("roundingMode", roundingModeNonTax);
                    paramCalculatePriceDto.put("flgTaxAmount", flgIncludeTaxAdditionalDisc);
                    paramCalculatePriceDto.put("taxId", invoiceTaxDto.getLong("taxId"));
                    paramCalculatePriceDto.put("flgDiscount", "A");

                    Dto calculatePriceDto = calculateAmountFromGrossPriceDiscForPo.execute(paramCalculatePriceDto);
                    Double nettPriceFromDiscount = calculatePriceDto.getDouble("nettPrice");

                    Double baseAmount = new Calc(Double.valueOf(invoiceTaxDto.getString("baseAmount"))).add(originalAddDiscAmount)
                                            .subtract(nettPriceFromDiscount).doubleValue();

                    Double taxPercentage = invoiceTaxDto.getDouble("taxPercentage");
                    Double taxAmount = new Calc(baseAmount).multiply(taxPercentage).divide(100, scaleTax, roundingModeTax).doubleValue();

                    log.info("curr code tax vs curr code invoice : "+ invoiceTaxDto.getString("taxCurrCode")+ " vs "+invoiceDto.getString("currCode"));

                    Double govTaxAmount =  invoiceTaxDto.getDouble("govTaxAmount");
                    if(invoiceTaxDto.getString("taxCurrCode").equals(invoiceDto.getString("currCode"))) {
                        govTaxAmount = taxAmount;
                    }

                    invoiceTaxDto.put("taxNo", paramInvoiceTaxDto.getString("taxNo"));
                    invoiceTaxDto.put("taxDate", paramInvoiceTaxDto.getString("taxDate"));
                    invoiceTaxDto.put("baseAmount", baseAmount);
                    invoiceTaxDto.put("taxAmount", taxAmount);
                    invoiceTaxDto.put("govTaxAmount", govTaxAmount);
                    invoiceTaxDto.put("version", Long.valueOf(paramInvoiceTaxDto.getString("version")));

                    resultInvoiceTaxList.add(invoiceTaxDto);

                    // simpan nett amount hasil perhitungan add disc amount ke add amount, dengan nilai minus ( jika ada pajak )
                    invoiceCostDto.put("addAmount", calculatePriceDto.getDouble("nettAmount")*-1);

                    Dto successDto = new Dto();
                    successDto.put("id", invoiceTaxDto.getLong("id"));
                    successDto.put("version", invoiceTaxDto.getLong("version"));
                    successDto.put("taxNo", invoiceTaxDto.getString("taxNo"));
                    successDto.put("taxDate", invoiceTaxDto.getString("taxDate"));
                    successDto.put("govTaxAmount", invoiceTaxDto.getDouble("govTaxAmount"));
                    successList.add(successDto);
                } catch (CoreException e) {
                    paramInvoiceTaxDto.put("errorKey", e.getErrorKey());

                    List<Object> argsList = new ArrayList<Object>();
                    if (e.getParamValues() != null && e.getParamValues().length > 0) for (Object paramValue : e.getParamValues()) {
                        argsList.add(paramValue);
                    }
                    paramInvoiceTaxDto.put("args", argsList);

                    failList.add(paramInvoiceTaxDto);
                }
            }
        }

        if (!failList.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failList",
                    new String[] {"id", "taxNo", "taxDate", "govTaxAmount", "version", "errorKey", "args"}, failList);
            throw new CoreException(PurchasingExceptionConstants.INVOICE_TAX_ERROR, errorParamDto);
        }

        this.prepareUpdateAudit(invoiceCostDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

        inputDto.put("invoiceDto", invoiceDto);
        inputDto.put("invoiceCostDto", invoiceCostDto);
        inputDto.put("invoiceAdditionalDto", invoiceAdditionalDto);
        inputDto.put("resultInvoiceTaxList", resultInvoiceTaxList);

        return null;
    }

    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        Dto outputDto = new Dto();

        Dto invoiceDto = inputDto.getDto("invoiceDto");
        Invoice invoice = GsonUtil.fromDto(invoiceDto, Invoice.class);
        invoice = invoiceDao.merge(invoiceDto.getLong("id"), invoice);

        Dto invoiceReceiptDateDto = inputDto.getDto("invoiceAdditionalDto");
        InvoiceAdditionalForDlg invoiceAdditionalForDlg = GsonUtil.fromDto(invoiceReceiptDateDto, InvoiceAdditionalForDlg.class);
        invoiceAdditionalForDlg = invoiceAdditionalForDlgDao.merge(invoiceReceiptDateDto.getLong("id"), invoiceAdditionalForDlg);

        Dto invoiceCostDto = inputDto.getDto("invoiceCostDto");
        InvoiceCost invoiceCost = GsonUtil.fromDto(invoiceCostDto, InvoiceCost.class);
        invoiceCost = invoiceCostDao.merge(invoiceCostDto.getLong("id"), invoiceCost);

        @SuppressWarnings("unchecked")
        List<Dto> resultInvoiceTaxList = inputDto.getList("resultInvoiceTaxList");
        for (Dto invoiceTaxDto : resultInvoiceTaxList) {
            InvoiceTax invoiceTax = GsonUtil.fromDto(invoiceTaxDto, InvoiceTax.class);
            invoiceTax = invoiceTaxDao.merge(invoiceTaxDto.getLong("id"), invoiceTax);

        }

        outputDto = new Dto(invoice);

        return outputDto;
    }

    public String getDescription() {
        return "Edit Invoice";
    }

}