#r "nuget: Microsoft.CodeAnalysis.CSharp, 4.11.0"

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;

// Argumenty pozycyjne + flagi (np. --related).
var positional = Args.Where(a => !a.StartsWith("--", StringComparison.Ordinal)).ToList();
var includeRelated = Args.Any(a => a == "--related");

if (positional.Count < 1)
{
    Console.Error.WriteLine("Użycie: dotnet script scan-workers.csx -- <KatalogDll> [<NazwaTypuDanych>] [--related]");
    Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0");
    Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0 DokumentHandlowy");
    Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0 Pracownik --related");
    return 1;
}

var dllDir = Path.GetFullPath(positional[0]);
var typeFilter = positional.Count >= 2 ? positional[1] : null;
if (!Directory.Exists(dllDir))
{
    Console.Error.WriteLine($"Katalog nie istnieje: {dllDir}");
    return 1;
}

var dllPaths = Directory.EnumerateFiles(dllDir, "*.dll", SearchOption.TopDirectoryOnly).ToList();
if (dllPaths.Count == 0)
{
    Console.Error.WriteLine($"Brak plików *.dll w katalogu: {dllDir}");
    return 1;
}

var refs = new List<MetadataReference>();
var addedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var p in dllPaths)
{
    try
    {
        refs.Add(MetadataReference.CreateFromFile(p));
        addedPaths.Add(Path.GetFileName(p));
    }
    catch (Exception ex) { Console.Error.WriteLine($"# Pominięto {Path.GetFileName(p)}: {ex.Message}"); }
}

var tpa = (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string ?? "")
    .Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
foreach (var path in tpa)
{
    var name = Path.GetFileName(path);
    if (addedPaths.Contains(name)) continue;
    try { refs.Add(MetadataReference.CreateFromFile(path)); addedPaths.Add(name); }
    catch { /* pomiń */ }
}

var compilation = CSharpCompilation.Create("ScanWorkers")
    .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
    .AddReferences(refs);

// Rekord opisujący pojedynczą rejestrację Worker/Extender (jednej klasie może
// odpowiadać wiele rejestracji — np. ten sam worker przypięty do różnych typów danych).
var registrations = new List<WorkerRegistration>();

foreach (var asmRef in compilation.References)
{
    if (compilation.GetAssemblyOrModuleSymbol(asmRef) is not IAssemblySymbol asm) continue;
    foreach (var a in asm.GetAttributes())
    {
        var ac = a.AttributeClass;
        if (ac == null) continue;
        if (!IsWorkerAttribute(ac)) continue;

        INamedTypeSymbol workerType = null;
        INamedTypeSymbol dataType = null;
        string alias = null;

        // Wariant generyczny: [Worker<TWorker>] lub [Worker<TWorker, TData>]
        if (ac.IsGenericType && ac.TypeArguments.Length >= 1)
        {
            workerType = ac.TypeArguments[0] as INamedTypeSymbol;
            if (ac.TypeArguments.Length >= 2)
                dataType = ac.TypeArguments[1] as INamedTypeSymbol;

            // Opcjonalny string z konstruktora = alias (Name)
            foreach (var arg in a.ConstructorArguments)
            {
                if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s)
                {
                    alias = s;
                    break;
                }
            }
        }
        // Wariant z parametrami: [Worker(typeof(TWorker))] / [Worker(typeof(TWorker), typeof(TData))]
        // ewentualnie z dodatkowym name jako string.
        else
        {
            var ca = a.ConstructorArguments;
            int typeIdx = 0;
            foreach (var arg in ca)
            {
                if (arg.Kind == TypedConstantKind.Type && arg.Value is INamedTypeSymbol nt)
                {
                    if (typeIdx == 0) workerType = nt;
                    else if (typeIdx == 1) dataType = nt;
                    typeIdx++;
                }
                else if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s && alias == null)
                {
                    alias = s;
                }
            }
        }

        // NamedArgument "Name" ma priorytet, gdy jest jawnie podany.
        foreach (var na in a.NamedArguments)
        {
            if (na.Key == "Name" && na.Value.Value is string s) alias = s;
        }

        if (workerType == null) continue;
        registrations.Add(new WorkerRegistration(workerType, dataType, alias, asm.Name));
    }
}

// Filtr po nazwie typu danych — gdy podany drugi argument, ograniczamy do workerów
// przypiętych do tego typu (po prostej nazwie lub po pełnej nazwie z namespace).
// Z flagą --related dorzucamy typy powiązane: Row→Table (przez property `Table`),
// Table→Row (przez indekser this[int]), oraz history-row (gdy DataType implementuje
// IRowWithHistory — przez indekser this[Date]).
// Extendery (rejestracje bez DataType) są w trybie filtra pomijane.

var allowedDataTypes = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
INamedTypeSymbol primaryFilterType = null;
Dictionary<string, object> scopeJson = null;
if (typeFilter != null && includeRelated)
{
    primaryFilterType = FindTypeByName(compilation, typeFilter);
    if (primaryFilterType != null)
    {
        allowedDataTypes.Add(primaryFilterType);
        var related = ResolveRelatedTypes(primaryFilterType);
        foreach (var r in related) allowedDataTypes.Add(r.Type);

        // Dla każdego Row z zestawu (podstawowy oraz historyczny zwrócony z this[Date])
        // dodaj klasy bazowe (do `Row` włącznie) oraz klasy pochodne. Dla tabel tego nie robimy —
        // intermediate `*Table` generowane i framework Table to inny obszar.
        var rowTypes = allowedDataTypes
            .Where(t => InheritsFromNamed(t, "Row", "Soneta.Business")
                        || (t.Name == "Row" && (t.ContainingNamespace?.ToDisplayString() ?? "") == "Soneta.Business"))
            .ToList();
        var baseAdded = new List<INamedTypeSymbol>();
        var derivedAdded = new List<INamedTypeSymbol>();
        foreach (var r in rowTypes)
        {
            foreach (var b in BaseTypes(r))
                if (allowedDataTypes.Add(b)) baseAdded.Add(b);
            foreach (var d in FindDerivedTypes(compilation, r))
                if (allowedDataTypes.Add(d)) derivedAdded.Add(d);
        }

        Console.Error.WriteLine($"# Typ podstawowy: {primaryFilterType.ToDisplayString()}");
        foreach (var r in related)
            Console.Error.WriteLine($"# Typ powiązany ({r.Kind}): {r.Type.ToDisplayString()}");
        foreach (var b in baseAdded)
            Console.Error.WriteLine($"# Klasa bazowa: {b.ToDisplayString()}");
        foreach (var d in derivedAdded)
            Console.Error.WriteLine($"# Klasa pochodna: {d.ToDisplayString()}");

        scopeJson = new Dictionary<string, object>
        {
            ["primary"] = primaryFilterType.ToDisplayString(),
            ["related"] = related.Select(r => (object)new Dictionary<string, object>
            {
                ["type"] = r.Type.ToDisplayString(),
                ["kind"] = r.Kind,
            }).ToList(),
            ["baseClasses"] = baseAdded.Select(b => (object)b.ToDisplayString()).ToList(),
            ["derivedClasses"] = derivedAdded.Select(d => (object)d.ToDisplayString()).ToList(),
        };
    }
    else
    {
        Console.Error.WriteLine($"# Nie znaleziono typu `{typeFilter}` w referencjach — --related wyłączony.");
    }
}

bool MatchesTypeFilter(INamedTypeSymbol dt)
{
    if (typeFilter == null || dt == null) return typeFilter == null;
    if (allowedDataTypes.Count > 0) return allowedDataTypes.Contains(dt);
    return string.Equals(dt.Name, typeFilter, StringComparison.Ordinal)
        || string.Equals(dt.ToDisplayString(), typeFilter, StringComparison.Ordinal);
}

var filtered = typeFilter != null
    ? registrations.Where(r => r.DataType != null && MatchesTypeFilter(r.DataType)).ToList()
    : registrations;

// Sortowanie: najpierw workery z dataType (po nazwie dataType), potem extendery (bez dataType).
var byData = filtered
    .Where(r => r.DataType != null)
    .GroupBy(r => r.DataType, SymbolEqualityComparer.Default)
    .OrderBy(g => ((INamedTypeSymbol)g.Key).ToDisplayString(), StringComparer.Ordinal)
    .ToList();

var extenders = typeFilter == null
    ? registrations.Where(r => r.DataType == null)
        .OrderBy(r => r.WorkerType.ToDisplayString(), StringComparer.Ordinal)
        .ToList()
    : new List<WorkerRegistration>();

WriteJson(byData, extenders, typeFilter, scopeJson);
return 0;

static bool IsWorkerAttribute(INamedTypeSymbol attrClass)
{
    // Nazwa klasy atrybutu w metadanych może mieć backtick dla wariantu generycznego
    // (WorkerAttribute, WorkerAttribute`1, WorkerAttribute`2). Symbol.Name zwraca "WorkerAttribute"
    // bez backticka, więc wystarczy porównać po nazwie i — dla bezpieczeństwa — sprawdzić namespace.
    if (attrClass.Name != "WorkerAttribute") return false;
    var ns = attrClass.ContainingNamespace?.ToDisplayString() ?? "";
    return ns.StartsWith("Soneta", StringComparison.Ordinal);
}

static bool HasAttribute(ISymbol s, string attributeTypeName)
{
    var shortName = attributeTypeName.EndsWith("Attribute")
        ? attributeTypeName.Substring(0, attributeTypeName.Length - "Attribute".Length)
        : attributeTypeName;
    foreach (var a in s.GetAttributes())
    {
        var n = a.AttributeClass?.Name;
        if (n == attributeTypeName || n == shortName) return true;
    }
    return false;
}

static string GetActionTitle(IMethodSymbol m)
{
    foreach (var a in m.GetAttributes())
    {
        var n = a.AttributeClass?.Name;
        if (n != "ActionAttribute" && n != "Action") continue;
        foreach (var arg in a.ConstructorArguments)
        {
            if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s)
                return s;
        }
        return ""; // [Action] bez tytułu — i tak licz jako akcja
    }
    return null;
}

static string StripSuffix(string name, string suffix)
{
    return name.EndsWith(suffix, StringComparison.Ordinal)
        ? name.Substring(0, name.Length - suffix.Length)
        : name;
}

static void WriteJson(
    List<IGrouping<ISymbol, WorkerRegistration>> byData,
    List<WorkerRegistration> extenders,
    string typeFilter,
    Dictionary<string, object> scope)
{
    // Dictionary z zachowaną kolejnością wstawiania — opis na początku, potem klucze typów.
    var root = new Dictionary<string, object>();
    root["description"] = typeFilter != null
        ? $"Workery przypięte do typu `{typeFilter}` (Soneta)"
        : "Workery i extendery (Soneta)";
    if (scope != null) root["scope"] = scope;

    foreach (var g in byData)
    {
        var dt = (INamedTypeSymbol)g.Key;
        root[dt.ToDisplayString()] = g
            .OrderBy(r => r.WorkerType.Name, StringComparer.Ordinal)
            .Select(BuildWorkerJson)
            .ToList();
    }
    if (typeFilter == null && extenders.Count > 0)
    {
        root["__extenders__"] = extenders.Select(BuildWorkerJson).ToList();
    }

    var opts = new JsonSerializerOptions
    {
        WriteIndented = true,
        Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
    };
    Console.WriteLine(JsonSerializer.Serialize(root, opts));
}

static Dictionary<string, object> BuildWorkerJson(WorkerRegistration reg)
{
    var w = reg.WorkerType;
    var hasWorkerSuffix = w.Name.EndsWith("Worker", StringComparison.Ordinal);
    var defaultAlias = hasWorkerSuffix
        ? StripSuffix(w.Name, "Worker")
        : w.Name;
    var aliasShown = !string.IsNullOrEmpty(reg.Alias) ? reg.Alias : defaultAlias;

    var paramsList = new List<Dictionary<string, object>>();

    // Parametry konstruktora (kind=ctor) — wybieramy pierwszy publiczny konstruktor z parametrami.
    var ctor = w.InstanceConstructors
        .FirstOrDefault(c => c.DeclaredAccessibility == Accessibility.Public && c.Parameters.Length > 0);
    if (ctor != null)
    {
        foreach (var p in ctor.Parameters)
        {
            var entry = new Dictionary<string, object>
            {
                ["name"] = p.Name,
                ["type"] = p.Type.ToDisplayString(),
                ["kind"] = "ctor",
            };
            AttachContextBaseProps(entry, p.Type);
            paramsList.Add(entry);
        }
    }

    // Property z [Context] — inicjowane z Context.
    foreach (var p in w.GetMembers().OfType<IPropertySymbol>()
                 .Where(p => p.DeclaredAccessibility == Accessibility.Public && !p.IsStatic && !p.IsIndexer)
                 .Where(p => HasAttribute(p, "ContextAttribute"))
                 .OrderBy(p => p.Name, StringComparer.Ordinal))
    {
        var entry = new Dictionary<string, object>
        {
            ["name"] = p.Name,
            ["type"] = p.Type.ToDisplayString(),
        };
        AttachContextBaseProps(entry, p.Type);
        paramsList.Add(entry);
    }

    // Akcje [Action] — metoda + tytuł + typ wyniku.
    var actions = new List<Dictionary<string, object>>();
    foreach (var m in w.GetMembers().OfType<IMethodSymbol>()
                 .Where(m => m.MethodKind == MethodKind.Ordinary
                             && m.DeclaredAccessibility == Accessibility.Public
                             && !m.IsStatic)
                 .OrderBy(m => m.Name, StringComparer.Ordinal))
    {
        var title = GetActionTitle(m);
        if (title == null) continue;
        actions.Add(new Dictionary<string, object>
        {
            ["name"] = title,
            ["method"] = m.Name,
            ["result"] = m.ReturnsVoid ? "void" : m.ReturnType.ToDisplayString(),
        });
    }

    // Pozostałe public property z getterem (bez [Context]) — do bindowania / odczytu.
    var props = new List<Dictionary<string, object>>();
    foreach (var p in w.GetMembers().OfType<IPropertySymbol>()
                 .Where(p => p.DeclaredAccessibility == Accessibility.Public && !p.IsStatic && !p.IsIndexer)
                 .Where(p => p.GetMethod != null)
                 .Where(p => !HasAttribute(p, "ContextAttribute"))
                 .OrderBy(p => p.Name, StringComparer.Ordinal))
    {
        props.Add(new Dictionary<string, object>
        {
            ["name"] = p.Name,
            ["type"] = p.Type.ToDisplayString(),
        });
    }

    var obj = new Dictionary<string, object>
    {
        ["workerAssembly"] = reg.AssemblyName,
        ["workerType"] = w.ToDisplayString(),
        ["name"] = aliasShown,
    };
    if (paramsList.Count > 0) obj["params"] = paramsList;
    if (actions.Count > 0) obj["actions"] = actions;
    if (props.Count > 0) obj["props"] = props;
    return obj;
}

// Dla typu parametru workera dziedziczącego z ContextBase doczepia listę publicznych
// instancyjnych property — to są pod-parametry, które użytkownik widzi w oknie parametrów workera.
static void AttachContextBaseProps(Dictionary<string, object> entry, ITypeSymbol type)
{
    if (type is not INamedTypeSymbol nt) return;
    if (!InheritsFromContextBase(nt)) return;

    var props = new List<Dictionary<string, object>>();
    var seen = new HashSet<string>(StringComparer.Ordinal);
    for (var t = nt; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
    {
        if (t.Name == "ContextBase") break; // property bazowe ContextBase pomijamy (Context itp.)
        foreach (var p in t.GetMembers().OfType<IPropertySymbol>())
        {
            if (p.DeclaredAccessibility != Accessibility.Public || p.IsStatic || p.IsIndexer) continue;
            if (p.GetMethod == null) continue;
            if (!seen.Add(p.Name)) continue;
            props.Add(new Dictionary<string, object>
            {
                ["name"] = p.Name,
                ["type"] = p.Type.ToDisplayString(),
            });
        }
    }
    if (props.Count > 0)
    {
        props = props.OrderBy(d => (string)d["name"], StringComparer.Ordinal).ToList();
        entry["props"] = props;
    }
}

static bool InheritsFromContextBase(INamedTypeSymbol type)
{
    for (var t = type.BaseType; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
    {
        if (t.Name == "ContextBase"
            && (t.ContainingNamespace?.ToDisplayString() ?? "").StartsWith("Soneta", StringComparison.Ordinal))
            return true;
    }
    return false;
}

// Szuka typu po prostej nazwie ("DokumentHandlowy") lub pełnej z namespace
// ("Soneta.Handel.DokumentHandlowy"). Zwraca pierwsze trafienie.
static INamedTypeSymbol FindTypeByName(CSharpCompilation compilation, string nameOrFullName)
{
    foreach (var asmRef in compilation.References)
    {
        if (compilation.GetAssemblyOrModuleSymbol(asmRef) is not IAssemblySymbol asm) continue;
        foreach (var t in EnumerateAllTypes(asm.GlobalNamespace))
        {
            if (t.DeclaredAccessibility != Accessibility.Public) continue;
            if (string.Equals(t.Name, nameOrFullName, StringComparison.Ordinal)
                || string.Equals(t.ToDisplayString(), nameOrFullName, StringComparison.Ordinal))
                return t;
        }
    }
    return null;
}

static IEnumerable<INamedTypeSymbol> EnumerateAllTypes(INamespaceSymbol ns)
{
    foreach (var t in ns.GetTypeMembers()) yield return t;
    foreach (var sub in ns.GetNamespaceMembers())
        foreach (var t in EnumerateAllTypes(sub)) yield return t;
}

// Zbiór typów powiązanych z `primary` (przechodnio), wraz z rodzajem powiązania:
// - "table"         — tabela uzyskana z property `Table` na klasie Row;
// - "row"           — rekord uzyskany z `this[int]` na klasie Table;
// - "history-row"   — rekord historyczny z `this[Date]` (IRowWithHistory);
// - "history-table" — tabela rekordu historycznego (Row→Table na history-row).
// Pętle są zabezpieczone zbiorem już odwiedzonych typów.
static List<RelatedType> ResolveRelatedTypes(INamedTypeSymbol primary)
{
    var results = new List<RelatedType>();
    var queue = new Queue<(INamedTypeSymbol Type, string ParentKind)>();
    queue.Enqueue((primary, "primary"));
    var visited = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default) { primary };

    while (queue.Count > 0)
    {
        var (t, parentKind) = queue.Dequeue();
        var historyBranch = parentKind == "history-row" || parentKind == "history-table";

        if (InheritsFromNamed(t, "Row", "Soneta.Business"))
        {
            if (FindMemberInherited(t, m => m is IPropertySymbol p && !p.IsIndexer && p.Name == "Table")
                is IPropertySymbol tableProp
                && tableProp.Type is INamedTypeSymbol tableType
                && visited.Add(tableType))
            {
                var kind = historyBranch ? "history-table" : "table";
                results.Add(new RelatedType(tableType, kind));
                queue.Enqueue((tableType, kind));
            }
        }

        if (InheritsFromNamed(t, "Table", "Soneta.Business"))
        {
            if (FindMemberInherited(t, m => m is IPropertySymbol p
                    && p.IsIndexer && p.Parameters.Length == 1
                    && p.Parameters[0].Type.SpecialType == SpecialType.System_Int32)
                is IPropertySymbol rowIndexer
                && rowIndexer.Type is INamedTypeSymbol rowType
                && visited.Add(rowType))
            {
                var kind = historyBranch ? "history-row" : "row";
                results.Add(new RelatedType(rowType, kind));
                queue.Enqueue((rowType, kind));
            }
        }

        if (ImplementsInterface(t, "IRowWithHistory"))
        {
            if (FindMemberInherited(t, m => m is IPropertySymbol p
                    && p.IsIndexer && p.Parameters.Length == 1
                    && p.Parameters[0].Type is INamedTypeSymbol pt
                    && pt.Name == "Date"
                    && (pt.ContainingNamespace?.ToDisplayString() ?? "").StartsWith("Soneta", StringComparison.Ordinal))
                is IPropertySymbol dateIndexer
                && dateIndexer.Type is INamedTypeSymbol histType
                && visited.Add(histType))
            {
                results.Add(new RelatedType(histType, "history-row"));
                queue.Enqueue((histType, "history-row"));
            }
        }
    }
    return results;
}

record RelatedType(INamedTypeSymbol Type, string Kind);

// Wszystkie klasy bazowe (bez `object`).
static IEnumerable<INamedTypeSymbol> BaseTypes(INamedTypeSymbol type)
{
    for (var t = type.BaseType; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
        yield return t;
}

// Wszystkie klasy pochodne (publiczne, w referencjach), które mają `baseType` w łańcuchu BaseType.
static IEnumerable<INamedTypeSymbol> FindDerivedTypes(CSharpCompilation compilation, INamedTypeSymbol baseType)
{
    foreach (var asmRef in compilation.References)
    {
        if (compilation.GetAssemblyOrModuleSymbol(asmRef) is not IAssemblySymbol asm) continue;
        foreach (var t in EnumerateAllTypes(asm.GlobalNamespace))
        {
            if (t.TypeKind != TypeKind.Class) continue;
            if (SymbolEqualityComparer.Default.Equals(t, baseType)) continue;
            for (var b = t.BaseType; b != null && b.SpecialType != SpecialType.System_Object; b = b.BaseType)
            {
                if (SymbolEqualityComparer.Default.Equals(b, baseType)) { yield return t; break; }
            }
        }
    }
}

static bool InheritsFromNamed(INamedTypeSymbol type, string name, string nsPrefix)
{
    for (var t = type.BaseType; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
    {
        if (t.Name == name
            && (t.ContainingNamespace?.ToDisplayString() ?? "").StartsWith(nsPrefix, StringComparison.Ordinal))
            return true;
    }
    return false;
}

static bool ImplementsInterface(INamedTypeSymbol type, string ifaceName)
{
    return type.AllInterfaces.Any(i => i.Name == ifaceName);
}

static ISymbol FindMemberInherited(INamedTypeSymbol type, Func<ISymbol, bool> predicate)
{
    for (var t = type; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
    {
        var m = t.GetMembers().FirstOrDefault(predicate);
        if (m != null) return m;
    }
    return null;
}

record WorkerRegistration(INamedTypeSymbol WorkerType, INamedTypeSymbol DataType, string Alias, string AssemblyName);