using Elwig.Helpers;
using Elwig.Helpers.Billing;
using Microsoft.Data.Sqlite;
using System.Reflection;

namespace Tests.HelperTests {
    [TestFixture]
    public class BillingTest {

        private const int Year1 = 2020, Year2 = 2020;
        private const int MgNr1 = 101, MgNr2 = 102, MgNr3 = 103, MgNr4 = 104;

        private SqliteConnection? Connection;

        [OneTimeSetUp]
        public async Task SetupDatabase() {
            Connection = await AppDbContext.ConnectAsync();
            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.BillingInsert.sql");
        }

        [OneTimeTearDown]
        public async Task TeardownDatabase() {
            if (Connection == null) return;
            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.BillingDelete.sql");
            await Connection.DisposeAsync();
            Connection = null;
        }

        [TearDown]
        public async Task CleanupDatabasePayment() {
            if (Connection == null) return;
            await AppDbContext.ExecuteBatch(Connection, """
                DELETE FROM credit;
                DELETE FROM delivery_part_bucket;
                DELETE FROM payment_variant;
                """);
        }

        private Task<Dictionary<string, AreaComBucket>> GetMemberAreaCommitmentBuckets(int year, int mgnr) {
            var ctx = new AppDbContext();
            return ctx.GetMemberAreaCommitmentBuckets(year, mgnr, Connection);
        }

        private Task<Dictionary<string, int>> GetMemberDeliveryBuckets(int year, int mgnr) {
            var ctx = new AppDbContext();
            return ctx.GetMemberDeliveryBuckets(year, mgnr, Connection);
        }

        private Task<Dictionary<string, int>> GetMemberPaymentBuckets(int year, int mgnr) {
            var ctx = new AppDbContext();
            return ctx.GetMemberPaymentBuckets(year, mgnr, Connection);
        }

        private async Task<Dictionary<(string, string), int>> GetMemberDeliveryPrices(int year, int mgnr) {
            var buckets = new Dictionary<(string, string), int>();
            using (var cmd = Connection!.CreateCommand()) {
                cmd.CommandText = $"""
                    SELECT lsnr || '/' ||  d.dpnr, d.sortid || b.discr, price
                    FROM v_delivery d
                        LEFT JOIN payment_delivery_part_bucket p ON (p.year, p.did, p.dpnr) = (d.year, d.did, d.dpnr)
                        LEFT JOIN delivery_part_bucket b ON (b.year, b.did, b.dpnr, b.bktnr) = (p.year, p.did, p.dpnr, p.bktnr)
                    WHERE d.year = {year} AND mgnr = {mgnr}
                    """;
                using var reader = await cmd.ExecuteReaderAsync();
                while (await reader.ReadAsync()) {
                    var lsnr = reader.GetString(0);
                    var bucket = reader.GetString(1);
                    buckets[(lsnr, bucket)] = reader.GetInt32(2);
                }
            }
            return buckets;
        }

        private static string FormatBuckets(Dictionary<string, int> buckets) {
            return string.Join("\r\n", buckets.OrderBy(b => b.Key));
        }

        private static string FormatBuckets(Dictionary<(string, string), int> buckets) {
            return string.Join("\r\n", buckets.OrderBy(b => b.Key));
        }

        private static string FormatBuckets(Dictionary<string, AreaComBucket> buckets) {
            return string.Join("\r\n", buckets.OrderBy(b => b.Key));
        }

        [Test]
        public async Task Test_01_NoActiveAreaCommitments() {
            if (Connection == null) return;
            var data = """
                {
                  "mode": "elwig",
                  "version": 1,
                  "payment": {
                    "GV/": "curve:0",
                    "GV/B": "curve:1",
                    "GV/K": "curve:2"
                  },
                  "quality": {"WEI": 0.1},
                  "curves": [{
                    "id": 0,
                    "mode": "oe",
                    "data": {"15kmw": 0.5},
                    "geb": 0.1
                  }, {
                    "id": 1,
                    "mode": "oe",
                    "data": {"15kmw": 0.54},
                    "geb": 0.1
                  }, {
                    "id": 2,
                    "mode": "oe",
                    "data": {"15kmw": 0.61},
                    "geb": 0.1
                  }]
                }
                """;
            await AppDbContext.ExecuteBatch(Connection, $"""
                INSERT INTO payment_variant (year, avnr, name, date, transfer_date, test_variant, calc_time, data) VALUES
                (2020, 1, 'Test', '2021-01-15', NULL, TRUE, NULL, '{data}');
                """);

            int mgnr = MgNr1, year = Year1;
            var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
            Assert.That(FormatBuckets(areaCom), Is.EqualTo(""));
            var delivery = await GetMemberDeliveryBuckets(year, mgnr);
            Assert.That(FormatBuckets(delivery), Is.EqualTo("""
                [GV, 16000]
                [GV_, 1000]
                [GVB, 8000]
                [GVK, 4000]
                """));

            BillingVariant b = new(year, 1);
            await b.CalculateBuckets(false, false, false);
            var payment = await GetMemberPaymentBuckets(year, mgnr);
            Assert.That(FormatBuckets(payment), Is.EqualTo("""
                [GV_, 17000]
                """));

            await b.Calculate();
            var prices = await GetMemberDeliveryPrices(year, mgnr);
            Assert.That(FormatBuckets(prices), Is.EqualTo("""
                [(20201001X001/1, GV_), 6100]
                [(20201001X001/2, GV_), 5000]
                [(20201001X002/1, GV_), 5400]
                [(20201001X002/2, GV_), 5400]
                [(20201001X003/1, GV_), 1000]
                [(20201001X003/2, GV_), 5000]
                """));
        }
    }
}