#include "../log.h"

#include "effect.h"
#include "pass.h"

using namespace Mauri;

auto Effect::parse(Parser &pr, const json &root) -> Effect *
{
    Effect *effect = new Effect();

    Asset *asset = asset_manager()->get(root["file"]);
    if (asset->type == ASSET_VOID) parse_fail(effect);

    const json &file = json::parse(asset->as_string(), nullptr, false);
    if (file.is_discarded()) parse_fail(effect);

    pr.map_value<u32>(root, "id", &effect->id, 0);
    pr.map_value<bool>(root, "visible", &effect->visible, true);
    pr.map_value<std::string>(file, "name", &effect->name, "");

    if (root.contains("passes"))
    {
        for (const json &pass0 : root["passes"])
        {
            Pass *pass = Pass::parse(pr, pass0, EFFECT0_PASS);
            if (pass) effect->passes0.emplace_back(pass);
        }
    }

    if (effect->passes0.size() == 0) parse_fail(effect);

    if (file.contains("passes"))
    {
        for (const json &pass1 : file["passes"])
        {
            Pass *pass = Pass::parse(pr, pass1, EFFECT1_PASS);
            if (pass) effect->passes1.emplace_back(pass);
        }
    }

    if (effect->passes1.size() == 0) parse_fail(effect);

    if (file.contains("fbos"))
    {
        for (const json &fbo : file["fbos"])
        {
            effect->fbos.emplace_back(EffectBuffer{fbo["name"], fbo.contains("scale") ? (f32)fbo["scale"] : 1.f });
        }
    }

    return effect;
}

auto Effect::load(Engine *engine, Object *object, bool last) -> void
{
    this->buffer_id = "_" + std::to_string(object->id) + "_" + std::to_string(this->id);

    for (const EffectBuffer &fbo : this->fbos)
    {
        engine->create_framebuffer(fbo.name + this->buffer_id, object->size[0], object->size[1], fbo.scale);
    }

    u32 index = 0;

    for (u32 i = 0; i < this->passes1.size(); i++)
    {
        Pass pass;

        pass.intermediate = false;

        pass.effect = this;
        pass.object = object;

        pass.model = false;
        pass.combine = object->visible && object->color_blend_mode == 0 &&
          i == (this->passes1.size() - 1) && last;
        //pass.combine = object->visible &&
        //  i == (this->passes1.size() - 1) && last;

        if (this->passes1[i]->command != COPY)
        {
            this->passes0[index]->load(engine, EFFECT0_PASS, &pass);
            index++;
        }

        this->passes1[i]->load(engine, EFFECT1_PASS, &pass);

        this->passes.push_back(new RenderPass(engine, &pass));
    }
}

auto Effect::draw(Engine *engine) -> void
{
    if (!this->visible) return;

#ifdef FRAME_STEP
    al_printf("%s\n", this->name.c_str());
#endif

    for (RenderPass *pass : this->passes)
    {
#ifdef FRAME_STEP
        if (pass->shader) al_printf("\t%s\n", pass->shader->origin()->name.c_str());
#endif
        pass->draw(engine);
    }
}

Effect::~Effect()
{
    for (Pass *pass0 : this->passes0)
    {
        delete pass0;
    }

    for (Pass *pass1 : this->passes1)
    {
        delete pass1;
    }

    for (RenderPass *pass : this->passes)
    {
        delete pass;
    }
}