using System;

using System.Collections.Generic;

using System.Linq;

using System.Text.Json;

public class Program

{

    public class CustomerPowerConsumption : ICloneable

    {

        public long Id {get; set;}

        public DateTime Date {get; set;}

        public double KWhBase {get; set;}

        public double KWhBaseUsed {get; set;}

        public double KWhRollover {get; set;}

        public double KWhRolloverUsed {get; set;}

        // NEW PARAMETERS

        public double KWhAdminRollover {get; set;}

        public double KWhAdminRolloverUsed {get; set;}

        public long Consumption {get; set;}

        public double KWhRemaining { get => KWhBaseRemaining + KWhRolloverRemaining + KWhAdminRolloverRemaining; }

        public double KWhBaseRemaining { get => KWhBase - KWhBaseUsed; }

        public double KWhRolloverRemaining { get => KWhRollover - KWhRolloverUsed; }

        public double KWhAdminRolloverRemaining { get => KWhAdminRollover - KWhAdminRolloverUsed; }

        public override string ToString()

        {

            return "Consumption info: " +

                "\nId: " + Id + 

                "\nDate: " + Date.ToString() + 

                "\nKwhBase: " + KWhBase +

                "\nKWhBaseUsed: " + KWhBaseUsed +

                "\nKWhRollover: " + KWhRollover +

                "\nKWhRolloverUsed: " + KWhRolloverUsed +

                "\nKWhAdminRollover: " + KWhAdminRollover +

                "\nKWhAdminRolloverUsed: " + KWhAdminRolloverUsed +

                "\nConsumption: " + Consumption + " ----- out of " + (KWhBase + KWhRollover + KWhAdminRolloverUsed) +

                "\nKWhRemaining: " + KWhRemaining +

                "\nKWhBaseRemaining: " + KWhBaseRemaining +

                "\nKWhRolloverRemaining: " + KWhRolloverRemaining +

                "\nKWhAdminRolloverRemaining: " + KWhAdminRolloverRemaining +

                "\n ============================================= \n\n";    

        }

        public object Clone()

        {

            return this.MemberwiseClone();

        }

    }

    public class CustomerPowerPackage

    {

        public long Id {get; set;}

        public double KWhBase {get; set;}

        public double KWhRollover {get; set;}

        public double KWhAdminRollover {get; set;}

        public DateTime Start {get; set;}

        public DateTime End {get; set;}

        public List<CustomerPowerConsumption> CustomerPowerConsumptions {get; set;} = new List<CustomerPowerConsumption>();

        public override string ToString()

        {

            return "PowerPackage info: " +

                "\nId: " + Id + 

                "\nKwhBase: " + KWhBase +

                "\nKWhRollover: " + KWhRollover +

                "\nKWhAdminRollover: " + KWhAdminRollover +

                "\nStart: " + Start +

                "\nEnd: " + End +

                "\n ============================================= \n\n";    

        }

    }

    public class ChargingTransaction

    {

        public long Id {get; set;}

        public DateTime EndDate {get; set;} // Just taking the end date since thats the date that matters to us

        public double ConsumedKwh {get; set;}

    }

    // GLOBAL VARIABLES

    private static List<ChargingTransaction> _allTransactions = new List<ChargingTransaction>();

    private static List<CustomerPowerPackage> _allPowerPackages = new List<CustomerPowerPackage>();

    public static void Main()

    {

        DateTime startDate = new DateTime(2022,9,01);

        CreateRandomTransactions(startDate);

        CreateCustomerPowerPackages(startDate, 700, 60, 40);

        var powerPackagesJson = JsonSerializer.Serialize(_allPowerPackages);

        var transactionsJson = JsonSerializer.Serialize(_allTransactions);

​

        Console.WriteLine("Power packages with consumptions: \n " + powerPackagesJson);

        Console.WriteLine("\n\n\nTransactions: \n " + transactionsJson);

        Console.WriteLine("\n\n\tCOMPLETED");

    }

    // Create random transactions to stimulate completed chargings.

    private static void CreateRandomTransactions(DateTime date)

    {

        int idCounter = 1;

        while (date <= DateTime.Now)

        {

            // Create the random consumption value

            Random r = new Random();

            int range = 90;

            long randomConsumption = (long)(r.NextDouble() * range);

            _allTransactions.Add(new ChargingTransaction

                                 {

                                     Id = idCounter++,

                                     EndDate = date,

                                     ConsumedKwh = randomConsumption

                                 });

            date = date.AddDays(1);

        }

    }

    // Create the customer power packages (AKA periods)

    private static void CreateCustomerPowerPackages(DateTime date, double baseKwh, double rollover, double adminRollover)

    {

        int idCounter = 1;

        while (date <= DateTime.Now) 

        {

            var previousPowerPackage = _allPowerPackages.FirstOrDefault(cpp => cpp.Start == date.AddMonths(-1));

​

            CustomerPowerPackage createdPowerPackage = new CustomerPowerPackage 

            {

                Id = idCounter++,

                KWhBase = baseKwh,

                KWhRollover = rollover,

                KWhAdminRollover = adminRollover,

                Start = date,

                End = date.AddMonths(1).AddDays(-1),

            };

            // Transfer over last periods information to the current period (rollover etc)

            if (previousPowerPackage is not null)

            {

                var lastConsumptionOfPreviousPackage = previousPowerPackage.CustomerPowerConsumptions.OrderByDescending(cpp => cpp.Date).First();

                var totalRollover = lastConsumptionOfPreviousPackage.KWhBaseRemaining + lastConsumptionOfPreviousPackage.KWhRolloverRemaining;

                var maxRollover = createdPowerPackage.KWhBase * 3;

​

                // Normal rollover can have at max 3 times the value of the base

                createdPowerPackage.KWhRollover = maxRollover <= totalRollover ? maxRollover : totalRollover;

​

                // Admin rollover does not get trimmed and can be transfered between periods without rules.

                createdPowerPackage.KWhAdminRollover = lastConsumptionOfPreviousPackage.KWhAdminRolloverRemaining;

                // If the previous period had over consumption we need to redact it from the current periods base

                if (lastConsumptionOfPreviousPackage.KWhRemaining < 0)

                {

                    createdPowerPackage.KWhBase = createdPowerPackage.KWhBase + lastConsumptionOfPreviousPackage.KWhRemaining;

                    createdPowerPackage.KWhAdminRollover = 0;

                    createdPowerPackage.KWhRollover = 0;

                }

​

            }

            _allPowerPackages.Add(createdPowerPackage);

            // Create the "days" for the period

            createdPowerPackage.CustomerPowerConsumptions.AddRange(CreateListOfPowerConsumptions(createdPowerPackage));

            date = date.AddMonths(1);

        }

    }

    // Create the customer power consumptions (AKA days in period)

    private static List<CustomerPowerConsumption> CreateListOfPowerConsumptions(CustomerPowerPackage powerPackage) 

    {

        List<CustomerPowerConsumption> consumptions = new List<CustomerPowerConsumption>();

        DateTime date = powerPackage.Start;

        while (date <= powerPackage.End) 

        {

            CustomerPowerConsumption newPowerConsumption = new CustomerPowerConsumption

            {

                Date = date,

                KWhBase = powerPackage.KWhBase,

                KWhBaseUsed = 0,

                KWhRollover = powerPackage.KWhRollover,

                KWhRolloverUsed = 0,

                KWhAdminRollover = powerPackage.KWhAdminRollover,

                KWhAdminRolloverUsed = 0,

                Consumption = 0

            };

            // Carry over the information of the previous day

            var previousPowerConsumption = consumptions.FirstOrDefault(c => c.Date == date.AddDays(-1));

            if (previousPowerConsumption is not null)

            {

                newPowerConsumption.Consumption = previousPowerConsumption.Consumption;

                newPowerConsumption.KWhAdminRolloverUsed = previousPowerConsumption.KWhAdminRolloverUsed;

                newPowerConsumption.KWhRolloverUsed = previousPowerConsumption.KWhRolloverUsed;

                newPowerConsumption.KWhBaseUsed = previousPowerConsumption.KWhBaseUsed;

            }

            // Apply the consumption

            newPowerConsumption = CalculateAndUpdatePowerConsumption(newPowerConsumption);

            consumptions.Add(newPowerConsumption);

            date = date.AddDays(1);

        }

        return consumptions;

    }

    private static CustomerPowerConsumption CalculateAndUpdatePowerConsumption(CustomerPowerConsumption powerConsumption) 

    {

        // Sum all the transactions made on the date

        double consumed = _allTransactions.Where(t => t.EndDate == powerConsumption.Date).Sum(t => t.ConsumedKwh);

        powerConsumption.Consumption = powerConsumption.Consumption + (long)consumed;

​

        /*

        *   The rules are:

        *   - First kwhBase finishes

        *   - Second kwhAdminRollover finishes

        *   - Third kwhRollover finishes

        *   - Remaining gets reduced from the kwhBase (even if it is leading to negative)

        */

        powerConsumption.KWhBaseUsed = CalculateConsumedAmount(ref consumed, powerConsumption.KWhBaseUsed, powerConsumption.KWhBaseRemaining, powerConsumption.KWhBase);

        powerConsumption.KWhAdminRolloverUsed = CalculateConsumedAmount(ref consumed, powerConsumption.KWhAdminRolloverUsed, powerConsumption.KWhAdminRolloverRemaining, powerConsumption.KWhAdminRollover);

        powerConsumption.KWhRolloverUsed = CalculateConsumedAmount(ref consumed, powerConsumption.KWhRolloverUsed, powerConsumption.KWhRolloverRemaining, powerConsumption.KWhRollover);

​

​

        // If there is still consumption left, push the base towards negative values

        if (consumed > 0)

        {

            powerConsumption.KWhBaseUsed = consumed + powerConsumption.KWhBaseUsed;

        }

        return powerConsumption;

    }

    // Consumed: It is a reference since we want to update the amount of consumed and reflect the value of it for the part that called this method. It is the value that should be redacted from our power.

    // Used: This is the amount that is used in the package right now for the SPECIFIC field (so not total used of entire package).

    // Remaining: This is the amount that is remaining in the package right now for the SPECIFIC field (so not total remaining of entire package).

    // BaseAmount: This is the amount that is the base of in the package right now for the SPECIFIC field (so not total base of the entire package).

    // @return: Returns the new amount for that SPECIFIC field of the total used (not total used of the entire package).

    private static double CalculateConsumedAmount(ref double consumed, double used, double remaining, double baseAmount) 

    {

        // We don't want to handle values going to negative here.

        if (consumed > 0 && remaining >= 0)

        {

            if (remaining <= consumed)

            {

                // This consumption will finish the whole capacity of kwh

                consumed = consumed - remaining;

                used = baseAmount;

            }

            else

            {

                // This consumption does not use the entirety of the kwh (from the specific field) and we can just finish the calculations by settings the consumed to zero

                used = consumed + used;

                consumed = 0;

            }

        }

        return used;

    }

    // Packages: All the packages that we want to update

    /*

    public static List<CustomerPowerPackage> ReCalculatePackageAndConsumptions(List<CustomerPowerPackage> packages)

    {

        foreach(var package in packages)

        {

            foreach(var powerConsumption in package.CustomerPowerConsumptions)

            {

​

                powerConsumption CalculateAndUpdatePowerConsumption(powerConsumption);

            }

        }

    }

    */

}