using NubLang.Parsing.Syntax;

namespace NubLang.Modules;

public class ModuleRepository
{
    private readonly Dictionary<string, Module> _modules = new();

    public ModuleRepository(List<SyntaxTree> syntaxTrees)
    {
        foreach (var syntaxTree in syntaxTrees)
        {
            var moduleName = syntaxTree.Metadata.ModuleName;
            var module = GetOrCreate(moduleName);
            ProcessSyntaxTree(module, syntaxTree);
        }
    }

    private static void ProcessSyntaxTree(Module module, SyntaxTree syntaxTree)
    {
        foreach (var definition in syntaxTree.Definitions)
        {
            switch (definition)
            {
                case FuncSyntax funcDef:
                {
                    var parameters = funcDef.Signature.Parameters.Select(x => new ModuleFunctionParameter(x.Name, x.Type)).ToList();
                    module.RegisterFunction(funcDef.Exported, funcDef.Name, funcDef.ExternSymbol, parameters, funcDef.Signature.ReturnType);
                    break;
                }
                case StructSyntax structDef:
                {
                    var fields = structDef.Fields.Select(x => new ModuleStructField(x.Name, x.Type, x.Value.HasValue)).ToList();

                    var functions = new List<ModuleStructFunction>();
                    foreach (var function in structDef.Functions)
                    {
                        var parameters = function.Signature.Parameters.Select(x => new ModuleStructFunctionParameter(x.Name, x.Type)).ToList();
                        functions.AddRange(new ModuleStructFunction(function.Name, function.Hook, parameters, function.Signature.ReturnType));
                    }

                    module.RegisterStruct(structDef.Exported, structDef.Name, fields, functions);
                    break;
                }
                case StructTemplateSyntax structDef:
                {
                    // todo(nub31): Include templates in modules
                    break;
                }
                default:
                {
                    throw new ArgumentOutOfRangeException(nameof(definition));
                }
            }
        }
    }

    public Dictionary<string, Module> Modules()
    {
        return _modules;
    }

    private Module GetOrCreate(string name)
    {
        if (!_modules.TryGetValue(name, out var module))
        {
            module = new Module();
            _modules[name] = module;
        }

        return module;
    }
}