/* Name 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/semantic.h"

namespace elna
{
namespace boot
{
    type::type()
        : tag(type_tag::alias)
    {
    }

    type::type(std::shared_ptr<alias_type> alias)
        : tag(type_tag::alias), alias(alias)
    {
    }

    type::type(std::shared_ptr<primitive_type> primitive)
        : tag(type_tag::primitive), primitive(primitive)
    {
    }

    type::type(std::shared_ptr<record_type> record)
        : tag(type_tag::record), record(record)
    {
    }

    type::type(std::shared_ptr<union_type> _union)
        : tag(type_tag::_union), _union(_union)
    {
    }

    type::type(std::shared_ptr<pointer_type> pointer)
        : tag(type_tag::pointer), pointer(pointer)
    {
    }

    type::type(std::shared_ptr<array_type> array)
        : tag(type_tag::array), array(array)
    {
    }

    void type::copy(const type& other)
    {
        switch (other.tag)
        {
        case type_tag::empty:
            break;
        case type_tag::alias:
            new (&alias) std::weak_ptr<alias_type>(other.alias);
            break;
        case type_tag::primitive:
            new (&primitive) std::weak_ptr<primitive_type>(other.primitive);
            break;
        case type_tag::record:
            new (&record) std::shared_ptr<record_type>(other.record);
            break;
        case type_tag::_union:
            new (&_union) std::shared_ptr<union_type>(other._union);
            break;
        case type_tag::pointer:
            new (&pointer) std::shared_ptr<pointer_type>(other.pointer);
            break;
        case type_tag::array:
            new (&array) std::shared_ptr<array_type>(other.array);
            break;
        }
    }

    type::type(const type& other)
        : tag(other.tag)
    {
        copy(other);
    }

    void type::move(type&& other)
    {
        switch (other.tag)
        {
        case type_tag::empty:
            break;
        case type_tag::alias:
            new (&alias) std::weak_ptr<alias_type>(std::move(other.alias));
            break;
        case type_tag::primitive:
            new (&primitive) std::weak_ptr<primitive_type>(std::move(other.primitive));
            break;
        case type_tag::record:
            new (&record) std::shared_ptr<record_type>(std::move(other.record));
            break;
        case type_tag::_union:
            new (&_union) std::shared_ptr<union_type>(std::move(other._union));
            break;
        case type_tag::pointer:
            new (&pointer) std::shared_ptr<pointer_type>(std::move(other.pointer));
            break;
        case type_tag::array:
            new (&array) std::shared_ptr<array_type>(std::move(other.array));
            break;
        }
    }

    type& type::operator=(const type& other)
    {
        this->~type();
        this->tag = other.tag;
        copy(other);
        return *this;
    }

    type::type(type&& other)
        : tag(other.tag)
    {
        move(std::move(other));
    }

    type& type::operator=(type&& other)
    {
        this->~type();
        this->tag = other.tag;
        move(std::move(other));
        return *this;
    }

    type::~type()
    {
        switch (tag)
        {
        case type_tag::empty:
            break;
        case type_tag::alias:
            break;
        case type_tag::primitive:
            break;
        case type_tag::record:
            this->record.~shared_ptr<record_type>();
            break;
        case type_tag::_union:
            this->_union.~shared_ptr<union_type>();
            break;
        case type_tag::pointer:
            this->pointer.~shared_ptr<pointer_type>();
            break;
        case type_tag::array:
            this->array.~shared_ptr<array_type>();
            break;
        }
    }

    template<>
    std::shared_ptr<alias_type> type::get<alias_type>() const
    {
        if (tag == type_tag::alias)
        {
            return this->alias.lock();
        }
        else
        {
            return nullptr;
        }
    }

    template<>
    std::shared_ptr<primitive_type> type::get<primitive_type>() const
    {
        if (tag == type_tag::primitive)
        {
            return this->primitive.lock();
        }
        else
        {
            return nullptr;
        }
    }

    template<>
    std::shared_ptr<record_type> type::get<record_type>() const
    {
        if (tag == type_tag::record)
        {
            return this->record;
        }
        else
        {
            return nullptr;
        }
    }

    template<>
    std::shared_ptr<union_type> type::get<union_type>() const
    {
        if (tag == type_tag::_union)
        {
            return this->_union;
        }
        else
        {
            return nullptr;
        }
    }

    template<>
    std::shared_ptr<pointer_type> type::get<pointer_type>() const
    {
        if (tag == type_tag::pointer)
        {
            return this->pointer;
        }
        else
        {
            return nullptr;
        }
    }

    template<>
    std::shared_ptr<array_type> type::get<array_type>() const
    {
        if (tag == type_tag::array)
        {
            return this->array;
        }
        else
        {
            return nullptr;
        }
    }

    bool type::empty() const
    {
        return tag == type_tag::empty;
    }

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

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

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

    void declaration_visitor::visit(program *program)
    {
        for (type_definition *const type : program->types)
        {
            this->unresolved.insert({ type->identifier, std::make_shared<alias_type>() });
        }
        for (type_definition *const type : program->types)
        {
            type->accept(this);
        }
    }

    void declaration_visitor::visit(type_definition *definition)
    {
        auto unresolved_declaration = this->unresolved.at(definition->identifier);

        definition->body().accept(this);

        unresolved_declaration->reference = this->current_type;
    }

    void declaration_visitor::visit(primitive_type_expression *type_expression)
    {
        auto unresolved_alias = this->unresolved.find(type_expression->name);

        if (unresolved_alias != this->unresolved.end())
        {
            this->current_type = type(unresolved_alias->second);
        }
        else
        {
            this->current_type = type(std::make_shared<primitive_type>(type_expression->name));
        }
    }

    void declaration_visitor::visit(array_type_expression *type_expression)
    {
    }

    void declaration_visitor::visit(pointer_type_expression *type_expression)
    {
        type_expression->base().accept(this);
        this->current_type = type(std::make_shared<pointer_type>(this->current_type));
    }

    void declaration_visitor::visit(record_type_expression *type_expression)
    {
        auto type_definition = std::make_shared<record_type>();

        this->current_type = type(type_definition);
    }

    void declaration_visitor::visit(union_type_expression *type_expression)
    {
        auto type_definition = std::make_shared<union_type>();

        this->current_type = type(type_definition);
    }

    void declaration_visitor::visit(procedure_type_expression *type_expression)
    {
    }
}
}