using DD.Persistence.Database.Entity;
using Microsoft.EntityFrameworkCore;
using System.Diagnostics;
using System.IO;

namespace DD.Persistence.TestTelemetryStress;

internal class Program_v2
{
    record TestDataItem(TagBag[] TagBags, TagSetValue[] TagSetValue);
    enum Table { TagBag, TagSetValue }
    enum Action { insert, select }

    record Log(
        Table Table,
        Action Action,
        DateTimeOffset Timestamp,
        TimeSpan TimeSpan,
        int tableLength,
        int count);

    static Random random = new Random((int)(DateTimeOffset.UtcNow.Ticks % 0x7FFFFFFF));

    static void Main(string[] args)
    {
        /* Цель теста сравнить время отклика БД с телеметрией за все бурение
         * по 2м схемам хранения:
         * - TagSetValue - строка таблицы БД - 14 значений с одной отметкой времени.
         * - TagBag - строка таблицы БД - 1 значение с отметкой времени и id параметра, для записи одной телеметрии используется 14 строк.
         * Данные генерируются одинаковые и за все бурение - 30 дней *24 часа * 60 минут * 60 сек
         * 
         * Вставка производится порциями по 172_800 записей (2 дня)
         * Замеряется время каждой вставки для построения графика. Таблицы вставки чередуются.
         * 
         * После вставки контекст уничтожается и делается пауза
         * 
         * Создается новые контексты для тестирования каждой выборки по каждой таблице по отдельности.
         * Параметры выборок для тестирования:
         * - 10 раз за произвольные 10 минут, интервалы распределены по всему диапазону дат
         * - 10 раз за произвольные 60 минут, интервалы распределены по всему диапазону дат
         * - 10 раз за произвольные 24*60 минут, интервалы распределены по всему диапазону дат
         */
        var begin = DateTimeOffset.Now;
        Console.WriteLine($"Started at {begin}");
        var insertLogs = FillDB();
        Pause();
        var selectLogs = TestSelect();
        var logs = insertLogs.Union(selectLogs);

        var end = DateTimeOffset.Now;
        Console.WriteLine($"complete at {end}, estimate {end - begin}");

        AnalyzeAndExportLogs(logs);

        /* Анализ логов:
         * - не замечено замедление вставки при увеличении размера таблиц 2592000 записей
         * - размер таблиц в БД TagBag - 778Мб TagSetValue - 285Мб. В 2,73 раз больше
         * - время вставки всех чанков TagBag - 2м11с,  TagSetValue - 3м40с
         * - время выборки из TagBag 21.69c (256180 записей) на 65% медленнее времени выборки из TagSetValue 13,11с (256180 записей)
         * Вывод: приемлемо
         */
    }

    private static void AnalyzeAndExportLogs(IEnumerable<Log> logs)
    {
        var orderedLogs = logs
            .OrderBy(l => l.Action)
            .ThenBy(l => l.Table)
            .ThenBy(l => l.Timestamp);

        var groups = orderedLogs
            .GroupBy(log => new { log.Action , log.Table })
            .OrderBy(group => group.Key.Action)
            .ThenBy(group => group.Key.Table);

        using var analysisStream = File.CreateText($"Analysis_{DateTime.Now:yyyy-MM-dd-HH-mm-ss}.csv");

        analysisStream.WriteLine("{Table}, {Action}, Sum(Time), Sum(Count), Max(TableLength)");

        foreach (var group in groups)
        {
            var max = group.Max(i => i.tableLength);
            var count = group.Sum(i => i.count);
            var timeMs = group.Sum(i => i.TimeSpan.TotalMilliseconds);
            var time = TimeSpan.FromMilliseconds(timeMs);
            var line = $"{group.Key.Table}, {group.Key.Action}, {time}, {count}, {max}";
            analysisStream.WriteLine(line);
        }
        
        analysisStream.WriteLine(string.Empty);
        analysisStream.WriteLine("{Table}, {Action}, Avg(Time), Avg(Count), Max(TableLength)");

        foreach (var group in groups.Where(g => g.Key.Action == Action.select))
        {
            var subGroups = group.GroupBy(i => Math.Round( 0.01d * i.count));

            foreach (var subGroup in subGroups) 
            {
                var max = subGroup.Max(i => i.tableLength);
                var count = subGroup.Average(i => i.count);
                var timeMs = subGroup.Average(i => i.TimeSpan.TotalMilliseconds);
                var time = TimeSpan.FromMilliseconds(timeMs);
                var line = $"{group.Key.Table}, {group.Key.Action}, {time}, {count}, {max}";
                analysisStream.WriteLine(line);
            }            
        }

        analysisStream.WriteLine(string.Empty);
        analysisStream.WriteLine("Table, Action, Time, Count, TableLength");

        foreach (var log in orderedLogs)
        {
            analysisStream.WriteLine($"{log.Table}, {log.Action}, {log.TimeSpan}, {log.count}, {log.tableLength}");
        }
    }

    private static Log[] FillDB()
    {
        var begin = DateTimeOffset.UtcNow;
        var increment = TimeSpan.FromSeconds(1);
        var count = 30 * 24 * 60 * 60;
        var logStopwatch = Stopwatch.StartNew();
        var data = GenerateData(count, begin, increment);
        Console.WriteLine($"Data[{data.Length}] generated {logStopwatch.Elapsed}");

        logStopwatch.Restart();
        using var db = GetDb();
        db.Database.EnsureDeleted();
        db.Database.EnsureCreated();
        Console.WriteLine($"Database recreated {logStopwatch.Elapsed}");


        var tagBagSet = db.Set<TagBag>();
        var tagSetValueSet = db.Set<TagSetValue>();

        var tagBagInsertedCount = 0;
        var tagSetValueInsertedCount = 0;
        var logs = new List<Log>(data.Length * 2);

        for (var i = 0; i < data.Length; i++) 
        {
            var chunk = data[i];
            var inserted = 0;

            var stopwatch = Stopwatch.StartNew();
            tagSetValueSet.AddRange(chunk.TagSetValue);
            inserted = db.SaveChanges();
            logs.Add(new Log(Table.TagSetValue, Action.insert, DateTimeOffset.UtcNow, stopwatch.Elapsed, tagBagInsertedCount, inserted));
            tagBagInsertedCount += inserted;
            db.ChangeTracker.Clear();

            Console.WriteLine($"chunk {i} of {data.Length} TagSetValue[{chunk.TagSetValue.Length}] added {stopwatch.Elapsed}");
            stopwatch.Restart();

            tagBagSet.AddRange(chunk.TagBags);
            inserted = db.SaveChanges();
            logs.Add(new Log(Table.TagBag, Action.insert, DateTimeOffset.UtcNow, stopwatch.Elapsed, tagSetValueInsertedCount, inserted));
            tagSetValueInsertedCount += inserted;
            db.ChangeTracker.Clear();

            Console.WriteLine($"chunk {i} of {data.Length} TagBags[{chunk.TagBags.Length}] added {stopwatch.Elapsed}");
        }

        return logs.ToArray();
    }

    private static void Pause()
    {
        GC.Collect();
        Thread.Sleep(1000);
    }

    private static Log[] TestSelect()
    {
        var testDateRanges = GetTestDateRanges();
        var logs1 = TestSelect<TagSetValue>(Table.TagSetValue, testDateRanges);
        var logs2 = TestSelect<TagBag>(Table.TagBag, testDateRanges);
        return [.. logs1, .. logs2];
    }

    private static Log[] TestSelect<T>(Table table, (DateTimeOffset begin, DateTimeOffset end)[] ranges)
        where T : class, ITimestamped
    {
        using var db = GetDb();
        var dbSet = db.Set<T>();
        var totalCount = dbSet.Count();

        var logs = new List<Log>(ranges.Length);
        
        foreach (var range in ranges)
        {
            var stopwatch = Stopwatch.StartNew();
            var selected = dbSet
                .Where(e => e.Timestamp > range.begin)
                .Where(e => e.Timestamp < range.end)
                .ToArray();
            var count = selected.Length;
            var maxTime = selected.Max(e => e.Timestamp);
            logs.Add(new Log(table, Action.select, DateTimeOffset.UtcNow, stopwatch.Elapsed, totalCount, count));
        }
        return logs.ToArray();
    }

    private static (DateTimeOffset begin, DateTimeOffset end)[] GetTestDateRanges()
    {
        using var db = GetDb();

        var dbSet1 = db.Set<TagSetValue>();
        var min1 = dbSet1.Min(e => e.Timestamp);
        var max1 = dbSet1.Max(e => e.Timestamp);

        var dbSet2 = db.Set<TagBag>();
        var min2 = dbSet2.Min(e => e.Timestamp);
        var max2 = dbSet2.Max(e => e.Timestamp);

        var min = min1 < min2 ? min1 : min2;
        var max = max1 > max2 ? max1 : max2;

        var list1 = CalculateRanges(min, max, TimeSpan.FromMinutes(60), 10);
        var list2 = CalculateRanges(min, max, TimeSpan.FromMinutes(12 * 60), 10);
        var list3 = CalculateRanges(min, max, TimeSpan.FromMinutes(24 * 60), 10);

        return [..list1, ..list2, ..list3];
    }

    private static (DateTimeOffset begin, DateTimeOffset end)[] CalculateRanges(DateTimeOffset min, DateTimeOffset max, TimeSpan range, int count)
    {
        if (max - min < range)
            throw new ArgumentException("max - min < range", nameof(range));

        var result = new (DateTimeOffset begin, DateTimeOffset end)[count];
        var max1 = max - range;
        var delta = max1 - min;
        var step = delta / count;
        for (var i = 0; i < count; i++) 
        {
            var b = min + i * step;
            var e = b + range;
            result[i] = (b, e);
        }
        return result;
    }

    private static DbContext GetDb()
    {
        var factory = new Database.Postgres.DesignTimeDbContextFactory();
        var context = factory.CreateDbContext(Array.Empty<string>());
        return context;
    }

    private static TestDataItem[] GenerateData(int count, DateTimeOffset begin, TimeSpan increment)
    {
        var chunkLimit = 172_800;
        var chunks = new List<TestDataItem>((count + chunkLimit) / chunkLimit);

        for (int i = 0; i < count; i += chunkLimit)
        {
            var item = GenerateDataChunk(begin, increment, chunkLimit);
            chunks.Add(item);
            begin += increment * chunkLimit;
        }

        return chunks.ToArray();
    }

    private static TestDataItem GenerateDataChunk(DateTimeOffset begin, TimeSpan increment, int chunkLimit)
    {
        List<TagBag> tagBags = [];
        List<TagSetValue> tagSetValue = [];
        for (int i = 0; i < chunkLimit; i++)
        {
            var tagSet = GenerateTagSetValue(begin);
            tagSetValue.Add(tagSet);

            var tagBag = MakeTagBag(tagSet);
            tagBags.Add(tagBag);
            begin += increment;
        }

        return new(tagBags.ToArray(), tagSetValue.ToArray());
    }

    private static TagSetValue GenerateTagSetValue(DateTimeOffset begin)
    {
        var result = new TagSetValue
        {
            Timestamp = begin,
            WellDepth = 100f * random.NextSingle(),
            BitDepth = 100f * random.NextSingle(),
            BlockPosition = 100f * random.NextSingle(),
            BlockSpeed = 100f * random.NextSingle(),
            Pressure = 100f * random.NextSingle(),
            AxialLoad = 100f * random.NextSingle(),
            HookWeight = 100f * random.NextSingle(),
            RotorTorque = 100f * random.NextSingle(),
            RotorSpeed = 100f * random.NextSingle(),
            Flow = 100f * random.NextSingle(),
            Mse = random.Next(),
            Mode = random.Next(),
            Pump0Flow = 100f * random.NextSingle(),
            Pump1Flow = 100f * random.NextSingle(),
            Pump2Flow = 100f * random.NextSingle(),
        };
        return result;
    }

    private static Guid BagId = Guid.NewGuid();
    private static TagBag MakeTagBag(TagSetValue tagSet)
    {
        TagBag data = new()
        {
            BagId = BagId,
            Timestamp = tagSet.Timestamp,
            Values =
            [
                tagSet.WellDepth,
                tagSet.BitDepth,
                tagSet.BlockPosition,
                tagSet.BlockSpeed,
                tagSet.Pressure,
                tagSet.AxialLoad,
                tagSet.HookWeight,
                tagSet.RotorTorque,
                tagSet.RotorSpeed,
                tagSet.Flow,
                tagSet.Mse,
                tagSet.Mode,
                tagSet.Pump0Flow,
                tagSet.Pump1Flow,
                tagSet.Pump2Flow,
            ],
            //new Dictionary<string, object>()
            //{
            //    {"WellDepth", tagSet.WellDepth },
            //    {"BitDepth", tagSet.BitDepth},
            //    {"BlockPosition", tagSet.BlockPosition},
            //    {"BlockSpeed", tagSet.BlockSpeed},
            //    {"Pressure", tagSet.Pressure},
            //    {"AxialLoad", tagSet.AxialLoad},
            //    {"HookWeight", tagSet.HookWeight},
            //    {"RotorTorque", tagSet.RotorTorque},
            //    {"RotorSpeed", tagSet.RotorSpeed},
            //    {"Flow", tagSet.Flow},
            //    {"Mse", tagSet.Mse},
            //    {"Pump0Flow", tagSet.Pump0Flow},
            //    {"Pump1Flow", tagSet.Pump1Flow},
            //    {"Pump2Flow", tagSet.Pump2Flow},
            //}

        };
        return data;
    }

}