using Microsoft.Data.Sqlite;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Elwig.Helpers.Billing {
    public class Billing {

        protected readonly int Year;
        protected readonly AppDbContext Context;
        protected readonly Dictionary<string, string> Attributes;
        protected readonly Dictionary<string, (decimal?, decimal?)> Modifiers;
        protected readonly Dictionary<string, (string, string?, string?, string?, int?, int?, decimal?)> AreaComTypes;

        public Billing(int year) {
            Year = year;
            Context = new AppDbContext();
            Attributes = Context.WineAttributes.ToDictionary(a => a.AttrId, a => a.Name);
            Modifiers = Context.Modifiers.Where(m => m.Year == Year).ToDictionary(m => m.ModId, m => (m.Abs, m.Rel));
            AreaComTypes = Context.AreaCommitmentTypes.ToDictionary(v => v.VtrgId, v => (v.SortId, v.AttrId1, v.AttrId2, v.Discriminator, v.MinKgPerHa, v.MaxKgPerHa, v.PenaltyAmount));
        }

        public async Task FinishSeason() {
            using var cnx = await AppDbContext.ConnectAsync();
            using (var cmd = cnx.CreateCommand()) {
                cmd.CommandText = $"""
                    UPDATE season
                    SET (start_date, end_date) = (SELECT MIN(date), MAX(date) FROM delivery WHERE year = {Year}),
                        bin_1_name = 'gebunden mit zwei Attributen',
                        bin_2_name = 'gebunden mit (erstem) Attribut',
                        bin_3_name = 'gebunden mit zweitem Attribut',
                        bin_4_name = 'gebunden ohne Attribut',
                        bin_5_name = 'ungebunden'
                    WHERE year = {Year}
                    """;
                await cmd.ExecuteNonQueryAsync();
            }
        }

        public async Task CalculateBins() {
            var inserts = new List<(int, int, int, int, int, int, int)>();
            foreach (var mgnr in Context.Members.Where(m => m.IsActive).OrderBy(m => m.MgNr).Select(m => m.MgNr)) {
                inserts.AddRange(await CalculateMemberBins(mgnr));
            }
            using var cnx = await AppDbContext.ConnectAsync();
            using var cmd = cnx.CreateCommand();
            cmd.CommandText = $"""
                INSERT INTO delivery_part_bin (year, did, dpnr, bin_1, bin_2, bin_3, bin_4, bin_5)
                VALUES {string.Join(",\n       ", inserts.Select(i => $"({Year}, {i.Item1}, {i.Item2}, {i.Item3}, {i.Item4}, {i.Item5}, {i.Item6}, {i.Item7})"))}
                ON CONFLICT DO UPDATE
                SET bin_1 = excluded.bin_1,
                    bin_2 = excluded.bin_2,
                    bin_3 = excluded.bin_3,
                    bin_4 = excluded.bin_4,
                    bin_5 = excluded.bin_5,
                    bin_6 = NULL,
                    bin_7 = NULL,
                    bin_8 = NULL,
                    bin_9 = NULL;
                """;
            await cmd.ExecuteNonQueryAsync();
        }

        public static async Task<(Dictionary<string, int>, Dictionary<string, int>)> GetMemberRightsObligations(int mgnr, int year, SqliteConnection cnx) {
            var rights = new Dictionary<string, int>();
            var obligations = new Dictionary<string, int>();

            using var cmd = cnx.CreateCommand();
            cmd.CommandText = $"""
                SELECT t.vtrgid,
                       SUM(COALESCE(area * min_kg_per_ha, 0)) / 10000 AS min_kg,
                       SUM(COALESCE(area * max_kg_per_ha, 0)) / 10000 AS max_kg
                FROM area_commitment c
                JOIN area_commitment_type t ON t.vtrgid = c.vtrgid
                WHERE mgnr = {mgnr} AND (year_from IS NULL OR year_from <= {year}) AND (year_to IS NULL OR year_to >= {year})
                GROUP BY t.vtrgid
                ORDER BY LENGTH(t.vtrgid) DESC, t.vtrgid
                """;

            var reader = await cmd.ExecuteReaderAsync();
            while (await reader.ReadAsync()) {
                var vtrgid = reader.GetString(0);
                obligations[vtrgid] = reader.GetInt32(1);
                rights[vtrgid] = reader.GetInt32(2);
            }

            return (rights, obligations);
        }

        public static async Task<Dictionary<string, int>> GetMemberBinWeights(int mgnr, int year, SqliteConnection cnx) {
            var bins = new Dictionary<string, int>();

            using var cmd = cnx.CreateCommand();
            cmd.CommandText = $"""
                SELECT bin, weight
                FROM v_bin
                WHERE (year, mgnr) = ({year}, {mgnr})
                """;

            var reader = await cmd.ExecuteReaderAsync();
            while (await reader.ReadAsync()) {
                var bin = reader.GetString(0);
                bins[bin] = reader.GetInt32(1);
            }

            return bins;
        }

        protected async Task<List<(int, int, int, int, int, int, int)>> CalculateMemberBins(int mgnr) {
            using var cnx = await AppDbContext.ConnectAsync();
            var (rights, obligations) = await GetMemberRightsObligations(mgnr, Year, cnx);

            var deliveries = new List<(int, int, string, int, double, string, string[], string[])>();
            using (var cmd = cnx.CreateCommand()) {
                cmd.CommandText = $"""
                    SELECT did, dpnr, sortid, weight, kmw, qualid, attributes, modifiers
                    FROM v_delivery
                    WHERE (year, mgnr) = ({Year}, {mgnr})
                    ORDER BY sortid, abgewertet ASC, LENGTH(attributes) DESC, COALESCE(attributes, '~'), kmw DESC, lsnr, dpnr
                    """;
                var reader = await cmd.ExecuteReaderAsync();
                while (await reader.ReadAsync()) {
                    deliveries.Add((
                        reader.GetInt32(0), reader.GetInt32(1), reader.GetString(2), reader.GetInt32(3),
                        reader.GetDouble(4), reader.GetString(5),
                        reader.IsDBNull(6) ? Array.Empty<string>() : reader.GetString(6).Split(",").Order().ToArray(),
                        reader.IsDBNull(7) ? Array.Empty<string>() : reader.GetString(7).Split(",").Order().ToArray()
                    ));
                }
            }

            List<(int, int, int, int, int, int, int)> inserts = new();
            foreach (var (did, dpnr, sortid, weight, kmw, qualid, attributes, modifiers) in deliveries) {
                if (qualid == "WEI" || qualid == "RSW" || qualid == "LDW") {
                    // Nicht mindestens Qualitätswein (QUW) -> ungebunden
                    inserts.Add((did, dpnr, 0, 0, 0, 0, weight));
                    continue;
                }

                if (attributes.Length > 2)
                    throw new NotSupportedException();

                int w = weight;
                int[] b = new int[4];
                foreach (var p in Utils.Permutate(attributes)) {
                    var c = p.Count();
                    var key = sortid + string.Join("", p);
                    if (rights.ContainsKey(key)) {
                        int i = 0;
                        if (c == 1) {
                            i = (p.ElementAt(0) == attributes[0]) ? 1 : 2;
                        } else if (c == 0) {
                            i = b.Length - 1;
                        }
                        var v = Math.Max(0, Math.Min(rights[key], w));
                        b[i] += v;
                        rights[key] -= v;
                        w -= v;
                    }
                }
                inserts.Add((did, dpnr, b[0], b[1], b[2], b[3], weight - b[0] - b[1] - b[2] - b[3]));
            }
            return inserts;
        }
    }
}