import { Add, Divide, Multiply, Subtract } from "../../shared/math-operations";
import { TrUtils } from "../../utils/tr-utils";

export class VendorDebitNoteTotalsService {

    static GetTotalsValue(ItemsList: any, IsIndependentTax: boolean, DetailedInfo: boolean,
        Disc: any, Perc: string,
        TaxCodes: any, WithItems: boolean, Settings: any, EntitySettings: any) {

        // LPerc = TrUtils.SetPercToStringIfNull(LPerc);
        // PPerc = TrUtils.SetPercToStringIfNull(PPerc);
        Perc = TrUtils.SetPercToStringIfNull(Perc);
        // LDisc = TrUtils.SetValueToZeroIfNull(LDisc);
        // PDisc = TrUtils.SetValueToZeroIfNull(PDisc);
        Disc = TrUtils.SetValueToZeroIfNull(Disc);


        // opCodesList = this.CalculateLaborValues(opCodesList, IsIndependentTax);

        ItemsList = this.CalculateLaborItemValues(ItemsList, IsIndependentTax);

        let finalTotalsData: any = this.GetFinalRODataForSave(ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings, EntitySettings.DecimalsNumber);

        if (DetailedInfo) {
            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData,
                IsIndependentTax, ItemsList, TaxCodes, EntitySettings.DecimalsNumber);
        }

        if (WithItems) {
            // finalTotalsData.Ops = opCodesList;
            finalTotalsData.Items = ItemsList;
        }
        return finalTotalsData;
    }

    static CalculateLaborItemValues(ItemsList: any, IsIndependentTax: boolean) {
        ItemsList = this.ResetLaborItemValues(ItemsList, IsIndependentTax);

        // ItemsList = this.GetLaborItemsDiscountPrice(ItemsList);

        // ItemsList = this.GetLaborItemsAfterDiscount(ItemsList);

        // ItemsList = this.GetItemsAfterTax(ItemsList, IsIndependentTax);

        return ItemsList;
    }

    static ResetLaborItemValues(ItemsList: any, IsIndependentTax: boolean) {
        ItemsList.forEach((Item: any) => {
            Item = this.ResetLaborItemValueIfInvalid(Item);
            if (TrUtils.IsZero(Item.Qty)) {
                Item.Qty = 1;
            }
            Item.DiscountedPrice = Add(Item.Disc, Item.RecDisc);
            Item.AfterItemDisc = Item.NetAmt;
            if (IsIndependentTax) {
                Item.AfterItemTax = Add(Item.AfterItemDisc, Item.CGST, Item.SGST, Item.IGST);
            } else {
                Item.AfterItemTax = Item.AfterItemDisc;
            }
        });
        return ItemsList;
    }

    static ResetLaborItemValueIfInvalid(Item: any) {
        Item.UnPr = TrUtils.SetValueToZeroIfNull(Item.UnPr);
        Item.Disc = TrUtils.SetValueToZeroIfNull(Item.Disc);
        Item.RecDisc = TrUtils.SetValueToZeroIfNull(Item.RecDisc);
        Item.CGST = TrUtils.SetValueToZeroIfNull(Item.CGST);
        Item.SGST = TrUtils.SetValueToZeroIfNull(Item.SGST);
        Item.IGST = TrUtils.SetValueToZeroIfNull(Item.IGST);
        return Item;
    }

    static GetFinalRODataForSave(ItemsList: any, IsIndependentTax: boolean, Disc: any, Perc: string,
        DetailedInfo: boolean, Settings: any, DecimalsNumber: number) {

        let finalTotalsData: any = {};

        finalTotalsData = this.SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo);

        finalTotalsData.Settings = Settings;

        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, ItemsList,
            IsIndependentTax, DetailedInfo, DecimalsNumber);

        return finalTotalsData;
    }

    static SetMainDiscountValues(Disc: string, Perc: string, finalTotalsData: any, DetailedInfo: boolean) {
        // finalTotalsData.LDisc = LDisc;
        // finalTotalsData.LPerc = LPerc;

        // finalTotalsData.PDisc = PDisc;
        // finalTotalsData.PPerc = PPerc;

        finalTotalsData.Disc = Disc;
        finalTotalsData.Perc = Perc;

        if (DetailedInfo) {
            // finalTotalsData.FixedLDisc = LDisc;
            // finalTotalsData.FixedPDisc = PDisc;
            finalTotalsData.FixedDisc = Disc;
        }
        return finalTotalsData;
    }

    static GetFinalCustomerTotalsData(finalTotalsData: any, ItemsList: any, IsIndependentTax: boolean,
        DetailedInfo: boolean, DecimalsNumber: number) {
        let CustomerAfterDiscTotals: number = this.GetSubTotalFor(ItemsList);

        // let CustLaborTaxTotal = this.GetLaborTaxTotalFor(IsIndependentTax);

        let CustItemTaxTotal = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);

        finalTotalsData.SubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
        // let CustLaborDiscTotal = this.GetLaborDiscountedTotal(LaborList, IsIndependentTax, finalTotalsData);

        let CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList, IsIndependentTax, finalTotalsData);

        // let CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
        let CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);

        finalTotalsData.STotal = Add(CustItemsDiscTotal, CustItemsTotalAfterDisc);

        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(finalTotalsData, CustItemTaxTotal, ItemsList, IsIndependentTax);

        finalTotalsData.Round = Subtract(Math.round(CustTotal), CustTotal);

        finalTotalsData.Total = Math.round(CustTotal);

        if (DetailedInfo) {
            finalTotalsData.FixedSubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
            finalTotalsData.FixedTotal = TrUtils.FixedTo(CustTotal, DecimalsNumber);
        }

        return finalTotalsData;
    }

    static GetSubTotalFor(ItemsList: any) {
        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
        let ItemsTotalAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
        return ItemsTotalAfterDisc;
    }

    static GetItemsTotalAfterDiscount(ItemsList: any) {
        let ItemsTotalAfterDisc: any = 0;
        ItemsList.forEach((Item: any) => {
            ItemsTotalAfterDisc = Add(ItemsTotalAfterDisc, Item.AfterItemDisc);
        });
        return ItemsTotalAfterDisc;
    }

    static GetDetailedTotalsData(finalTotalsData: any, IsIndependentTax: boolean, ItemsList: any, TaxCodes: any, DecimalsNumber: number) {
        // finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList, IsIndependentTax, finalTotalsData);

        finalTotalsData.CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList, IsIndependentTax, finalTotalsData);

        // finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
        finalTotalsData.CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);

        // finalTotalsData.CustLaborTotalBeforeDisc = TrUtils.FixedTo(finalTotalsData.CustLaborTotalAfterDisc
        //     + finalTotalsData.CustLaborDiscTotal);
        finalTotalsData.CustItemsTotalBeforeDisc = Add(finalTotalsData.CustItemsTotalAfterDisc
            , finalTotalsData.CustItemsDiscTotal);

        // finalTotalsData.CustLaborITax = this.GetLaborTaxTotalFor(opCodesList, IsIndependentTax);
        // finalTotalsData.CustLaborSGST = this.GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax);
        // finalTotalsData.CustLaborCGST = this.GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax);
        // finalTotalsData.CustLaborIGST = this.GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax);
        let TaxInfo: any = this.GetItemGSTTaxTotal(ItemsList, IsIndependentTax);
        finalTotalsData.CustItemITax = TrUtils.SetValueToZeroIfNull(TaxInfo[3]);
        finalTotalsData.CustItemCGST = TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
        finalTotalsData.CustItemIGST = TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
        finalTotalsData.CustItemSGST = TrUtils.SetValueToZeroIfNull(TaxInfo[1]);

        // finalTotalsData.CustItemITax = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
        // finalTotalsData.CustItemCGST = this.GetItemCGSTTaxTotal(ItemsList, IsIndependentTax);
        // finalTotalsData.CustItemIGST = this.GetItemIGSTTaxTotal(ItemsList, IsIndependentTax);
        // finalTotalsData.CustItemSGST = this.GetItemSGSTTaxTotal(ItemsList, IsIndependentTax);

        // finalTotalsData.CustLaborAfterTax = Add(finalTotalsData.CustLaborITax , finalTotalsData.CustLaborTotalAfterDisc);
        finalTotalsData.CustItemAfterTax = Add(finalTotalsData.CustItemITax, finalTotalsData.CustItemsTotalAfterDisc);

        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForItemsByHSN(ItemsList, TaxCodes, DecimalsNumber);

        finalTotalsData.CustTotalRoundedBy = TrUtils.FixedTo(finalTotalsData.Round, DecimalsNumber);

        finalTotalsData.CustRoundedTotal = TrUtils.FixedTo(finalTotalsData.Total, DecimalsNumber);

        for (var key in finalTotalsData) {
            if (key !== 'Total' && key !== 'SubTotal' &&
                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
                && typeof finalTotalsData[key] === 'number') {
                finalTotalsData[key] = TrUtils.FixPriceValue(finalTotalsData[key], DecimalsNumber);
            }
        }

        return finalTotalsData;
    }

    static GetItemDiscountedTotal(ItemsList: any, isTaxable: boolean, finalTotalsData: any) {
        let ItemsDiscountedTotal: any = 0;
        let overallItemDisc: number = 0;
        if (!isTaxable) {
            overallItemDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc)
        }
        ItemsList.forEach((Item: any) => {
            ItemsDiscountedTotal = Add(ItemsDiscountedTotal, Item.DiscountedPrice);
        });
        return Add(ItemsDiscountedTotal, overallItemDisc);
    }

    static GetItemsTaxTotalFor(ItemsList: any, IsIndependentTax: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsIndependentTax) {
            ItemsList.forEach((Item: any) => {
                TotalTaxAmt = Add(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
            });
        }
        return TotalTaxAmt;
    }

    static GetCustomerTotalBasedOnTaxType(finalTotalsData: any, ItemsTaxAmount: number
        , ItemsList: any,
        IsIndependentTax: boolean) {
        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
        let ItemsTotalAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
        if (IsIndependentTax) {
            return Add(ItemsTotalAfterDisc, ItemsTaxAmount);
        } else {
            return Subtract(ItemsTotalAfterDisc, finalTotalsData.Disc);
        }
    }

    static ItemsTotalAfterDiscount(ItemsTotalAfterDisc: number, ItemsTaxAmount: number, MainPDisc: number, PDiscInPerc: string) {
        let ItemsTotal: number = Add(ItemsTotalAfterDisc, ItemsTaxAmount);
        if (!TrUtils.IsZero(MainPDisc)) {
            if (!TrUtils.IsEmpty(PDiscInPerc)) {
                ItemsTotal = Subtract(ItemsTotal, Divide(Multiply(ItemsTotal, Number(PDiscInPerc)), 100));
            } else {
                ItemsTotal = Subtract(ItemsTotal, MainPDisc);
            }
        }
        return ItemsTotal;
    }

    static GetItemGSTTaxTotal(ItemsList: any, IsIndependentTax: boolean) {
        let TotalCGSTAmt: number = 0;
        let TotalSGSTAmt: number = 0;
        let TotalIGSTAmt: number = 0;
        let TotalTaxAmt: number = 0;
        if (IsIndependentTax) {
            ItemsList.forEach((Item: any) => {
                TotalCGSTAmt = Add(TotalCGSTAmt, Item.CGST);
                TotalSGSTAmt = Add(TotalSGSTAmt, Item.SGST);
                TotalIGSTAmt = Add(TotalIGSTAmt, Item.IGST);
                TotalTaxAmt = Add(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
            });
        }
        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
    }

    static GetTaxGroupingForItemsByHSN(Items: any, TaxCodes: any, DecimalsNumber:number) {
        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
        // Items = this.ResetItemsHSNIfInvalid(Items);

        let FinalMatchedItems: any[] = this.CompareItemsByHSN(Items, TaxCodes);

        return this.GetTaxGroupingInfoByHSN(FinalMatchedItems, TaxCodes, DecimalsNumber);
    }

    static GetCombinedTaxPercentage(Items: any, TaxCodes: any) {
        Items.forEach((Item: any) => {
            if (TrUtils.IsNull(Item.HSN)) {
                Item.HSN = '';
            }
            let TaxInfo = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
            Item.CGSTAmt = TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
            Item.SGSTAmt = TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
            Item.IGSTAmt = TrUtils.SetValueToZeroIfNull(TaxInfo[2]);

            Item.CombinedTaxPercentage = Add(Item.CGSTAmt, Item.SGSTAmt, Item.IGSTAmt);
        });
        return Items;
    }

    static CompareItemsByHSN(Items: any, TaxCodes: any) {
        let FinalMatchedItems: any[] = [];
        Items.forEach((Item: any) => {
            let MatchedItemsBasedOnHSN = Items.filter((argItem: any) => {
                let ItemFound: boolean = false;
                FinalMatchedItems.forEach((FinalArgItems: any) => {
                    let ItemIndex: any = FinalArgItems.findIndex((FinalArgItem: any) => {
                        return FinalArgItem._id === argItem._id;
                    });
                    if (ItemIndex !== -1) {
                        ItemFound = true;
                    }
                });

                // let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
                // let argCGST = argGSTValues[0];
                // let argSGST = argGSTValues[1];
                // let argIGST = argGSTValues[2];

                // let ItemGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
                // let ItemCGST = ItemGSTValues[0];
                // let ItemSGST = ItemGSTValues[1];
                // let ItemIGST = ItemGSTValues[2];

                return (argItem.HSN === Item.HSN) && (!ItemFound) &&
                    (argItem.CGSTAmt === Item.CGSTAmt) && (argItem.IGSTAmt === Item.IGSTAmt) &&
                    (argItem.SGSTAmt === Item.SGSTAmt);
            });
            if (MatchedItemsBasedOnHSN.length !== 0) {
                FinalMatchedItems.push(MatchedItemsBasedOnHSN);
            }
        });
        return FinalMatchedItems;
    }

    static GetTaxGroupingInfoByHSN(FinalMatchedItems: any, TaxCodes: any, DecimalsNumber: number) {
        let HSNTaxInfo: any[] = [];
        FinalMatchedItems.forEach((MatchedItem: any) => {
            let TaxInfo: any = {};
            let TaxOnAmount: any = 0;
            let TaxAmount: any = 0;
            let HSN: any = MatchedItem[0].HSN;
            TaxInfo.CombinedTaxPercentage = MatchedItem[0].CombinedTaxPercentage;
            MatchedItem.forEach((argMatchedGSTItem: any) => {
                TaxOnAmount = Add(TaxOnAmount, argMatchedGSTItem.AfterItemDisc);
                TaxAmount = Add(TaxAmount, argMatchedGSTItem.CGST);
                TaxAmount = Add(TaxAmount, argMatchedGSTItem.IGST);
                TaxAmount = Add(TaxAmount, argMatchedGSTItem.SGST);
            });
            TaxInfo.HSN = HSN;
            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
            TaxInfo.ItemsCount = MatchedItem.length;
            // let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
            // TaxInfo.CGST = GSTValues[0];
            // TaxInfo.SGST = GSTValues[1];
            // TaxInfo.IGST = GSTValues[2];
            TaxInfo.CGST = MatchedItem[0].CGSTAmt;
            TaxInfo.IGST = MatchedItem[0].IGSTAmt;
            TaxInfo.SGST = MatchedItem[0].SGSTAmt;
            if (TaxOnAmount !== 0) {
                HSNTaxInfo.push(TaxInfo);
            }
        });
        return HSNTaxInfo;
    }

    static GetGSTValueBasedOnTaxCode(TCode: any, TaxCodes: any) {
        let CGST: number = 0;
        let SGST: number = 0;
        let IGST: number = 0;
        if (TrUtils.IsNull(TCode)) {
            return [CGST, SGST, IGST];
        }
        let TCodeIndex: any = TaxCodes.findIndex((TaxCode: any) => {
            return TaxCode._id === Number(TCode);
        });
        if (TCodeIndex !== -1) {
            if (TaxCodes[TCodeIndex].Type === 'Intra') {
                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
            } else {
                return [0, 0, TaxCodes[TCodeIndex].IGST];
            }
        } else {
            return [CGST, SGST, IGST];
        }
    }

}