using Syntax.Node;

namespace Syntax;

public sealed class DefinitionTable
{
    private readonly List<TopLevelNode> _topLevelNodes;

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

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

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

    public IEnumerable<StructNode> LookupStruct(string @namespace, string name)
    {
        return _topLevelNodes
            .OfType<StructNode>()
            .Where(x => x.Namespace == @namespace && x.Name == name);
    }

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

    public IEnumerable<TraitImplNode> LookupTraitImpl(NubType itemType)
    {
        return _topLevelNodes
            .OfType<TraitImplNode>()
            .Where(x => x.TraitType == itemType);
    }

    public IEnumerable<TraitFuncImplNode> LookupTraitFuncImpl(TraitImplNode traitImpl, string name)
    {
        return traitImpl.Functions.Where(x => x.Name == name);
    }

    public IEnumerable<TraitNode> LookupTrait(string @namespace, string name)
    {
        return _topLevelNodes
            .OfType<TraitNode>()
            .Where(x => x.Namespace == @namespace && x.Name == name);
    }

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