using Common;
using Syntax.Parsing;
using Syntax.Parsing.Node;
using Syntax.Typing;
using Syntax.Typing.BoundNode;

namespace Syntax;

public class DefinitionTable
{
    private readonly IEnumerable<SyntaxTree> _syntaxTrees;

    public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
    {
        _syntaxTrees = syntaxTrees;
    }

    public Optional<FuncDefinition> LookupFunction(string @namespace, string name)
    {
        var definition = _syntaxTrees
            .Where(c => c.Namespace == @namespace)
            .SelectMany(c => c.Definitions)
            .OfType<FuncDefinition>()
            .SingleOrDefault(f => f.Name == name);

        return Optional.OfNullable(definition);
    }

    public Optional<StructDefinitionNode> LookupStruct(string @namespace, string name)
    {
        var definition = _syntaxTrees
            .Where(c => c.Namespace == @namespace)
            .SelectMany(c => c.Definitions)
            .OfType<StructDefinitionNode>()
            .SingleOrDefault(f => f.Name == name);

        return Optional.OfNullable(definition);
    }

    public IEnumerable<StructDefinitionNode> GetStructs()
    {
        return _syntaxTrees
            .SelectMany(c => c.Definitions)
            .OfType<StructDefinitionNode>();
    }

    public IEnumerable<FuncDefinition> GetFunctions()
    {
        return _syntaxTrees
            .SelectMany(c => c.Definitions)
            .OfType<FuncDefinition>();
    }
}

public class BoundDefinitionTable
{
    private readonly IEnumerable<BoundSyntaxTree> _syntaxTrees;

    public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees)
    {
        _syntaxTrees = syntaxTrees;
    }

    public Optional<BoundFuncDefinition> LookupFunc(string @namespace, string name)
    {
        var definition = _syntaxTrees
            .Where(c => c.Namespace == @namespace)
            .SelectMany(c => c.Definitions)
            .OfType<BoundFuncDefinition>()
            .SingleOrDefault(f => f.Name == name);

        return Optional.OfNullable(definition);
    }

    public Optional<BoundStructDefinitionNode> LookupStruct(string @namespace, string name)
    {
        var definition = _syntaxTrees
            .Where(c => c.Namespace == @namespace)
            .SelectMany(c => c.Definitions)
            .OfType<BoundStructDefinitionNode>()
            .SingleOrDefault(f => f.Name == name);

        return Optional.OfNullable(definition);
    }

    public IEnumerable<BoundStructDefinitionNode> GetStructs()
    {
        return _syntaxTrees
            .SelectMany(c => c.Definitions)
            .OfType<BoundStructDefinitionNode>();
    }

    public IEnumerable<BoundFuncDefinition> GetFunctions()
    {
        return _syntaxTrees
            .SelectMany(c => c.Definitions)
            .OfType<BoundFuncDefinition>();
    }
}