using System.Diagnostics;
using Microsoft.Extensions.Logging;
using Serilog.Context;
using ZB.MOM.WW.CBDD.Bson;
using ZB.MOM.WW.CBDD.Core.Collections;
using ZB.MOM.WW.CBDD.Core.Compression;
using ZB.MOM.WW.CBDD.Core.Storage;

namespace ZB.MOM.WW.CBDD.Tests.Benchmark;

internal static class DatabaseSizeBenchmark
{
    private static readonly int[] TargetCounts = [10_000, 1_000_000, 10_000_000];
    private static readonly CompressionOptions CompressedBrotliFast = new()
    {
        EnableCompression = true,
        MinSizeBytes = 256,
        MinSavingsPercent = 0,
        Codec = CompressionCodec.Brotli,
        Level = System.IO.Compression.CompressionLevel.Fastest
    };

    private static readonly Scenario[] Scenarios =
    [
        // Separate compression set (no compaction)
        new(
            Set: "compression",
            Name: "CompressionOnly-Uncompressed",
            CompressionOptions: CompressionOptions.Default,
            RunCompaction: false),
        new(
            Set: "compression",
            Name: "CompressionOnly-Compressed-BrotliFast",
            CompressionOptions: CompressedBrotliFast,
            RunCompaction: false),
        // Separate compaction set (compaction enabled)
        new(
            Set: "compaction",
            Name: "Compaction-Uncompressed",
            CompressionOptions: CompressionOptions.Default,
            RunCompaction: true),
        new(
            Set: "compaction",
            Name: "Compaction-Compressed-BrotliFast",
            CompressionOptions: CompressedBrotliFast,
            RunCompaction: true)
    ];

    private const int BatchSize = 50_000;
    private const int ProgressInterval = 1_000_000;

    /// <summary>
    /// Tests run.
    /// </summary>
    /// <param name="logger">Logger for benchmark progress and results.</param>
    public static void Run(ILogger logger)
    {
        var results = new List<SizeResult>(TargetCounts.Length * Scenarios.Length);

        logger.LogInformation("=== CBDD Database Size Benchmark (Separate Compression/Compaction Sets) ===");
        logger.LogInformation("Targets: {Targets}", string.Join(", ", TargetCounts.Select(x => x.ToString("N0"))));
        logger.LogInformation("Scenarios: {Scenarios}", string.Join(", ", Scenarios.Select(x => $"{x.Set}:{x.Name}")));
        logger.LogInformation("Batch size: {BatchSize:N0}", BatchSize);

        foreach (var targetCount in TargetCounts)
        {
            foreach (var scenario in Scenarios)
            {
                var dbPath = Path.Combine(Path.GetTempPath(), $"cbdd_size_{scenario.Name}_{targetCount}_{Guid.NewGuid():N}.db");
                var walPath = Path.ChangeExtension(dbPath, ".wal");
                using var _ = LogContext.PushProperty("TargetCount", targetCount);
                using var __ = LogContext.PushProperty("Scenario", scenario.Name);
                using var ___ = LogContext.PushProperty("ScenarioSet", scenario.Set);

                logger.LogInformation(
                    "Starting {Set} scenario {Scenario} for target {TargetCount:N0} docs",
                    scenario.Set,
                    scenario.Name,
                    targetCount);

                var insertStopwatch = Stopwatch.StartNew();
                CompressionStats compressionStats = default;
                CompactionStats compactionStats = new();
                long preCompactDbBytes;
                long preCompactWalBytes;
                long postCompactDbBytes;
                long postCompactWalBytes;

                using (var storage = new StorageEngine(dbPath, PageFileConfig.Default, scenario.CompressionOptions))
                using (var transactionHolder = new BenchmarkTransactionHolder(storage))
                {
                    var collection = new DocumentCollection<SizeBenchmarkDocument>(
                        storage,
                        transactionHolder,
                        new SizeBenchmarkDocumentMapper());

                    var inserted = 0;
                    while (inserted < targetCount)
                    {
                        var currentBatchSize = Math.Min(BatchSize, targetCount - inserted);
                        var documents = new SizeBenchmarkDocument[currentBatchSize];
                        var baseValue = inserted;

                        for (var i = 0; i < currentBatchSize; i++)
                        {
                            documents[i] = CreateDocument(baseValue + i);
                        }

                        collection.InsertBulk(documents);
                        transactionHolder.CommitAndReset();

                        inserted += currentBatchSize;
                        if (inserted == targetCount || inserted % ProgressInterval == 0)
                        {
                            logger.LogInformation("Inserted {Inserted:N0}/{TargetCount:N0}", inserted, targetCount);
                        }
                    }

                    insertStopwatch.Stop();
                    preCompactDbBytes = File.Exists(dbPath) ? new FileInfo(dbPath).Length : 0;
                    preCompactWalBytes = File.Exists(walPath) ? new FileInfo(walPath).Length : 0;

                    if (scenario.RunCompaction)
                    {
                        compactionStats = storage.Compact(new CompactionOptions
                        {
                            EnableTailTruncation = true,
                            DefragmentSlottedPages = true,
                            NormalizeFreeList = true
                        });
                    }

                    postCompactDbBytes = File.Exists(dbPath) ? new FileInfo(dbPath).Length : 0;
                    postCompactWalBytes = File.Exists(walPath) ? new FileInfo(walPath).Length : 0;
                    compressionStats = storage.GetCompressionStats();
                }

                var result = new SizeResult(
                    scenario.Set,
                    scenario.Name,
                    scenario.RunCompaction,
                    targetCount,
                    insertStopwatch.Elapsed,
                    preCompactDbBytes,
                    preCompactWalBytes,
                    postCompactDbBytes,
                    postCompactWalBytes,
                    compactionStats,
                    compressionStats);
                results.Add(result);

                logger.LogInformation(
                    "Completed {Set}:{Scenario} {TargetCount:N0} docs in {Elapsed}. pre={PreTotal}, post={PostTotal}, shrink={Shrink}, compactApplied={CompactionApplied}, compactReclaim={CompactReclaim}, compRatio={CompRatio}",
                    scenario.Set,
                    scenario.Name,
                    targetCount,
                    insertStopwatch.Elapsed,
                    FormatBytes(result.PreCompactTotalBytes),
                    FormatBytes(result.PostCompactTotalBytes),
                    FormatBytes(result.ShrinkBytes),
                    scenario.RunCompaction,
                    FormatBytes(result.CompactionStats.ReclaimedFileBytes),
                    result.CompressionRatioText);

                TryDelete(dbPath);
                TryDelete(walPath);
            }
        }

        logger.LogInformation("=== Size Benchmark Summary ===");
        foreach (var result in results
                     .OrderBy(x => x.Set)
                     .ThenBy(x => x.TargetCount)
                     .ThenBy(x => x.Scenario))
        {
            logger.LogInformation(
                "{Set,-11} | {Scenario,-38} | {Count,12:N0} docs | insert={Elapsed,12} | pre={Pre,12} | post={Post,12} | shrink={Shrink,12} | compact={CompactBytes,12} | ratio={Ratio}",
                result.Set,
                result.Scenario,
                result.TargetCount,
                result.InsertElapsed,
                FormatBytes(result.PreCompactTotalBytes),
                FormatBytes(result.PostCompactTotalBytes),
                FormatBytes(result.ShrinkBytes),
                FormatBytes(result.CompactionStats.ReclaimedFileBytes),
                result.CompressionRatioText);
        }

        WriteSummaryCsv(results, logger);
    }

    private static SizeBenchmarkDocument CreateDocument(int value)
    {
        return new SizeBenchmarkDocument
        {
            Id = ObjectId.NewObjectId(),
            Value = value,
            Name = $"doc-{value:D8}"
        };
    }

    private static void TryDelete(string path)
    {
        if (File.Exists(path))
        {
            File.Delete(path);
        }
    }

    private static string FormatBytes(long bytes)
    {
        string[] units = ["B", "KB", "MB", "GB", "TB"];
        double size = bytes;
        var unitIndex = 0;

        while (size >= 1024 && unitIndex < units.Length - 1)
        {
            size /= 1024;
            unitIndex++;
        }

        return $"{size:N2} {units[unitIndex]}";
    }

    private static void WriteSummaryCsv(IEnumerable<SizeResult> results, ILogger logger)
    {
        var outputDirectory = Path.Combine(Directory.GetCurrentDirectory(), "BenchmarkDotNet.Artifacts", "results");
        Directory.CreateDirectory(outputDirectory);
        var outputPath = Path.Combine(outputDirectory, "DatabaseSizeBenchmark-results.csv");

        var lines = new List<string>
        {
            "set,scenario,target_count,run_compaction,insert_seconds,pre_total_bytes,post_total_bytes,shrink_bytes,compaction_reclaimed_bytes,compression_ratio_text"
        };

        foreach (var result in results.OrderBy(x => x.Set).ThenBy(x => x.TargetCount).ThenBy(x => x.Scenario))
        {
            lines.Add(string.Join(",",
                result.Set,
                result.Scenario,
                result.TargetCount.ToString(),
                result.RunCompaction ? "true" : "false",
                result.InsertElapsed.TotalSeconds.ToString("F3"),
                result.PreCompactTotalBytes.ToString(),
                result.PostCompactTotalBytes.ToString(),
                result.ShrinkBytes.ToString(),
                result.CompactionStats.ReclaimedFileBytes.ToString(),
                result.CompressionRatioText));
        }

        File.WriteAllLines(outputPath, lines);
        logger.LogInformation("Database size summary CSV written to {OutputPath}", outputPath);
    }

    private sealed record Scenario(string Set, string Name, CompressionOptions CompressionOptions, bool RunCompaction);

    private sealed record SizeResult(
        string Set,
        string Scenario,
        bool RunCompaction,
        int TargetCount,
        TimeSpan InsertElapsed,
        long PreCompactDbBytes,
        long PreCompactWalBytes,
        long PostCompactDbBytes,
        long PostCompactWalBytes,
        CompactionStats CompactionStats,
        CompressionStats CompressionStats)
    {
        /// <summary>
        /// Gets or sets the pre compact total bytes.
        /// </summary>
        public long PreCompactTotalBytes => PreCompactDbBytes + PreCompactWalBytes;
        /// <summary>
        /// Gets or sets the post compact total bytes.
        /// </summary>
        public long PostCompactTotalBytes => PostCompactDbBytes + PostCompactWalBytes;
        /// <summary>
        /// Gets or sets the shrink bytes.
        /// </summary>
        public long ShrinkBytes => PreCompactTotalBytes - PostCompactTotalBytes;

        /// <summary>
        /// Gets or sets the compression ratio text.
        /// </summary>
        public string CompressionRatioText =>
            CompressionStats.BytesAfterCompression > 0
                ? $"{(double)CompressionStats.BytesBeforeCompression / CompressionStats.BytesAfterCompression:N2}x"
                : "n/a";
    }

    private sealed class SizeBenchmarkDocument
    {
        /// <summary>
        /// Gets or sets the id.
        /// </summary>
        public ObjectId Id { get; set; }
        /// <summary>
        /// Gets or sets the value.
        /// </summary>
        public int Value { get; set; }
        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        public string Name { get; set; } = string.Empty;
    }

    private sealed class SizeBenchmarkDocumentMapper : ObjectIdMapperBase<SizeBenchmarkDocument>
    {
        /// <inheritdoc />
        public override string CollectionName => "size_documents";

        /// <inheritdoc />
        public override ObjectId GetId(SizeBenchmarkDocument entity) => entity.Id;

        /// <inheritdoc />
        public override void SetId(SizeBenchmarkDocument entity, ObjectId id) => entity.Id = id;

        /// <inheritdoc />
        public override int Serialize(SizeBenchmarkDocument entity, BsonSpanWriter writer)
        {
            var sizePos = writer.BeginDocument();
            writer.WriteObjectId("_id", entity.Id);
            writer.WriteInt32("value", entity.Value);
            writer.WriteString("name", entity.Name);
            writer.EndDocument(sizePos);
            return writer.Position;
        }

        /// <inheritdoc />
        public override SizeBenchmarkDocument Deserialize(BsonSpanReader reader)
        {
            var document = new SizeBenchmarkDocument();

            reader.ReadDocumentSize();
            while (reader.Remaining > 0)
            {
                var bsonType = reader.ReadBsonType();
                if (bsonType == BsonType.EndOfDocument)
                {
                    break;
                }

                var name = reader.ReadElementHeader();
                switch (name)
                {
                    case "_id":
                        document.Id = reader.ReadObjectId();
                        break;
                    case "value":
                        document.Value = reader.ReadInt32();
                        break;
                    case "name":
                        document.Name = reader.ReadString();
                        break;
                    default:
                        reader.SkipValue(bsonType);
                        break;
                }
            }

            return document;
        }
    }
}