/* Symbol definitions.
   Copyright (C) 2025 Free Software Foundation, Inc.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "elna/boot/symbol.h"

namespace elna::boot
{
    type::type(std::shared_ptr<alias_type> alias)
        : payload(alias)
    {
    }

    type::type(std::shared_ptr<primitive_type> primitive)
        : payload(primitive)
    {
    }

    type::type(std::shared_ptr<record_type> record)
        : payload(record)
    {
    }

    type::type(std::shared_ptr<pointer_type> pointer)
        : payload(pointer)
    {
    }

    type::type(std::shared_ptr<constant_type> constant)
        : payload(constant)
    {
    }

    type::type(std::shared_ptr<array_type> array)
        : payload(array)
    {
    }

    type::type(std::shared_ptr<procedure_type> procedure)
        : payload(procedure)
    {
    }

    type::type(std::shared_ptr<enumeration_type> enumeration)
        : payload(enumeration)
    {
    }

    template<typename T>
    std::shared_ptr<T> type::get() const
    {
        if constexpr (std::is_same_v<T, alias_type>)
        {
            if (auto *wp = std::get_if<std::weak_ptr<alias_type>>(&payload))
                return wp->lock();
            return nullptr;
        }
        else
        {
            if (auto *sp = std::get_if<std::shared_ptr<T>>(&payload))
                return *sp;
            return nullptr;
        }
    }

    // Explicit instantiation for all types used by callers.
    template std::shared_ptr<alias_type> type::get<alias_type>() const;
    template std::shared_ptr<primitive_type> type::get<primitive_type>() const;
    template std::shared_ptr<record_type> type::get<record_type>() const;
    template std::shared_ptr<pointer_type> type::get<pointer_type>() const;
    template std::shared_ptr<array_type> type::get<array_type>() const;
    template std::shared_ptr<constant_type> type::get<constant_type>() const;
    template std::shared_ptr<procedure_type> type::get<procedure_type>() const;
    template std::shared_ptr<enumeration_type> type::get<enumeration_type>() const;

    bool type::operator==(const std::nullptr_t&) const
    {
        return empty();
    }

    bool type::operator==(const type& other) const
    {
        type resolved_this = resolve_aliases(*this);
        type resolved_that = resolve_aliases(other);

        if (auto left_record = resolved_this.get<record_type>())
        {
            return left_record == resolved_that.get<record_type>();
        }
        if (auto left_primitive = resolved_this.get<primitive_type>())
        {
            auto right_primitive = resolved_that.get<primitive_type>();

            return right_primitive != nullptr && left_primitive->identifier == right_primitive->identifier;
        }
        if (auto left_enumeration = resolved_this.get<enumeration_type>())
        {
            return left_enumeration == resolved_that.get<enumeration_type>();
        }
        if (auto left_pointer = resolved_this.get<pointer_type>())
        {
            auto right_pointer = resolved_that.get<pointer_type>();

            return right_pointer != nullptr && left_pointer->base == right_pointer->base;
        }
        if (auto left_const = resolved_this.get<constant_type>())
        {
            auto right_const = resolved_that.get<constant_type>();

            return right_const != nullptr && left_const->unqualified == right_const->unqualified;
        }
        if (auto left_array = resolved_this.get<array_type>())
        {
            auto right_array = resolved_that.get<array_type>();

            return right_array != nullptr && left_array->size == right_array->size
                && left_array->base == right_array->base;
        }
        if (auto left_procedure = resolved_this.get<procedure_type>())
        {
            auto right_procedure = resolved_that.get<procedure_type>();

            return right_procedure != nullptr && left_procedure->return_type == right_procedure->return_type
                && left_procedure->parameters == right_procedure->parameters;
        }
        return resolved_this.empty() && resolved_that.empty();
    }

    bool type::empty() const
    {
        return std::holds_alternative<std::monostate>(payload);
    }

    std::string type::to_string() const
    {
        return std::visit([](const auto& p) -> std::string {
            using T = std::decay_t<decltype(p)>;
            if constexpr (std::is_same_v<T, std::monostate>)
                return "<empty>";
            else if constexpr (std::is_same_v<T, std::weak_ptr<alias_type>>)
                return p.lock()->name;
            else if constexpr (std::is_same_v<T, std::shared_ptr<primitive_type>>)
                return p->identifier;
            else if constexpr (std::is_same_v<T, std::shared_ptr<pointer_type>>)
                return "^" + p->base.to_string();
            else if constexpr (std::is_same_v<T, std::shared_ptr<constant_type>>)
                return "const " + p->unqualified.to_string();
            else if constexpr (std::is_same_v<T, std::shared_ptr<array_type>>)
                return "[" + std::to_string(p->size) + "]" + p->base.to_string();
            else if constexpr (std::is_same_v<T, std::shared_ptr<record_type>>)
            {
                if (p->base.empty())
                    return "record ... end";
                else
                    return "record(" + p->base.to_string() + ") ... end";
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<procedure_type>>)
            {
                std::string result = "proc(";
                for (std::size_t i = 0; i < p->parameters.size(); ++i)
                {
                    if (i > 0) result += ", ";
                    result += p->parameters[i].to_string();
                }
                result += ")";
                if (p->return_type.no_return)
                    result += ": !";
                else if (!p->return_type.proper_type.empty())
                    result += ": " + p->return_type.proper_type.to_string();
                return result;
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<enumeration_type>>)
                return "(enumeration)";
        }, payload);
    }

    alias_type::alias_type(const std::string& name)
        : name(name), referent()
    {
    }

    pointer_type::pointer_type(type base)
        : base(base)
    {
    }

    constant_type::constant_type(type unqualified)
        : unqualified(unqualified)
    {
    }

    array_type::array_type(type base, std::uint64_t size)
        : base(base), size(size)
    {
    }

    primitive_type::primitive_type(const std::string& identifier)
        : identifier(identifier)
    {
    }

    record_type::record_type(type base)
        : base(base)
    {
    }

    procedure_type::procedure_type(return_t return_type)
        : return_type(return_type)
    {
    }

    enumeration_type::enumeration_type(const std::vector<std::string>& members)
        : members(members)
    {
    }

    info::~info()
    {
    }

    std::shared_ptr<type_info> info::is_type()
    {
        return nullptr;
    }

    std::shared_ptr<procedure_info> info::is_procedure()
    {
        return nullptr;
    }

    std::shared_ptr<variable_info> info::is_variable()
    {
        return nullptr;
    }

    type_info::type_info(const type symbol)
        : symbol(symbol)
    {
    }

    std::shared_ptr<type_info> type_info::is_type()
    {
        return std::static_pointer_cast<type_info>(shared_from_this());
    }

    procedure_info::procedure_info(const procedure_type symbol, const std::vector<std::string> names,
            std::shared_ptr<symbol_table> scope)
        : symbol(symbol), names(names), scope(scope)
    {
    }

    std::shared_ptr<procedure_info> procedure_info::is_procedure()
    {
        return std::static_pointer_cast<procedure_info>(shared_from_this());
    }

    bool procedure_info::is_extern() const
    {
        return this->scope == nullptr;
    }

    variable_info::variable_info(const type symbol, bool is_extern)
        : symbol(symbol), is_extern(is_extern)
    {
    }

    std::shared_ptr<variable_info> variable_info::is_variable()
    {
        return std::static_pointer_cast<variable_info>(shared_from_this());
    }

    std::shared_ptr<symbol_table> builtin_symbol_table()
    {
        auto result = std::make_shared<symbol_table>();

        result->enter("Int", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Int"))));
        result->enter("Word", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Word"))));
        result->enter("Char", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Char"))));
        result->enter("Pointer", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Pointer"))));
        result->enter("Float", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Float"))));
        result->enter("String", std::make_shared<type_info>(type(std::make_shared<primitive_type>("String"))));

        type boolean = type(std::make_shared<primitive_type>("Bool"));
        result->enter("Bool", std::make_shared<type_info>(boolean));

        procedure_type assert_symbol{ procedure_type::return_t() };
        assert_symbol.parameters.push_back(boolean);
        std::shared_ptr<procedure_info> assert_info = std::make_shared<procedure_info>(assert_symbol,
            std::vector<std::string>{ "condition" });
        result->enter("assert", assert_info);

        return result;
    }

    symbol_bag::symbol_bag(forward_table&& unresolved, std::shared_ptr<symbol_table> global_table)
        : unresolved(unresolved)
    {
        this->symbols = std::make_shared<symbol_table>(global_table);
    }

    std::shared_ptr<info> symbol_bag::lookup(const std::string& name)
    {
        for (auto import_bag : this->imports)
        {
            if (auto result = import_bag->lookup(name))
            {
                return result;
            }
        }
        return this->symbols->lookup(name);
    }

    bool symbol_bag::enter(const std::string& name, std::shared_ptr<info> entry)
    {
        return this->symbols->enter(name, entry);
    }

    std::shared_ptr<symbol_table> symbol_bag::enter()
    {
        this->symbols = std::make_shared<symbol_table>(this->symbols);
        return this->symbols;
    }

    void symbol_bag::enter(std::shared_ptr<symbol_table> child)
    {
        this->symbols = child;
    }

    std::shared_ptr<symbol_table> symbol_bag::leave()
    {
        std::shared_ptr<symbol_table> result = this->symbols;

        this->symbols = result->scope();
        return result;
    }

    std::shared_ptr<alias_type> symbol_bag::declared(const std::string& symbol_name)
    {
        auto unresolved_alias = this->unresolved.find(symbol_name);

        return unresolved_alias == this->unresolved.end() ? std::shared_ptr<alias_type>() : unresolved_alias->second;
    }

    std::shared_ptr<alias_type> symbol_bag::resolve(const std::string& symbol_name, type& resolution)
    {
        auto unresolved_declaration = this->unresolved.at(symbol_name);

        unresolved_declaration->referent = resolution;
        return unresolved_declaration;
    }

    void symbol_bag::add_import(const symbol_bag& bag)
    {
        this->imports.push_front(bag.exported_symbols());
    }

    std::shared_ptr<symbol_table> symbol_bag::exported_symbols() const
    {
        if (!m_exported)
        {
            m_exported = std::make_shared<symbol_table>(symbols->scope());
            for (const auto& [name, info] : *symbols)
            {
                if (info->exported)
                {
                    m_exported->enter(name, info);
                }
            }
        }
        return m_exported;
    }

    type resolve_underlying_type(std::shared_ptr<alias_type> alias)
    {
        return resolve_underlying_type(alias->referent);
    }

    type resolve_underlying_type(const type& alias)
    {
        type resolved_alias = resolve_aliases(alias);

        if (auto qualified = resolved_alias.get<constant_type>())
        {
            return resolve_underlying_type(qualified->unqualified);
        }
        else
        {
            return resolved_alias;
        }
    }

    type resolve_aliases(const type& checked)
    {
        if (auto alias = checked.get<alias_type>())
        {
            return resolve_aliases(alias->referent);
        }
        return checked;
    }

    bool is_primitive_type(const type& checked, const std::string& name)
    {
        if (auto primitive_checked = checked.get<primitive_type>())
        {
            return primitive_checked->identifier == name;
        }
        return false;
    }

    bool is_any_pointer_type(const type& checked)
    {
        return checked.get<pointer_type>() != nullptr
            || checked.get<procedure_type>() != nullptr
            || is_primitive_type(resolve_underlying_type(checked), "Pointer");
    }
}