/** @file DGlobalSymtab.cpp
*
 *  @author Roland Conybeare, Jan 2026
 **/

#include "DGlobalSymtab.hpp"
#include "DUniqueString.hpp"
#include <xo/expression2/Expression.hpp>
#include <xo/expression2/Variable.hpp>
#include <xo/object2/Array.hpp>
#include <xo/gc/GCObject.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/scope.hpp>

namespace xo {
    using xo::map::DArenaHashMap;
    using xo::mm::AGCObject;

    namespace scm {

        DGlobalSymtab::DGlobalSymtab(dp<repr_type> map,
                                     DArray * vars)
        : map_{std::move(map)}, vars_{vars}
        {
        }

        dp<DGlobalSymtab>
        DGlobalSymtab::make(obj<AAllocator> mm,
                            obj<AAllocator> aux_mm,
                            const ArenaHashMapConfig & cfg)
        {
            auto map = dp<repr_type>::make(aux_mm, cfg);
            assert(map);

            /* choosing same capacity for hash, vars */
            DArray * vars = DArray::empty(mm, map->capacity());
            assert(vars);

            auto symtab = dp<DGlobalSymtab>::make(mm, std::move(map), vars);
            assert(symtab);

            return symtab;
        }

        void
        DGlobalSymtab::visit_pools(const MemorySizeVisitor & visitor) const
        {
            if (map_)
                map_->visit_pools(visitor);
        }

        DVariable *
        DGlobalSymtab::lookup_variable(const DUniqueString * sym) const noexcept
        {
            Binding existing = this->lookup_binding(sym);

            if (existing.is_null())
                return nullptr;

            auto var_gco = obj<AGCObject,DVariable>::from((*vars_)[existing.j_slot()]);
            auto var = var_gco.to_facet<AExpression>();

            assert(var.data());

            return var.data();
        }

        DVariable *
        DGlobalSymtab::establish_variable(obj<AAllocator> mm,
                                          const DUniqueString * sym,
                                          TypeRef typeref)
        {
            DVariable * var = this->lookup_variable(sym);

            if (!var) {
                assert(vars_);

                DArray::size_type n = vars_->size();

                // NOTE: expansion here is moot at present (Feb 2026).
                //       Not implemented in ArenaHashMap

                /** make sure vars_ has room **/
                if (n == vars_->capacity()) {
                    // reallocate with more capacity
                    DArray * vars_2x = DArray::copy(mm, vars_, vars_->capacity() * 2);

                    assert(vars_2x);

                    this->vars_ = vars_2x;
                }

                /** create new variable **/
                Binding binding = Binding::global(n);
                var = DVariable::make(mm, sym, typeref, binding);

                if (!var) {
                    // something terribly wrong
                    assert(false);
                    return var;
                }

                assert(map_->size() < map_->capacity());

                (*map_)[sym] = binding.j_slot();

                bool ok = vars_->push_back(obj<AGCObject,DVariable>(var));

                if (!ok)
                    assert(false);
            }

            return var;
        }

        Binding
        DGlobalSymtab::lookup_binding(const DUniqueString * sym) const noexcept
        {
            assert(sym);

            scope log(XO_DEBUG(true), "stub");
            log && log(xtag("sym", std::string_view(*sym)));

            auto ix = map_->find(sym);

            if (ix == map_->end())
                return Binding::null();

            return Binding::global(ix->second);
        }

        // ----- gcobject facet -----

        std::size_t
        DGlobalSymtab::shallow_size() const noexcept
        {
            return sizeof(DGlobalSymtab);
        }

        DGlobalSymtab *
        DGlobalSymtab::shallow_copy(obj<AAllocator> mm) const noexcept
        {
            /** can't use std_copy_for because of non-copyable dp<repr_type>
             *
             * TODO: rename to shallow_move() throughout, and have std_copy_for()
             *       -> std_move_for()
             *
             **/

            void * copy_mem = mm.alloc_copy_for(this);

            if (copy_mem) {
                DGlobalSymtab * self = const_cast<DGlobalSymtab*>(this);

                return new (copy_mem) DGlobalSymtab(std::move(self->map_), vars_);
            }

            return nullptr;
        }

        std::size_t
        DGlobalSymtab::forward_children(obj<ACollector> gc) noexcept
        {
            // map_ doesn't contain any gc-owned data, can skip

            gc.forward_inplace(&vars_);

            return this->shallow_size();
        }

    } /*namespace scm*/
} /*namespace xo*/

/* end DGlobalSymtab.cpp */