using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MiniExcelLibs;

namespace ExcelKv.Core;

public class RegionConfig
{
    public int TopHeaderStartRow { get; set; } = 0;
    public int TopHeaderDepth { get; set; } = 3;
    public int LeftHeaderStartCol { get; set; } = 0;
    public int LeftHeaderWidth { get; set; } = 4;
    
    // Optional Parsing Limits (inclusive indices)
    public int? DataEndRow { get; set; } 
    public int? DataEndCol { get; set; }
}

public interface IStorageWrapper
{
    Task SetAsync(string key, string value);
    // New: Metadata overload for Traceability
    Task SetAsync(string key, string value, int row, int col);
    Task IncrementAsync(string key, double value);
}

// Live Aggregator Helper (Moved here for shared access)
public class LiveAggregator
{
    private static readonly System.Text.RegularExpressions.Regex MetricPattern = 
        new System.Text.RegularExpressions.Regex(@"(수량|합계|Volume|Weight|Total|Usage)", System.Text.RegularExpressions.RegexOptions.IgnoreCase | System.Text.RegularExpressions.RegexOptions.Compiled);

    public static bool IsMetric(string colName) => MetricPattern.IsMatch(colName);
    
    public static string GenerateGroupKey(string sheetName, string category, string spec, string metricName)
        => $"Stats:{Use_(category)}:{Use_(spec)}:{Use_(metricName)}";
        
    private static string Use_(string s) => string.IsNullOrWhiteSpace(s) ? "Unknown" : s.Replace(" ", "_");
}


public class ExcelLoader
{
    public static async Task<List<string>> GetSheetNamesAsync(string filePath)
    {
        return await Task.Run(() => MiniExcel.GetSheetNames(filePath).ToList());
    }

    public static async Task<List<string[]>> GetPreviewRowsAsync(string filePath, string sheetName, int count = 50)
    {
        return await Task.Run(() => 
        {
            var rows = MiniExcel.Query(filePath, sheetName: sheetName, useHeaderRow: false).Take(count).ToList();
            List<string[]> result = new();
            foreach(IDictionary<string, object> r in rows)
            {
                result.Add(FlattenDictionaryRow(r));
            }
            return result;
        });
    }

    public static async Task<int> ProcessFileAsync(
        string filePath, 
        string sheetName, 
        RegionConfig config, 
        IStorageWrapper storage, 
        SchemaRegistry registry)
    {
        Console.WriteLine($"[Core.Loader] Processing {filePath} Sheet: {sheetName}...");
        
        var rows = MiniExcel.Query(filePath, sheetName: sheetName, useHeaderRow: false).ToList();
        
        // Validation
        int dataStartRow = config.TopHeaderStartRow + config.TopHeaderDepth;
        if (rows.Count <= dataStartRow) return 0;

        // 1. Analyze Top Headers (Data Columns)
        var topHeaderRows = new List<string[]>();
        for (int i = config.TopHeaderStartRow; i < dataStartRow; i++)
        {
             topHeaderRows.Add(FlattenDictionaryRow((IDictionary<string, object>)rows[i]));
        }
        
        // Calculate Global Max Col from Data Rows to ensure we don't truncate data
        // Optimization: check a sample or assume logical limit. For correctness, check valid rows.
        int globalMaxCol = 0;
        int limitRow = config.DataEndRow.HasValue ? Math.Min(rows.Count, config.DataEndRow.Value + 1) : rows.Count;
        for(int i = dataStartRow; i < limitRow; i++)
        {
            var d = (IDictionary<string, object>)rows[i];
            if(d.Count > globalMaxCol) globalMaxCol = d.Count; // Approximate
            // FlattenDictionaryRow is cleaner but expensive to call just for count.
            // d.Keys.Count is effectively the column count for that row.
        }

        // Flatten Data Headers (Right Side)
        var topAxisKeys = FlattenTopHeaders(topHeaderRows, config.LeftHeaderStartCol + config.LeftHeaderWidth, globalMaxCol);
        
        // ... (Left Axis Header logic omitted for brevity, unchanged) ...
        // ** New: Extract Left Axis Headers (Corner Region) **
        // These are the headers *above* the Left Key columns.
        var leftAxisHeaders = new List<string>();
        var bottomHeaderRow = FlattenDictionaryRow((IDictionary<string, object>)rows[dataStartRow - 1]);
        
        for (int c = 0; c < config.LeftHeaderWidth; c++)
        {
            int absCol = config.LeftHeaderStartCol + c;
            string headerVal = (absCol < bottomHeaderRow.Length) ? bottomHeaderRow[absCol] : $"Col{c}";
            leftAxisHeaders.Add(headerVal);
        }

        string ns = System.IO.Path.GetFileName(filePath) + "_" + sheetName;
        registry.RegisterSchema(ns, topAxisKeys);

        // 2. Process Data Rows
        string[] lastLeftValues = new string[config.LeftHeaderWidth]; 

        int processedCount = 0;

        for (int i = dataStartRow; i < limitRow; i++)
        {
            var rowDict = (IDictionary<string, object>)rows[i];
            var rowVals = FlattenDictionaryRow(rowDict);
            
            // ... (Left Key Logic Unchanged) ...
            var currentLeftParts = new List<string>();
            bool rowHasContent = false;
            for (int c = 0; c < config.LeftHeaderWidth; c++)
            {
                int absCol = config.LeftHeaderStartCol + c;
                string val = (absCol < rowVals.Length) ? rowVals[absCol] : "";
                if (string.IsNullOrWhiteSpace(val)) val = lastLeftValues[c];
                else lastLeftValues[c] = val;
                if(!string.IsNullOrWhiteSpace(val)) {
                    currentLeftParts.Add(val);
                    rowHasContent = true;
                }
            }
            if (!rowHasContent) continue; 
            string leftKey = string.Join("----", currentLeftParts);

            // B. Map Values
            int limitCol = config.DataEndCol.HasValue ? Math.Min(rowVals.Length, config.DataEndCol.Value + 1) : rowVals.Length;

            for (int c = config.LeftHeaderStartCol + config.LeftHeaderWidth; c < limitCol; c++)
            {
                int topIndex = c - (config.LeftHeaderStartCol + config.LeftHeaderWidth);
                if (topIndex < 0 || topIndex >= topAxisKeys.Count) continue;

                string topKey = topAxisKeys[topIndex]; 
                if (string.IsNullOrWhiteSpace(topKey)) continue; // Skip if no header key

                string val = rowVals[c];
                if (string.IsNullOrWhiteSpace(val)) continue;

                // ** Feature: Rounding to 6 Decimal Places **
                // "All data should be formatted to 6 decimal places by default"
                if (double.TryParse(val, out double dVal))
                {
                    val = Math.Round(dVal, 6).ToString(); // Simple G-format or fixed? User said "Decimal 6 places". 
                    // Let's use standard string representation of the rounded 6-digit number to avoid trailing zeros "1.100000".
                    // Math.Round(1.1, 6) -> 1.1. 
                    // If user meant "Fixed 6 places" (1.100000), use F6. Usually "representation" means significant digits.
                    // Given SI context, significant precision matters. Let's use normalization (remove trailing zeros)
                    // Update: User said "소수점 6자리까지 표현하는걸로 통일". Could mean truncate or round. Safe bet is Round.
                }

                string fullKey = $"{sheetName}:{leftKey}*{topKey}";
                
                await storage.SetAsync(fullKey, val, i, c);

                if (LiveAggregator.IsMetric(topKey) && double.TryParse(val, out double statVal))
                {
                     await storage.IncrementAsync($"Stats:Global:{topKey}", statVal);
                }
            }
            processedCount++;
        }
        
        Console.WriteLine($"[Core.Loader] Finished. Processed: {processedCount} items.");
        return processedCount;
    }


    private static string[] FlattenDictionaryRow(IDictionary<string, object> rowDict)
    {
        var sortedKeys = rowDict.Keys.OrderBy(k => k.Length).ThenBy(k => k).ToList();
        var result = new string[sortedKeys.Count]; 
        
        for (int i = 0; i < sortedKeys.Count; i++)
        {
            var val = rowDict[sortedKeys[i]];
            result[i] = val?.ToString() ?? "";
        }
        return result;
    }

    private static List<string> FlattenTopHeaders(List<string[]> headerRows, int startCol, int globalMaxCol)
    {
        if (headerRows.Count == 0) return new List<string>();
        // Ensure we cover all data columns, even if headers are short
        int maxCol = Math.Max(headerRows.Max(r => r.Length), globalMaxCol);
        
        var flatHeaders = new List<string>();
        
        // Iterate Columns
        var lastValues = new string[headerRows.Count];
        for (int c = startCol; c < maxCol; c++)
        {
            var parts = new List<string>();
            // Iterate Rows (Depth)
            for (int r = 0; r < headerRows.Count; r++)
            {
                string val = (c < headerRows[r].Length) ? headerRows[r][c] : "";
                
                // Horizontal Forward Fill (Re-enabled for Merged Headers)
                if (string.IsNullOrWhiteSpace(val)) val = lastValues[r];
                else lastValues[r] = val;
                
                if (!string.IsNullOrWhiteSpace(val)) parts.Add(val);
            }
            // If empty, use "Col_Index" fallback or keep empty? 
            // User schema usually requires keys. If empty, it's skipped in mapping.
            // Let's keep it empty, but if data exists, it won't map unless we have a key.
            // If parts is empty, let's leave valid empty string so mapping can decide.
            flatHeaders.Add(string.Join("----", parts)); 
        }
        return flatHeaders;
    }
}