/*!
    \file fbe.cpp
    \brief Fast binary encoding implementation
    \author Ivan Shynkarenka
    \date 11.04.2018
    \copyright MIT License
*/

#include "fbe.h"

namespace FBE {

void Attributes::Merge(Attributes* attributes)
{
    deprecated |= attributes->deprecated;
    hidden |= attributes->hidden;
}

void EnumBody::AddValue(EnumValue* v)
{
    if (v == nullptr)
        yyerror("Enum is null!");
    if (v->name->empty())
        yyerror("Enum name is invalid!");

    // Check for duplicates
    auto it = std::find_if(values.begin(), values.end(), [v](auto item)->bool { return *item->name.get() == *v->name.get(); });
    if (it != values.end())
        yyerror("Duplicate enum name " + *v->name.get());

    values.push_back(std::shared_ptr<EnumValue>(v));
}

void FlagsBody::AddValue(FlagsValue* v)
{
    if (v == nullptr)
        yyerror("Flags is null!");
    if (v->name->empty())
        yyerror("Flags name is invalid!");
    if (!v->value || (!v->value->constant && !v->value->reference))
        yyerror("Flags value is invalid!");

    // Check for duplicates
    auto it = std::find_if(values.begin(), values.end(), [v](auto item)->bool { return *item->name.get() == *v->name.get(); });
    if (it != values.end())
        yyerror("Duplicate flags name " + *v->name.get());

    values.push_back(std::shared_ptr<FlagsValue>(v));
}

void StructField::SetArraySize(int size)
{
    if (size <= 0)
        yyerror("Array size should be greater than zero!");

    N = size;
}

void StructBody::AddField(StructField* f)
{
    if (f == nullptr)
        yyerror("Struct field is null!");
    if (f->name->empty())
        yyerror("Struct field name is invalid!");
    if (f->type->empty())
        yyerror("Struct field type is invalid!");

    // Check for duplicates
    auto it = std::find_if(fields.begin(), fields.end(), [f](auto item)->bool { return *item->name.get() == *f->name.get(); });
    if (it != fields.end())
        yyerror("Duplicate struct field name " + *f->name.get());

    fields.push_back(std::shared_ptr<StructField>(f));
}

void StructRejects::AddReject(std::string* r, bool g)
{
    if (r == nullptr)
        yyerror("Reject is null!");
    if (r->empty())
        yyerror("Reject is invalid!");

    // Check for duplicates
    auto it = std::find_if(rejects.begin(), rejects.end(), [r](auto item)->bool { return *item.reject.get() == *r; });
    if (it != rejects.end())
        yyerror("Duplicate reject " + *r);

    rejects.push_back({ std::shared_ptr<std::string>(r), g });
}

int StructType::stype = 0;

StructType::StructType(int t, bool f) : type(t), fixed(f)
{
    if (type < 0)
        yyerror("Struct type should not be negative!");

    if (!fixed)
    {
        if (type == 0)
            type = ++stype;
        else
            stype = type;
    }
}

void Statements::AddStatement(Statement* st)
{
    if (st == nullptr)
        yyerror("Statement is null!");

    if (st->e)
        AddEnum(st->e);
    if (st->f)
        AddFlags(st->f);
    if (st->s)
        AddStruct(st->s);

    delete st;
}

void Statements::AddEnum(std::shared_ptr<EnumType>& e)
{
    if (e == nullptr)
        yyerror("Enum is null!");
    if (e->name->empty())
        yyerror("Enum name is invalid!");
    if (!e->body)
        yyerror("Enum is empty - " + *e->name.get());

    // Check for duplicates
    auto it = std::find_if(enums.begin(), enums.end(), [&e](auto item)->bool { return *item->name.get() == *e->name.get(); });
    if (it != enums.end())
        yyerror("Duplicate enum name " + *e->name.get());

    enums.push_back(e);
}

void Statements::AddFlags(std::shared_ptr<FlagsType>& f)
{
    if (f == nullptr)
        yyerror("Flags is null!");
    if (f->name->empty())
        yyerror("Flags name is invalid!");
    if (!f->body)
        yyerror("Flags is empty - " + *f->name.get());

    // Check for duplicates
    auto it = std::find_if(flags.begin(), flags.end(), [&f](auto item)->bool { return *item->name.get() == *f->name.get(); });
    if (it != flags.end())
        yyerror("Duplicate flags name " + *f->name.get());

    flags.push_back(f);
}

void Statements::AddStruct(std::shared_ptr<StructType>& s)
{
    if (s == nullptr)
        yyerror("Struct is null!");
    if (s->name->empty())
        yyerror("Struct name is invalid!");
    if (!s->body)
        yyerror("Struct is empty - " + *s->name.get());

    // Check for duplicates
    auto it = std::find_if(structs.begin(), structs.end(), [&s](auto item)->bool { return *item->name.get() == *s->name.get(); });
    if (it != structs.end())
        yyerror("Duplicate struct name " + *s->name.get());
    it = std::find_if(structs.begin(), structs.end(), [&s](auto item)->bool { return (item->type == s->type) && item->fixed && s->fixed; });
    if (it != structs.end())
        yyerror("Duplicate struct type " + std::to_string(s->type));

    structs.push_back(s);
}

void Import::AddImport(std::string* i)
{
    if (i == nullptr)
        yyerror("Import is null!");
    if (i->empty())
        yyerror("Import package is invalid!");

    // Check for duplicates
    auto it = std::find_if(imports.begin(), imports.end(), [i](auto item)->bool { return *item.get() == *i; });
    if (it != imports.end())
        yyerror("Duplicate import package " + *i);

    imports.push_back(std::shared_ptr<std::string>(i));
}

Version::Version(const std::string& v)
{
    auto pos = v.find('.');
    if (pos == v.npos)
        minor = std::atoi(v.c_str());
    else
    {
        major = std::atoi(v.substr(0, pos).c_str());
        minor = std::atoi(v.substr(pos + 1).c_str());
    }
}

std::shared_ptr<Package> Package::root = std::make_shared<Package>(0);

Package::Package(int o) : offset(o)
{
    if (offset < 0)
        yyerror("Package offset should not be negative!");
}

void Package::initialize()
{
    if (body)
    {
        for (const auto& child_s : body->structs)
        {
            // Add offset to all structs in the package
            if (!child_s->fixed)
                child_s->type += offset;

            // Find structs with id & key flags
            if (child_s->body)
            {
                std::vector<std::shared_ptr<StructField>> fields;
                for (const auto& field : child_s->body->fields)
                {
                    if (field->id)
                    {
                        if (child_s->id)
                            yyerror("Struct " + *child_s->name.get() + " must have only one [id] field!");
                        child_s->id = true;
                        field->keys = true;
                    }
                    if (field->keys)
                        child_s->keys = true;
                    if (field->reseter)
                        field->optional = true;
                    fields.push_back(field);
                    if (field->reseter)
                    {
                        auto reseter = std::make_shared<StructField>();
                        reseter->name = std::make_shared<std::string>(*field->name + "Reset");
                        reseter->type = std::make_shared<std::string>("bool");
                        fields.push_back(reseter);
                    }
                }
                child_s->body->fields = fields;
            }
        }
    }
}

} // namespace FBE