using NubLang.Syntax.Parsing.Node;

namespace NubLang.Syntax.Binding;

public class DefinitionTable
{
    private readonly List<DefinitionSyntax> _definitions;

    public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
    {
        _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
    }

    public IEnumerable<LocalFuncSyntax> LookupLocalFunc(string @namespace, string name)
    {
        return _definitions
            .OfType<LocalFuncSyntax>()
            .Where(x => x.Namespace == @namespace && x.Name == name);
    }

    public IEnumerable<ExternFuncSyntax> LookupExternFunc(string @namespace, string name)
    {
        return _definitions
            .OfType<ExternFuncSyntax>()
            .Where(x => x.Namespace == @namespace && x.Name == name);
    }

    public IEnumerable<StructSyntax> LookupStruct(NubCustomType type)
    {
        return _definitions
            .OfType<StructSyntax>()
            .Where(x => x.Namespace == type.Namespace && x.Name == type.Name);
    }

    public IEnumerable<StructFieldSyntax> LookupStructField(StructSyntax structNode, string field)
    {
        return structNode.Fields.Where(x => x.Name == field);
    }

    // public IEnumerable<TraitFuncImplSyntax> LookupTraitFuncImpl(NubType forType, string name)
    // {
    //     return _definitions
    //         .OfType<TraitImplSyntax>()
    //         .Where(x => x.ForType == forType)
    //         .SelectMany(x => x.Functions)
    //         .Where(x => x.Name == name);
    // }

    public IEnumerable<TraitSyntax> LookupTrait(NubCustomType type)
    {
        return _definitions
            .OfType<TraitSyntax>()
            .Where(x => x.Namespace == type.Namespace && x.Name == type.Name);
    }

    public IEnumerable<TraitFuncSyntax> LookupTraitFunc(TraitSyntax trait, string name)
    {
        return trait.Functions.Where(x => x.Name == name);
    }
}