prs/prs.shared/Utilities/InvoiceUtilities.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using PRSDimensionUtils;
using Syncfusion.Windows.Controls.Grid;

namespace PRS.Shared;


public enum InvoiceTimeCalculation
{
    Detailed,
    Activity,
    Collapsed,
}
    
public enum InvoiceMaterialCalculation
{
    Detailed,
    Product,
    CostCentre,
    Collapsed,
}
    
public enum InvoiceExpensesCalculation
{
    Detailed,
    Collapsed,
}

public enum InvoicingStrategy
{
    InvoiceOnIssue,
    InvoiceOnPurchase
}

public static class InvoiceUtilities
{
    
    private class InvoiceLineDetail
    {
        public String Description { get; set; }
        public TaxCodeLink TaxCode { get; set; }
        public double Quantity { get; set; }
        public double Charge { get; set; }

        public InvoiceLineDetail()
        {
            TaxCode = new TaxCodeLink();
        }
    }

    private static async Task<InvoiceLine[]> TimeLines(Invoice invoice, InvoiceTimeCalculation timesummary)
    {
        var timelines = new Dictionary<Guid, InvoiceLineDetail>();

        var activitiesTask = Task.Run(() =>
        {
            return Client.Query(
                Filter<CustomerActivitySummary>.Where(x => x.Customer.ID).InList(invoice.Customer.ID, Guid.Empty),
                Columns.None<CustomerActivitySummary>().Add(x => x.Customer.ID)
                    .Add(x => x.Activity.ID)
                    .Add(x => x.Activity.Code)
                    .Add(x => x.Activity.Description)
                    .Add(x => x.Charge.TaxCode.ID)
                    .Add(x => x.Charge.TaxCode.Rate)
                    .Add(x => x.Charge.Chargeable)
                    .Add(x => x.Charge.FixedCharge)
                    .Add(x => x.Charge.ChargeRate)
                    .Add(x => x.Charge.ChargePeriod)
                    .Add(x => x.Charge.MinimumCharge))
                .ToObjects<CustomerActivitySummary>()
                .GroupByDictionary(x => (CustomerID: x.Customer.ID, ActivityID: x.Activity.ID));
        });
        var assignmentsTask = Task.Run(() =>
        {
            return Client.Query(
                Filter<Assignment>.Where(x => x.Invoice.ID).IsEqualTo(invoice.ID).And(x => x.Charge.Chargeable).IsEqualTo(true),
                Columns.None<Assignment>()
                    .Add(x => x.ID)
                    .Add(x => x.Activity.ID)
                    .Add(x => x.Activity.Description)
                    .Add(x => x.Date)
                    .Add(x => x.Title)
                    .Add(x => x.Description)
                    .Add(x => x.Charge.OverrideCharge)
                    .Add(x => x.Charge.Charge)
                    .Add(x => x.Charge.OverrideQuantity)
                    .Add(x => x.Charge.Quantity)
                    .Add(x => x.Actual.Duration),
                new SortOrder<Assignment>(x => x.Date))
                .ToArray<Assignment>();
        });

        var activities = await activitiesTask;
        foreach (var assignment in await assignmentsTask)
        {
            var id = timesummary switch
            {
                InvoiceTimeCalculation.Detailed => assignment.ID,
                InvoiceTimeCalculation.Activity => assignment.Activity.ID,
                _ => Guid.Empty
            };

            var description = timesummary switch
            {
                InvoiceTimeCalculation.Detailed => $"{assignment.Date:dd MMM yy} - {assignment.Title}: {assignment.Description}",
                InvoiceTimeCalculation.Activity => assignment.Activity.Description,
                _ => "Labour"
            };

            var quantity = assignment.Charge.OverrideQuantity
                ? TimeSpan.FromHours(assignment.Charge.Quantity)
                : assignment.Actual.Duration;

            var activity = activities.GetValueOrDefault((invoice.Customer.ID, assignment.Activity.ID))?.FirstOrDefault()
                ?? activities.GetValueOrDefault((Guid.Empty, assignment.Activity.ID))?.FirstOrDefault()
                ?? new CustomerActivitySummary();

            double charge;
            if (assignment.Charge.OverrideCharge)
            {
                charge = quantity.TotalHours * assignment.Charge.Charge;
            }
            else
            {
                var chargeperiod = !activity.Charge.ChargePeriod.Equals(TimeSpan.Zero)
                    ? activity.Charge.ChargePeriod
                    : TimeSpan.FromHours(1);

                quantity = quantity.Ceiling(chargeperiod);

                // Rate is charge per hour, so we must divide by the charge period time, to get dollars per hour, rather than dollars per period
                // $/hr = ($/pd) * (pd/hr) = ($/pd) / (hr/pd)
                // where $/pd is ChargeRate and hr/pd = chargeperiod.TotalHours
                var rate = activity.Charge.ChargeRate / chargeperiod.TotalHours;
                
                charge = Math.Max(
                    activity.Charge.FixedCharge + (quantity.TotalHours * rate),
                    activity.Charge.MinimumCharge);
            }

            if(!timelines.TryGetValue(id, out var timeline))
            {
                timeline = new InvoiceLineDetail
                {
                    Description = description
                };
                timeline.TaxCode.CopyFrom(activity.Charge.TaxCode);
                timelines.Add(id, timeline);
            }

            timeline.Quantity += quantity.TotalHours;
            timeline.Charge += charge;
        }

        return timelines.Values.ToArray(line =>
        {
            var update = new InvoiceLine();
            update.Invoice.ID = invoice.ID;
            update.Description = line.Description;
            update.TaxCode.CopyFrom(line.TaxCode);
            update.Quantity = timesummary != InvoiceTimeCalculation.Collapsed ? line.Quantity : 1;
            update.ExTax = line.Charge;
            return update;
        });
    }
    private static async Task<InvoiceLine[]> PartLines(Invoice invoice, InvoiceMaterialCalculation partsummary, InvoicingStrategy strategy)
    {
        var customerProductsTask = Task.Run(() =>
        {
            return Client.Query(
                Filter<CustomerProduct>.Where(x => x.Customer.ID).InList(invoice.Customer.ID, Guid.Empty),
                Columns.None<CustomerProduct>()
                    .Add(x => x.Customer.ID)
                    .Add(x => x.Product.ID)
                    .Add(x => x.Discount))
                .ToObjects<CustomerProduct>()
                .GroupByDictionary(x => (CustomerID: x.Customer.ID, ProductID: x.Product.ID));
        });
        var stockMovementFilter = Filter<StockMovement>.Where(x => x.Invoice.ID).IsEqualTo(invoice.ID)
            .And(x => x.Charge.Chargeable).IsEqualTo(true);
        var productInstancesTask = Task.Run(() =>
        {
            return Client.Query(
                Filter<ProductInstance>.Where(x => x.Charge.Chargeable).IsEqualTo(true)
                    .And(x => x.Product.ID).InQuery(
                        stockMovementFilter,
                        x => x.Product.ID),
                Columns.None<ProductInstance>()
                    .Add(x => x.Product.ID)
                    .Add(x => x.Style.ID)
                    .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local)
                    .Add(x => x.Charge.PriceType)
                    .Add(x => x.Charge.Price)
                    .Add(x => x.Charge.Markup))
                .ToObjects<ProductInstance>()
                .GroupBy(x => (ProductID: x.Product.ID, StyleID: x.Style.ID, x.Dimensions))
                .ToDictionary(x => x.Key, x => x.First());
        });
        var movementsTask = Task.Run(() =>
        {
            return Client.Query(
                stockMovementFilter,
                Columns.None<StockMovement>()
                    .Add(x => x.ID)
                    .Add(x => x.Qty)
                    .Add(x => x.Units)
                    .Add(x => x.Cost)
                    .Add(x => x.Product.ID)
                    .Add(x => x.Product.Name)
                    .Add(x => x.Product.CostCentre.ID)
                    .Add(x => x.Product.CostCentre.Description)
                    .Add(x => x.Product.DefaultMarkUp)
                    .Add(x => x.Product.TaxCode.ID)
                    .Add(x => x.Product.TaxCode.Rate)
                    .Add(x => x.Product.DefaultMarkUp)
                    .Add(x => x.Style.ID)
                    .Add(x => x.Style.Code)
                    .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local)
                    .Add(x => x.Charge.OverrideCharge)
                    .Add(x => x.Charge.Charge)
                    .Add(x => x.Charge.OverrideQuantity)
                    .Add(x => x.Charge.Quantity))
                .ToArray<StockMovement>();
        });
        
        var partlines = new Dictionary<Guid, InvoiceLineDetail>();

        var customerProducts = await customerProductsTask;
        var productInstances = await productInstancesTask;
        foreach (var item in await movementsTask)
        {
            var id = partsummary switch
            {
                InvoiceMaterialCalculation.Detailed => item.ID,
                InvoiceMaterialCalculation.Product => item.Product.ID,
                InvoiceMaterialCalculation.CostCentre => item.Product.CostCentre.ID,
                _ => Guid.Empty
            };

            var description = partsummary switch
            {
                InvoiceMaterialCalculation.Detailed => $"{item.Product.Name}: {item.Style.Code}; {item.Dimensions.UnitSize}",
                InvoiceMaterialCalculation.Product => item.Product.Name,
                InvoiceMaterialCalculation.CostCentre => item.Product.CostCentre.Description,
                _ => "Materials"
            };

            var instance =
                productInstances.GetValueOrDefault((item.Product.ID, item.Style.ID, item.Dimensions));
            var customerProduct =
                customerProducts.GetValueOrDefault((invoice.Customer.ID, item.Product.ID))?.FirstOrDefault();

            // Quantity only to be used for the actual invoice line quantity if in Detailed version, otherwise we just use '1' as the quantity for the invoice line.
            var quantity = item.Charge.OverrideQuantity
                ? item.Charge.Quantity
                : item.Units * (strategy == InvoicingStrategy.InvoiceOnIssue ? -1 : 1);

            var discountMultiplier = 1 - (customerProduct?.Discount ?? 0) / 100;

            double charge;
            if (item.Charge.OverrideCharge)
            {
                charge = quantity * item.Charge.Charge;
            }
            else
            {
                if(instance is not null)
                {
                    charge = quantity * (instance.Charge.PriceType switch
                    {
                        ProductPriceType.CostPlus => item.Cost * (1 + instance.Charge.Markup / 100),
                        _ => instance.Charge.Price
                    }) * discountMultiplier;
                }
                else
                {
                    charge = quantity * item.Cost * item.Product.DefaultMarkUp * discountMultiplier;
                }
            }

            if(!partlines.TryGetValue(id, out var partline))
            {
                partline = new InvoiceLineDetail
                {
                    Description = description
                };
                if(partsummary != InvoiceMaterialCalculation.Detailed)
                {
                    partline.Quantity = 1;
                }
                partline.TaxCode.CopyFrom(item.Product.TaxCode);
                partlines.Add(id, partline);
            }

            if(partsummary == InvoiceMaterialCalculation.Detailed)
            {
                partline.Quantity += quantity;
            }
            partline.Charge += charge;               
        }

        return partlines.Values.ToArray(line =>
        {
            var update = new InvoiceLine();
            update.Invoice.ID = invoice.ID;
            update.Description = line.Description;
            update.TaxCode.CopyFrom(line.TaxCode);
            update.Quantity = new[] { InvoiceMaterialCalculation.Detailed, InvoiceMaterialCalculation.Product }.Contains(partsummary) ? line.Quantity : 1.0F;
            update.ExTax = line.Charge;
            return update;
        });
    }
    private static async Task<InvoiceLine[]> ExpenseLines(Invoice invoice, InvoiceExpensesCalculation expensesSummary)
    {
        var billLinesTask = Task.Run(() =>
        {
            return Client.Query(
                Filter<BillLine>.Where(x => x.Invoice.ID).IsEqualTo(invoice.ID).And(x => x.Charge.Chargeable).IsEqualTo(true),
                Columns.None<BillLine>()
                    .Add(x => x.ID)
                    .Add(x => x.Description)
                    .Add(x => x.ExTax)
                    .Add(x => x.TaxCode.ID)
                    .Add(x => x.TaxCode.Rate)
                    .Add(x => x.Charge.OverrideCharge)
                    .Add(x => x.Charge.Charge)
                    .Add(x => x.Charge.OverrideQuantity)
                    .Add(x => x.Charge.Quantity))
                .ToArray<BillLine>();
        });
        
        var expenselines = new Dictionary<Guid, InvoiceLineDetail>();

        foreach (var item in await billLinesTask)
        {
            var id = expensesSummary switch
            {
                InvoiceExpensesCalculation.Detailed => item.ID,
                _ => Guid.Empty
            };

            var description = expensesSummary switch
            {
                InvoiceExpensesCalculation.Detailed => $"{item.Description}",
                _ => "Expenses"
            };
            
            var quantity = item.Charge.OverrideQuantity
                ? item.Charge.Quantity
                : 1.0;
            
            double charge;
            if (item.Charge.OverrideCharge)
            {
                charge = quantity * item.Charge.Charge;
            }
            else
            {
                charge = quantity * item.ExTax * (1 + invoice.Customer.Markup / 100);
            }

            if(!expenselines.TryGetValue(id, out var expenseLine))
            {
                expenseLine = new InvoiceLineDetail
                {
                    Description = description
                };
                expenseLine.TaxCode.CopyFrom(item.TaxCode);
                expenselines.Add(id, expenseLine);
            }

            expenseLine.Quantity += quantity;
            expenseLine.Charge += charge;               
        }

        return expenselines.Values.ToArray(line =>
        {
            var update = new InvoiceLine();
            update.Invoice.ID = invoice.ID;
            update.Description = line.Description;
            update.TaxCode.CopyFrom(line.TaxCode);
            update.Quantity = expensesSummary != InvoiceExpensesCalculation.Collapsed ? line.Quantity : 1.0F;
            update.ExTax = line.Charge;
            return update;
        });
    }
    
    public static void GenerateInvoiceLines(
        Guid invoiceid,
        InvoiceTimeCalculation timesummary,
        InvoiceMaterialCalculation partsummary,
        InvoiceExpensesCalculation expensesSummary,
        InvoicingStrategy strategy,
        IProgress<String>? progress
    )
    {
        progress?.Report("Loading Invoice");
        var invoice = Client.Query(
            Filter<Invoice>.Where(x => x.ID).IsEqualTo(invoiceid))
            .ToObjects<Invoice>().FirstOrDefault();
        if(invoice is null)
        {
            Logger.Send(LogType.Error, "", $"Could not find invoice with ID {invoiceid}");
            return;
        }
        
        progress?.Report("Loading Detail Data");

        var deleteOldTask = Task.Run(() =>
        {
            var oldlines = new Client<InvoiceLine>().Query(
                Filter<InvoiceLine>.Where(x => x.Invoice.ID).IsEqualTo(invoice.ID),
                Columns.None<InvoiceLine>().Add(x => x.ID)
            ).Rows.Select(x => x.ToObject<InvoiceLine>()).ToArray();
            new Client<InvoiceLine>().Delete(oldlines, "");
        });

        var timeLinesTask = TimeLines(invoice, timesummary);
        var partLinesTask = PartLines(invoice, partsummary, strategy);
        var expenseLinesTask = ExpenseLines(invoice, expensesSummary);

        progress?.Report("Calculating...");

        var updates = CoreUtils.Concatenate(
            timeLinesTask.Result,
            partLinesTask.Result,
            expenseLinesTask.Result);

        progress?.Report("Creating Invoice Lines");
        Client.Save(updates, "Recalculating Invoice from Time and Materials");
    }

}