using System;

public class Program

{

    public static void Main()

    {

        // Be careful when relying on this fiddle, and check to make sure it's up to date.

        PointOfSale pointOfSale = new PointOfSale(total: 1, tax: 1);

        int exemptionAmount = 0;

        int spendAmount = 1;

​

        pointOfSale.ApplyTender(1);

​

        // Create proposed order: expected values

        AdjustedCheckValues expectedProposedOrderValues =

            new AdjustedCheckValues(

            spendAmount: 1,         // amount the customer wants to pay

            taxAmount: 1,           // no tax will be due for this payment; tax will be paid "at the end"

            exemptionAmount: 0);    // there are no exemptions

​

        AdjustedCheckValues proposedOrderValues = ProposedOrderCalculator.CalculateCreateProposedOrderValues(

            pointOfSale.TotalOutstandingAmount,

            pointOfSale.TotalTaxAmount,

            exemptionAmount,

            spendAmount);

        Console.WriteLine("spend_amount to use for the Proposed Order Request: " + proposedOrderValues.SpendAmount);

        Console.WriteLine("tax_amount to use for the Proposed Order Request: " + proposedOrderValues.TaxAmount);

        Console.WriteLine("exemption_amount to use for the Proposed Order Request: " + proposedOrderValues.ExemptionAmount);

        Console.WriteLine();

​

        // available discount amount $0.00

        int availableDiscountAmount = 0;

​

        pointOfSale.ApplyDiscount(availableDiscountAmount);

​

        // $ 0.00 (Subtotal Remaining)

        // $ 0.01 (Tax)

        // $ 0.01 (Total)

        // $ 0.01 (Total + Discount Applied) 

        AdjustedCheckValues expectedCompletedOrderValues =

            new AdjustedCheckValues(

            spendAmount: 1,

            taxAmount: 1,

            exemptionAmount: 0);

​

        AdjustedCheckValues completedOrderValues = ProposedOrderCalculator.CalculateCompleteOrderValues(

            pointOfSale.TotalOutstandingAmount,

            pointOfSale.TotalTaxAmount,

            exemptionAmount,

            spendAmount,

            availableDiscountAmount);

        Console.WriteLine("spend_amount to use for the Completed Order Request: " + completedOrderValues.SpendAmount);

        Console.WriteLine("tax_amount to use for the Completed Order Request: " + completedOrderValues.TaxAmount);

        Console.WriteLine("exemption_amount to use for the Completed Order Request: " + completedOrderValues.ExemptionAmount);

    }

}

​

public class AdjustedCheckValues

{

    public int SpendAmount { get; }

    public int TaxAmount { get; }

    public int ExemptionAmount { get; }

​

    internal AdjustedCheckValues(int spendAmount, int taxAmount, int exemptionAmount)

    {

        SpendAmount = spendAmount;

        TaxAmount = taxAmount;

        ExemptionAmount = exemptionAmount;

    }

​

    public override string ToString()

    {

        return $"SpendAmount={SpendAmount};TaxAmount={TaxAmount};ExemptionAmount={ExemptionAmount};";

    }

}

​

internal class CheckData

{

    public int PaymentAmount { get; set; }

    public int TaxAmount { get; set; }

    public int ExemptionAmount { get; set; }

    public int OutstandingAmount { get; set; }

    public int PreTaxSubtotal => OutstandingAmount - TaxAmount;

    public int NonExemptSubtotal => PreTaxSubtotal - ExemptionAmount;

}

​

public static class ProposedOrderCalculator

{

    /// <summary>

    /// Accepts known values from the point-of-sale and gives you an AdjustedCheckValues object containing the 

    /// spend_amount, tax_amount, and exemption_amount to submit a LevelUp Create Proposed Order API request.

    /// </summary>

    /// <param name="outstandingAmount">The current total amount of the check, including tax, in cents.</param>

    /// <param name="taxAmount">The current tax due on the check, in cents.</param>

    /// <param name="exemptAmount">The current total of exempted items on the check, in cents.</param>

    /// <param name="paymentAmount">The amount the customer would like to spend, in cents.</param>

    /// <returns>LevelUp.Pos.ProposedOrderCalculator.CalculateCreateProposedOrderValues</returns>

    public static AdjustedCheckValues CalculateCreateProposedOrderValues(

        int outstandingAmount,

        int taxAmount,

        int exemptAmount,

        int paymentAmount

    )

    {

        return CalculateOrderValues(

            outstandingAmount,

            taxAmount,

            exemptAmount,

            paymentAmount);

    }

​

    /// <summary>

    /// Accepts known values from the point-of-sale and gives you an AdjustedCheckValues object containing the 

    /// spend_amount, tax_amount, and exemption_amount to submit a LevelUp Complete Order API request.

    /// </summary>

    /// <param name="outstandingAmount">The current total amount of the check, including tax, in cents.</param>

    /// <param name="taxAmount">The current tax due on the check, in cents.</param>

    /// <param name="exemptAmount">The current total of exempted items on the check, in cents.</param>

    /// <param name="paymentAmount">The amount the customer would like to spend, in cents.</param>

    /// <param name="appliedDiscountAmount">The discount amount applied to the point of sale for the customer.</param>

    /// <returns>LevelUp.Pos.ProposedOrderCalculator.CalculateCompleteOrderValues</returns>

    public static AdjustedCheckValues CalculateCompleteOrderValues(

        int outstandingAmount,

        int taxAmount,

        int exemptAmount,

        int paymentAmount,

        int appliedDiscountAmount

    )

    {

        int outstandingAmountWithDiscount = outstandingAmount + Math.Abs(appliedDiscountAmount);

​

        return CalculateOrderValues(

            outstandingAmountWithDiscount,

            taxAmount,

            exemptAmount,

            paymentAmount);

    }

​

    internal static AdjustedCheckValues CalculateOrderValues(

        int outstandingAmount,

        int taxAmount,

        int exemptionAmount,

        int paymentAmount)

    {

        CheckData checkData = SanitizeData(outstandingAmount, taxAmount, exemptionAmount, paymentAmount);

​

        var adjustedTaxAmount = CalculateAdjustedTaxAmount(checkData);

​

        var adjustedExemptionAmount = CalculateAdjustedExemptionAmount(checkData);

​

        return new AdjustedCheckValues(checkData.PaymentAmount, adjustedTaxAmount, adjustedExemptionAmount);

    }

​

    internal static CheckData SanitizeData(int outstandingAmount, int taxAmount, int exemptionAmount, int paymentAmount)

    {

        var checkData = new CheckData

        {

            ExemptionAmount = exemptionAmount,

            OutstandingAmount = outstandingAmount,

            PaymentAmount = paymentAmount,

            TaxAmount = taxAmount

        };

​

        checkData.PaymentAmount = PaymentAmountCannotBeGreaterThanOutstandingAmount(

            checkData.OutstandingAmount, 

            checkData.PaymentAmount);

​

        checkData.TaxAmount = TaxAmountCannotBeGreaterThanOutstandingAmount(

            checkData.OutstandingAmount, 

            checkData.TaxAmount);

​

        checkData.ExemptionAmount = ExemptionAmountCannotBeGreaterThanPreTaxSubtotal(

            checkData.ExemptionAmount, 

            checkData.PreTaxSubtotal);

​

        return checkData;

    }

​

    /// <summary>

    /// For LevelUp Proposed/Complete Order, with partial payments, the last user to pay is responsible for paying

    /// the tax.

    /// </summary>

    /// <param name="checkData"></param>

    internal static int CalculateAdjustedTaxAmount(CheckData checkData)

    {

        if (checkData.TaxAmount > checkData.OutstandingAmount)

        {

            throw new Exception("Tax amount cannot be greater than total outstanding amount.");

        }

​

        bool isTaxFullyPaid = checkData.PaymentAmount >= checkData.OutstandingAmount;

        if (isTaxFullyPaid)

        {

            return checkData.TaxAmount;

        }

​

        return ZeroIfNegative(checkData.PaymentAmount - checkData.PreTaxSubtotal);

    }

​

    /// <summary>

    /// For LevelUp Proposed/Complete Order, with partial payments, the last user to pay bears the burden of

    /// exemption amounts. We allow anyone paying to use discount credit until the remaining amount owed is

    /// less than or equal to the amount of exempted items on the check.

    /// </summary>

    /// <param name="checkData"></param>

    internal static int CalculateAdjustedExemptionAmount(CheckData checkData)

    {

        if (checkData.ExemptionAmount > checkData.PreTaxSubtotal)

        {

            throw new Exception("Exemption amount cannot be greater that the pre-tax total on the check.");

        }

​

        bool isExemptFullyPaid = checkData.PaymentAmount >= checkData.PreTaxSubtotal;

        if (isExemptFullyPaid)

        {

            return checkData.ExemptionAmount;

        }

​

        return ZeroIfNegative(checkData.PaymentAmount - checkData.NonExemptSubtotal);

    }

​

    private static int PaymentAmountCannotBeGreaterThanOutstandingAmount(

        int outstandingAmount,

        int paymentAmount)

        => SmallerOrZeroIfNegative(outstandingAmount, paymentAmount);

​

    private static int TaxAmountCannotBeGreaterThanOutstandingAmount(int outstandingAmount, int taxAmount)

        => SmallerOrZeroIfNegative(taxAmount, outstandingAmount);

​

    private static int ExemptionAmountCannotBeGreaterThanPreTaxSubtotal(

        int exemptAmount,

        int outstandingAmount)

        => SmallerOrZeroIfNegative(exemptAmount, outstandingAmount);

​

    internal static int SmallerOrZeroIfNegative(int a, int b) => ZeroIfNegative(Math.Min(a, b));

​

    private static int ZeroIfNegative(int val) => Math.Max(0, val);

}

​

internal class PointOfSale

{

    private int StartingTotal { get; }

    private int StartingTax { get; }

    private int StartingSubtotal => StartingTotal - StartingTax;

    private decimal TaxRate => (decimal)StartingTax / (decimal)StartingSubtotal;

​

    private int TotalDiscounts { get; set; }

    private int TotalTenders { get; set; }

​

    private int AdjustedSubtotal => StartingSubtotal - TotalDiscounts;

    private decimal AdjustedSubtotalInDollars => AdjustedSubtotal / 100.0M;

    private int AdjustedTax => decimal.ToInt32(AdjustedSubtotalInDollars * TaxRate * 100.0M);

​

    /// <summary>

    /// The current amount, in cents, owed by a customer, at any given moment.

    /// </summary>

    public int TotalOutstandingAmount => AdjustedSubtotal + AdjustedTax - TotalTenders;

​

    /// <summary>

    /// The total amount of tax due, in cents, on a check, at any given moment.

    /// </summary>

    public int TotalTaxAmount => AdjustedTax;

​

    /// <summary>

    /// By passing in a total amount owed and the tax due on a check, we can simulate a simplistic point of sale

    /// for testing purposes.

    /// </summary>

    /// <param name="total">The intial amount due on the check including tax, in cents.</param>

    /// <param name="tax">The initial tax due on the check, in cents.</param>

    public PointOfSale(int total, int tax)

    {

        if (total == tax)

        {

            throw new Exception($"The total must be greater than tax (a subtotal amount must exist). If the intent " +

                                $"is to test a partial payment scenario, use the ${nameof(ApplyTender)} method to " +

                                $"reduce the outstanding balance.");

        }

​

        StartingTotal = total;

        StartingTax = tax;

    }

​

    /// <summary>

    /// Applies a pre-tax discount to the check.

    /// </summary>

    /// <param name="discountAmountInCents"></param>

    public void ApplyDiscount(int discountAmountInCents) => TotalDiscounts += discountAmountInCents;

​

    /// <summary>

    /// Apply a standard tender to the check. e.g. Cash, Credit Card, etc.

    /// </summary>

    /// <param name="tenderAmountInCents"></param>

    public void ApplyTender(int tenderAmountInCents) => TotalTenders += tenderAmountInCents;

}