/* 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"

#include <utility>

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<slice_type> slice)
        : payload(slice)
    {
    }

    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 (const auto *weak_pointer = std::get_if<std::weak_ptr<alias_type>>(&payload)) {
                return weak_pointer->lock();
}
            return nullptr;
        }
        else
        {
            if (auto *shared_pointer = std::get_if<std::shared_ptr<T>>(&payload)) {
                return *shared_pointer;
}
            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<slice_type> type::get<slice_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 const resolved_this = resolve_aliases(*this);
        type const 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_slice = resolved_this.get<slice_type>())
        {
            auto right_slice = resolved_that.get<slice_type>();

            return right_slice != nullptr && left_slice->base == right_slice->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& payload) -> std::string {
            using T = std::decay_t<decltype(payload)>;
            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 payload.lock()->name;
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<primitive_type>>)
            {
                return payload->identifier;
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<pointer_type>>)
            {
                return "^" + payload->base.to_string();
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<constant_type>>)
            {
                return "const " + payload->unqualified.to_string();
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<array_type>>)
            {
                return "[" + std::to_string(payload->size) + "]" + payload->base.to_string();
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<slice_type>>)
            {
                return "[]" + payload->base.to_string();
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<record_type>>)
            {
                return payload->base.empty()
                    ? "record ... end"
                    : "record(" + payload->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 < payload->parameters.size(); ++i)
                {
                    if (i > 0) { result += ", ";
}
                    result += payload->parameters[i].to_string();
                }
                result += ")";
                if (payload->return_type.no_return) {
                    result += ": !";
                } else if (!payload->return_type.proper_type.empty()) {
                    result += ": " + payload->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) 
    {
    }

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

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

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

    slice_type::slice_type(type base)
        : base(std::move(base))
    {
    }

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

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

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

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

    info::~info() = default;

    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(std::move(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 const 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> const 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, const 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 (const 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, const 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 = std::move(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(const 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_numeric_type(const type& checked)
    {
        type const resolved = resolve_underlying_type(checked);

        return is_primitive_type(resolved, "Int")
            || is_primitive_type(resolved, "Word")
            || is_primitive_type(resolved, "Float");
    }

    bool is_integral_type(const type& checked)
    {
        type const resolved = resolve_underlying_type(checked);

        return is_primitive_type(resolved, "Int")
            || is_primitive_type(resolved, "Word");
    }

    bool is_discrete_type(const type& checked)
    {
        type const resolved = resolve_underlying_type(checked);

        return is_primitive_type(resolved, "Int")
            || is_primitive_type(resolved, "Word")
            || is_primitive_type(resolved, "Bool")
            || is_primitive_type(resolved, "Char");
    }

    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");
    }
}