/* Type analysis.
   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/type_check.h"

#include <algorithm>
#include <utility>

namespace elna::boot
{
    non_constant_initializer_error::non_constant_initializer_error(const source_position position)
        : error(position)
    {
    }

    std::string non_constant_initializer_error::what() const
    {
        return "Variable initializers must be constant expressions";
    }

    type_mismatch_error::type_mismatch_error(const source_position position,
            type expected, type actual)
        : error(position), expected(std::move(expected)), actual(std::move(actual))
    {
    }

    std::string type_mismatch_error::what() const
    {
        return "Expected type '" + expected.to_string()
            + "', but got '" + actual.to_string() + "'";
    }

    constant_assignment_error::constant_assignment_error(const source_position position,
            type assignee)
        : error(position), assignee(std::move(assignee))
    {
    }

    std::string constant_assignment_error::what() const
    {
        return "Cannot assign to a value of type '" + assignee.to_string()
            + "', because it is constant or contains constant members";
    }

    field_not_found_error::field_not_found_error(const identifier& field_name,
            type composite_type)
        : error(field_name.position()), field_name(field_name.name()), composite_type(std::move(composite_type))
    {
    }

    std::string field_not_found_error::what() const
    {
        type const resolved = resolve_underlying_type(composite_type);
        bool const is_enum = resolved.get<enumeration_type>() != nullptr;
        bool const is_record = resolved.get<record_type>() != nullptr;

        if (is_enum || is_record)
        {
            std::string message = is_enum ? "Enumeration" : "Record";

            if (auto alias = composite_type.get<alias_type>())
            {
                message += " '" + alias->name + "'";
            }
            message += " does not have a ";
            message += is_enum ? "member" : "field";
            message += " named '" + field_name + "'";
            return message;
        }
        return "Type '" + composite_type.to_string()
            + "' does not have a field named '" + field_name + "'";
    }

    duplicate_member_error::duplicate_member_error(const boot::identifier& member_name,
            type aggregate, std::optional<source_position> original,
            std::optional<std::string> base_name)
        : error(member_name.position()), member_name(member_name.name()), aggregate(std::move(aggregate)),
        original(original), base_name(std::move(base_name))
    {
    }

    std::string duplicate_member_error::what() const
    {
        type const resolved = resolve_underlying_type(aggregate);
        bool const is_enum = resolved.get<enumeration_type>() != nullptr;
        std::string const kind = is_enum ? "member" : "field";
        std::string message = is_enum ? "Enumeration" : "Record";

        if (auto alias = aggregate.get<alias_type>())
        {
            message += " '" + alias->name + "'";
        }
        message += " already has a " + kind + " named '" + member_name + "'";

        if (base_name.has_value())
        {
            message += " (defined in base type '" + *base_name + "')";
        }
        return message;
    }

    std::optional<std::pair<std::string, source_position>> duplicate_member_error::note() const
    {
        if (original.has_value() && original->start().available())
        {
            return std::make_pair("previously declared here", *original);
        }
        return std::nullopt;
    }

    cyclic_declaration_error::cyclic_declaration_error(const std::vector<std::string>& cycle,
            const source_position position)
        : error(position), cycle(cycle)
    {
    }

    std::string cyclic_declaration_error::what() const
    {
        auto segment = std::cbegin(this->cycle);
        std::string message = "Type declaration forms a cycle: " + *segment;

        ++segment;
        for (; segment != std::cend(this->cycle); ++segment)
        {
            message += " -> " + *segment;
        }
        return message;
    }

    return_error::return_error(const std::string& identifier, const source_position position,
            type return_type)
        : error(position), identifier(identifier), return_type(std::move(return_type))
    {
    }

    std::string return_error::what() const
    {
        if (!return_type.empty())
        {
            return "Procedure '" + this->identifier
                + "' does not return a value, but return expression has type '"
                + return_type.to_string() + "'";
        }
        return "Procedure '" + this->identifier
            + "' is expected to return, but does not have a return statement";
    }

    base_type_error::base_type_error(type actual, const source_position position)
        : error(position), actual(std::move(actual))
    {
    }

    std::string base_type_error::what() const
    {
        return "'" + actual.to_string() + "' is not a record type";
    }

    argument_count_error::argument_count_error(std::size_t expected, std::size_t actual,
            const source_position position)
        : error(position), expected(expected), actual(actual)
    {
    }

    std::string argument_count_error::what() const
    {
        if (actual > expected)
        {
            return "Too many arguments, expected " + std::to_string(expected)
                + ", got " + std::to_string(actual);
        }
        else
        {
            return "Too few arguments, expected " + std::to_string(expected)
                + ", got " + std::to_string(actual);
        }
    }

    unsupported_trait_type_error::unsupported_trait_type_error(const identifier& trait,
            type actual)
        : error(trait.position()), actual(std::move(actual)), trait_name(trait.name())
    {
    }

    std::string unsupported_trait_type_error::what() const
    {
        return "Type '" + actual.to_string()
            + "' does not support trait '#" + trait_name + "'";
    }

    unary_operation_error::unary_operation_error(const source_position position,
            type actual, unary_operator operation)
        : error(position), actual(std::move(actual)), op(operation)
    {
    }

    char unary_operation_error::unary_operator_symbol(unary_operator operation)
    {
        switch (operation)
        {
            using enum unary_operator;
            case reference:
                return '@';
            case negation:
                return '~';
            case minus:
                return '-';
            case plus:
                return '+';
        }
        __builtin_unreachable();
    }

    std::string unary_operation_error::what() const
    {
        return "Type '" + actual.to_string()
            + "' cannot be used with unary '"
            + unary_operator_symbol(op) + "'";
    }

    /*
     * Whether the type itself is constant or has a constant member at any
     * nesting level, so that values of this type cannot be reassigned as a
     * whole. Pointers to constants do not make the type itself constant.
     */
    static bool contains_constant_member(const type& checked)
    {
        auto referent = resolve_aliases(checked);

        if (referent.get<constant_type>() != nullptr)
        {
            return true;
        }
        else if (auto record = referent.get<record_type>())
        {
            for (const type_field& field : record->fields)
            {
                if (contains_constant_member(field.second))
                {
                    return true;
                }
            }
            return !record->base.empty()
                && contains_constant_member(resolve_underlying_type(record->base));
        }
        else if (auto array = referent.get<array_type>())
        {
            return contains_constant_member(array->base);
        }
        return false;
    }

    bool type_analysis_visitor::check_unresolved_symbol(const std::shared_ptr<alias_type>& alias,
            std::vector<std::string>& alias_path)
    {
        if (std::ranges::find(alias_path, alias->name) != std::cend(alias_path))
        {
            return false;
        }
        alias_path.push_back(alias->name);

        if (auto another_alias = alias->referent.get<alias_type>())
        {
            return check_unresolved_symbol(another_alias, alias_path);
        }
        return true;
    }

    /*
     * Checks whether derived has base in its record parent chain.
     *
     * Base record type must not be null. Derived record type may be null.
     */
    static bool is_base_of(const std::shared_ptr<record_type>& base,
            const std::shared_ptr<record_type>& derived)
    {
        if (derived != nullptr)
        {
            if (auto current_record = resolve_underlying_type(derived->base).get<record_type>())
            {
                return current_record == base || is_base_of(base, current_record);
            }
        }
        return false;
    }

    assign_check::verdict assign_check::guard_const_laundering() const
    {
        if (!is_primitive_type(ctx.aliased_assignee, "Pointer"))
        {
            return verdict::pass;
        }
        if (auto ptr = ctx.aliased_assignment.get<pointer_type>();
                ptr != nullptr && resolve_aliases(ptr->base).get<constant_type>() != nullptr)
        {
            return verdict::reject;
        }
        if (auto const_assign = ctx.aliased_assignment.get<constant_type>();
                const_assign != nullptr && is_primitive_type(const_assign->unqualified, "Pointer"))
        {
            return verdict::reject;
        }
        return verdict::pass;
    }

    assign_check::verdict assign_check::check_exact_match() const
    {
        return ctx.resolved_assignee == ctx.resolved_assignment ? verdict::accept : verdict::pass;
    }

    assign_check::verdict assign_check::check_pointer_hatch() const
    {
        if (is_primitive_type(ctx.resolved_assignee, "Pointer")
                && is_any_pointer_type(ctx.resolved_assignment))
        {
            return verdict::accept;
        }
        if (is_primitive_type(ctx.resolved_assignment, "Pointer")
                && is_any_pointer_type(ctx.resolved_assignee))
        {
            return verdict::accept;
        }
        return verdict::pass;
    }

    assign_check::verdict assign_check::check_pointer_conversion() const
    {
        auto assignee_ptr = ctx.resolved_assignee.get<pointer_type>();
        auto assignment_ptr = ctx.resolved_assignment.get<pointer_type>();

        if (assignee_ptr == nullptr || assignment_ptr == nullptr)
        {
            return verdict::reject;
        }
        auto assignee_pointee_const = resolve_aliases(assignee_ptr->base).get<constant_type>();
        auto assignment_pointee_const = resolve_aliases(assignment_ptr->base).get<constant_type>();

        // Constness can be added at the first indirection level, but not removed.
        if (assignee_pointee_const != nullptr
                && assignee_pointee_const->unqualified == assignment_ptr->base)
        {
            return verdict::accept;
        }
        if (assignment_pointee_const != nullptr && assignee_pointee_const == nullptr)
        {
            return verdict::reject;
        }
        // A pointer to a record can be assigned to a pointer to its base type.
        if (auto assignee_record = resolve_underlying_type(assignee_ptr->base).get<record_type>())
        {
            return is_base_of(assignee_record,
                    resolve_underlying_type(assignment_ptr->base).get<record_type>())
                ? verdict::accept : verdict::pass;
        }
        return verdict::pass;
    }

    bool assign_check::run()
    {
        for (auto handler : {&assign_check::guard_const_laundering,
                &assign_check::check_exact_match,
                &assign_check::check_pointer_hatch,
                &assign_check::check_pointer_conversion})
        {
            switch ((this->*handler)())
            {
                case verdict::accept: return true;
                case verdict::reject: return false;
                case verdict::pass:;
            }
        }
        return false;
    }

    bool type_analysis_visitor::is_assignable_from(const type& assignee, const type& assignment)
    {
        return assign_check{
                resolve_aliases(assignee),
                resolve_aliases(assignment),
                resolve_underlying_type(assignee),
                resolve_underlying_type(assignment)
            }.run();
    }

    type_analysis_visitor::type_analysis_visitor(symbol_bag bag, const target_info& target)
        :  bag(std::move(bag)), target(target)
    {
    }

    void type_analysis_visitor::visit(procedure_declaration *declaration)
    {
        this->current_procedure = this->bag.lookup(declaration->identifier.name())->is_procedure();

        if (declaration->body.has_value())
        {
            this->bag.enter(this->current_procedure->scope);
        }
        walking_visitor::visit(declaration);

        if (declaration->body.has_value())
        {
            if (declaration->body.value().return_expression != nullptr)
            {
                const expression *return_expr = declaration->body.value().return_expression;
                type const return_type = this->current_procedure->symbol.return_type.proper_type;

                if (!return_type.empty())
                {
                    if (!is_assignable_from(return_type, return_expr->type_decoration))
                    {
                        add_error<type_mismatch_error>(
                                return_expr->position(), return_type, return_expr->type_decoration);
                    }
                }
                else
                {
                    add_error<return_error>(declaration->identifier.name(),
                            return_expr->position(), return_expr->type_decoration);
                }
            }
            else if (declaration->heading().return_type.proper_type != nullptr)
            {
                add_error<return_error>(declaration->identifier.name(), declaration->position());
            }
            this->bag.leave();
        }
        this->current_procedure.reset();
    }

    void type_analysis_visitor::visit(unit *unit)
    {
        walking_visitor::visit(unit);
    }

    void type_analysis_visitor::visit(assign_statement *statement)
    {
        walking_visitor::visit(statement);

        if (contains_constant_member(statement->lvalue().type_decoration))
        {
            add_error<constant_assignment_error>(statement->position(),
                    statement->lvalue().type_decoration);
        }
        else if (!is_assignable_from(statement->lvalue().type_decoration, statement->rvalue().type_decoration))
        {
            add_error<type_mismatch_error>(statement->position(),
                    statement->lvalue().type_decoration, statement->rvalue().type_decoration);
        }
    }

    void type_analysis_visitor::visit(variable_declaration *declaration)
    {
        walking_visitor::visit(declaration);

        if (declaration->initializer == nullptr || has_errors())
        {
            return;
        }
        evaluator constant_evaluator(this->bag, this->target, this->evaluated_initializers);
        if (!constant_evaluator.evaluate(*declaration->initializer))
        {
            add_error<non_constant_initializer_error>(declaration->initializer->position());
            return;
        }
        // Record const variable initializers so later declarations
        // can chain through them.
        for (const auto& identifier : declaration->identifiers)
        {
            if (auto var = this->bag.lookup(identifier.name())->is_variable();
                    resolve_aliases(var->symbol).get<constant_type>() != nullptr)
            {
                this->evaluated_initializers[identifier.name()] = declaration->initializer;
            }
        }
        for (const identifier_definition& variable_identifier : declaration->identifiers)
        {
            auto variable_symbol = this->bag.lookup(variable_identifier.name())->is_variable();
            if (!is_assignable_from(variable_symbol->symbol, declaration->initializer->type_decoration))
            {
                add_error<type_mismatch_error>(
                        declaration->initializer->position(),
                        variable_symbol->symbol, declaration->initializer->type_decoration);
            }
        }
    }

    void type_analysis_visitor::visit(case_statement *statement)
    {
        walking_visitor::visit(statement);
        type const condition_type = resolve_underlying_type(statement->condition().type_decoration);

        for (const switch_case& case_block : statement->cases)
        {
            for (const expression *case_label : case_block.labels)
            {
                if (!is_assignable_from(condition_type, case_label->type_decoration))
                {
                    add_error<type_mismatch_error>(
                            case_label->position(), condition_type, case_label->type_decoration);
                }
            }
        }
    }

    void type_analysis_visitor::visit(type_declaration *declaration)
    {
        std::vector<std::string> alias_path;
        auto unresolved_type = this->bag.lookup(declaration->identifier.name())->is_type()->symbol.get<alias_type>();

        if (!check_unresolved_symbol(unresolved_type, alias_path))
        {
            add_error<cyclic_declaration_error>(alias_path, declaration->position());
        }
        else
        {
            walking_visitor::visit(declaration);
        }
    }

    void type_analysis_visitor::visit(record_type_expression *expression)
    {
        if (expression->base.has_value())
        {
            type const base_type = resolve_underlying_type(this->bag.lookup(expression->base.value().name())->is_type()->symbol);
            if (base_type.get<record_type>() == nullptr)
            {
                add_error<base_type_error>(base_type, expression->position());
            }
        }
        walking_visitor::visit(expression);
    }

    void type_analysis_visitor::visit(procedure_call *call)
    {
        call->callable().accept(this);

        if (auto procedure = call->callable().type_decoration.get<procedure_type>())
        {
            std::vector<expression *>::const_iterator argument_iterator = std::cbegin(call->arguments);
            std::vector<type>::const_iterator type_iterator = std::cbegin(procedure->parameters);

            while (argument_iterator != std::cend(call->arguments)
                    && type_iterator != std::cend(procedure->parameters))
            {
                (*argument_iterator)->accept(this);
                if (!is_assignable_from(*type_iterator, (*argument_iterator)->type_decoration))
                {
                    add_error<type_mismatch_error>(
                            (*argument_iterator)->position(), *type_iterator,
                            (*argument_iterator)->type_decoration);
                }
                ++argument_iterator;
                ++type_iterator;
            }
            if (call->arguments.size() != procedure->parameters.size())
            {
                add_error<argument_count_error>(procedure->parameters.size(),
                        call->arguments.size(), call->position());
            }
        }
    }

    void type_analysis_visitor::visit(record_constructor_expression *expression)
    {
        auto record = resolve_underlying_type(expression->type_decoration).get<record_type>();

        if (record == nullptr)
        {
            add_error<type_mismatch_error>(
                    expression->position(), type(std::make_shared<record_type>()),
                    expression->type_decoration);
            return;
        }
        for (const field_initializer& initializer : expression->field_initializers)
        {
            for (const type_field& field : record->fields)
            {
                if (field.first == initializer.name())
                {
                    if (!is_assignable_from(field.second, initializer.value().type_decoration))
                    {
                        add_error<type_mismatch_error>(
                                initializer.value().position(), field.second,
                                initializer.value().type_decoration);
                    }
                    break;
                }
            }
        }
    }

    void type_analysis_visitor::visit(array_constructor_expression *expression)
    {
        auto array = resolve_underlying_type(expression->type_decoration).get<array_type>();

        if (array == nullptr)
        {
            add_error<type_mismatch_error>(
                    expression->position(), type(std::make_shared<array_type>(type(), 0)),
                    expression->type_decoration);
            return;
        }
        if (expression->elements.size() > array->size)
        {
            add_error<argument_count_error>(array->size, expression->elements.size(),
                    expression->position());
            return;
        }
        for (auto *element : expression->elements)
        {
            if (!is_assignable_from(array->base, element->type_decoration))
            {
                add_error<type_mismatch_error>(
                        element->position(), array->base, element->type_decoration);
            }
        }
    }

    void type_analysis_visitor::visit(unary_expression *expression)
    {
        walking_visitor::visit(expression);

        auto operation = expression->operation();
        type const resolved = resolve_underlying_type(expression->operand().type_decoration);

        if (operation == unary_operator::plus)
        {
            if (!is_numeric_type(resolved))
            {
                add_error<unary_operation_error>(expression->position(),
                        expression->operand().type_decoration, operation);
            }
        }
        else if (operation == unary_operator::minus)
        {
            if (!is_primitive_type(resolved, "Int")
                    && !is_primitive_type(resolved, "Float"))
            {
                add_error<unary_operation_error>(expression->position(),
                        expression->operand().type_decoration, operation);
            }
        }
        else if (operation == unary_operator::negation)
        {
            if (!is_primitive_type(resolved, "Bool")
                    && !is_integral_type(resolved))
            {
                add_error<unary_operation_error>(expression->position(),
                        expression->operand().type_decoration, operation);
            }
        }
    }
}