/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#include "SpineSpriteAnimateDialog.h"

#ifdef TOOLS_ENABLED

#include "SpineSprite.h"

void SpineSpriteAnimateDialog::_bind_methods() {
    ClassDB::bind_method(D_METHOD("_on_animate_button_pressed"), &SpineSpriteAnimateDialog::_on_animate_button_pressed);
    ClassDB::bind_method(D_METHOD("_on_scene_tree_selected"), &SpineSpriteAnimateDialog::_on_scene_tree_selected);
    ClassDB::bind_method(D_METHOD("_on_scene_tree_hide"), &SpineSpriteAnimateDialog::_on_scene_tree_hide);
    ClassDB::bind_method(D_METHOD("_on_animate_dialog_action"), &SpineSpriteAnimateDialog::_on_animate_dialog_action);
}

SpineSpriteAnimateDialog::SpineSpriteAnimateDialog() {
    animate_dialog = memnew(ConfirmationDialog);
    add_child(animate_dialog);
    animate_dialog->get_ok()->set_text("Generate");
    animate_dialog_override_button = animate_dialog->add_button("Override", false, "override");
    animate_dialog_override_button->set_visible(false);
    animate_dialog->set_title("Animations Generator");
    animate_dialog->set_resizable(true);
    animate_dialog->set_custom_minimum_size(Vector2(550, 400));
    animate_dialog->set_hide_on_ok(false);
    animate_dialog->connect("custom_action", this, "_on_animate_dialog_action");
    Vector<Variant> al;
    al.push_back("confirmed");
    animate_dialog->connect("confirmed", this, "_on_animate_dialog_action", al);

    auto vb = memnew(VBoxContainer);
    animate_dialog->add_child(vb);

    auto scroll = memnew(ScrollContainer);
    scroll->set_h_size_flags(SIZE_EXPAND_FILL);
    scroll->set_v_size_flags(SIZE_EXPAND_FILL);
//    vb->add_margin_child("Animations", scroll);
    vb->add_child(scroll);

    animate_dialog_tree = memnew(Tree);
    animate_dialog_tree->set_h_size_flags(SIZE_EXPAND_FILL);
    animate_dialog_tree->set_v_size_flags(SIZE_EXPAND_FILL);
    scroll->add_child(animate_dialog_tree);

    animate_dialog_tree->set_columns(3);
    animate_dialog_tree->set_column_titles_visible(true);
    animate_dialog_tree->set_hide_folding(true);
    animate_dialog_tree->set_hide_root(true);

    animate_dialog_tree->set_column_title(0, TTR("Animation"));
    animate_dialog_tree->set_column_title(1, TTR("Loop"));
    animate_dialog_tree->set_column_title(2, TTR("Track ID"));

    animate_dialog_tree->create_item();
    add_row("test1");
    add_row("test12");
    add_row("test13");

    auto l = memnew(Label);
    l->set_text("W.I.P");
    vb->add_child(l);

    scene_tree_dialog = memnew(SceneTreeDialog);
    scene_tree_dialog->set_title("Choose a AnimationPlayer to override, or choose none to create a new one.");
    Vector<StringName> valid_types;
    valid_types.push_back("AnimationPlayer");
    scene_tree_dialog->get_scene_tree()->set_valid_types(valid_types);
    scene_tree_dialog->get_scene_tree()->set_show_enabled_subscene(true);
    scene_tree_dialog->get_ok()->hide();
    add_child(scene_tree_dialog);
    scene_tree_dialog->connect("selected", this, "_on_scene_tree_selected");
    scene_tree_dialog->connect("popup_hide", this, "_on_scene_tree_hide");

    error_dialog = memnew(AcceptDialog);
    add_child(error_dialog);
}

SpineSpriteAnimateDialog::~SpineSpriteAnimateDialog() {

}

void SpineSpriteAnimateDialog::set_animate_button(ToolButton *b) {
    animate_button = b;
    animate_button->connect("pressed", this, "_on_animate_button_pressed");
}

void SpineSpriteAnimateDialog::add_row(const String &animation, bool loop, int64_t track_id) {
    auto item = animate_dialog_tree->create_item();
    item->set_text(0, animation);

    item->set_cell_mode(1, TreeItem::CELL_MODE_CHECK);
    item->set_checked(1, loop);
    item->set_editable(1, true);

    item->set_cell_mode(2, TreeItem::CELL_MODE_RANGE);
    item->set_range(2, track_id);
    item->set_editable(2, true);
}

void SpineSpriteAnimateDialog::clear_tree() {
    animate_dialog_tree->clear();
    animate_dialog_tree->create_item();
}

void SpineSpriteAnimateDialog::error(const String &text, const String &title) {
    error_dialog->set_text(text);
    error_dialog->set_title(title);
    error_dialog->popup_centered();
}

#define ERROR_MSG(x) do{error(x);err=true;return;}while(false)
void SpineSpriteAnimateDialog::load_data_from_sprite(SpineSprite *sprite, bool &err) {
    if (sprite == nullptr) {
        ERROR_MSG("The sprite is null.");
    }
    if (!sprite->get_animation_state().is_valid() || !sprite->get_skeleton().is_valid()) {
        ERROR_MSG("The sprite is not loaded.");
    }
    clear_tree();

    Vector<String> animations;
    sprite->get_skeleton()->get_data()->get_animation_names(animations);

    for (size_t i=0; i<animations.size(); ++i) {
        add_row(animations[i]);
    }

    err = false;
}

#define MIN_TRACK_LENGTH 0.15

void SpineSpriteAnimateDialog::gen_new_animation_player(SpineSprite *sprite, bool &err) {
    if (sprite == nullptr) {
        ERROR_MSG("The sprite player is null.");
    }
    if (!sprite->get_animation_state().is_valid() || !sprite->get_skeleton().is_valid()) {
        ERROR_MSG("The sprite is not loaded.");
    }
    auto p = sprite->get_parent();
    if (p == nullptr) {
        p = sprite;
    }

    auto anim_player = memnew(AnimationPlayer);
    anim_player->set_name("AnimationPlayer");
    p->add_child(anim_player);
    anim_player->set_owner(sprite->get_owner());
    anim_player->set_root(anim_player->get_path_to(p));

    gen_animations(sprite, anim_player, get_data_from_tree(), MIN_TRACK_LENGTH, err);
}

Dictionary SpineSpriteAnimateDialog::get_data_from_tree() {
    Dictionary res;
    if (animate_dialog_tree->get_root() == nullptr) return res;

    auto item = animate_dialog_tree->get_root()->get_children();
    while (item) {
        Dictionary row;
        row["loop"] = item->is_checked(1);
        row["track_id"] = item->get_range(2);

        res[item->get_text(0)] = row;
        item = item->get_next();
    }
    return res;
}

void SpineSpriteAnimateDialog::gen_animations(SpineSprite *sprite, AnimationPlayer *anim_player, const Dictionary &config, float min_duration, bool &err) {
    if (sprite == nullptr || anim_player == nullptr) {
        ERROR_MSG("The sprite or animation player is null.");
    }
    if (!sprite->get_animation_state().is_valid() || !sprite->get_skeleton().is_valid()) {
        ERROR_MSG("The sprite is not loaded.");
    }
    if (anim_player->get_node_or_null(anim_player->get_root()) == nullptr) {
        ERROR_MSG("The root node of animation player is null.");
    }

    auto path_to_sprite = anim_player->get_node(anim_player->get_root())->get_path_to(sprite);

    Array animations = sprite->get_skeleton()->get_data()->get_animations();
    for (size_t i=0; i<animations.size(); ++i) {
        auto spine_anim = (Ref<SpineAnimation>) animations[i];

        Dictionary ca;
        if (config.has(spine_anim->get_anim_name())) {
            ca = config[spine_anim->get_anim_name()];
        }

        if (!ca.has("loop")) ca["loop"] = true;
        if (!ca.has("track_id")) ca["track_id"] = 0;

        Array key_frame_value;
        key_frame_value.push_back(gen_current_animation_data(spine_anim->get_anim_name(), ca["track_id"], ca["loop"], false, false, 0.3, 0));

        auto anim = Ref<Animation>(memnew(Animation));
        auto track_index = anim->add_track(Animation::TYPE_VALUE);
        anim->set_length(min_duration > spine_anim->get_duration() ? min_duration : spine_anim->get_duration());
        anim->track_set_path(track_index, NodePath(vformat("%s:current_animations", path_to_sprite)));
        anim->track_insert_key(track_index, 0.0, key_frame_value);
        anim->value_track_set_update_mode(track_index, Animation::UPDATE_DISCRETE);

        if (anim_player->has_animation(spine_anim->get_anim_name()))
            anim_player->remove_animation(spine_anim->get_anim_name());
        anim_player->add_animation(spine_anim->get_anim_name(), anim);
    }

    err = false;
}

Dictionary SpineSpriteAnimateDialog::gen_current_animation_data(const String &animation, int64_t track_id, bool loop, bool clear, bool empty, bool empty_duration, float delay) {
    Dictionary res;
    res["animation"] = animation;
    res["track_id"] = track_id;
    res["loop"] = loop;
    res["clear"] = clear;
    res["empty"] = empty;
    res["empty_animation_duration"] = empty_duration;
    res["delay"] = delay;
    return res;
}


void SpineSpriteAnimateDialog::load_data_from_anim_player(AnimationPlayer *anim_player, bool &err) {
    if (anim_player == nullptr) {
        ERROR_MSG("The animation player is null.");
    }
    auto root = anim_player->get_node_or_null(anim_player->get_root());
    if (root == nullptr) return;

    auto sprite = get_node_or_null(spine_sprite_path);
    if (sprite == nullptr) return;

    auto item = animate_dialog_tree->get_root()->get_children();
    while (item) {
        String animation = item->get_text(0);

        auto anim = anim_player->get_animation(animation);
        if (anim.is_valid() && anim->get_track_count() > 0) {
            if (anim->track_get_type(0) == Animation::TYPE_VALUE) {
                auto track_path = anim->track_get_path(0);
                if (root->get_node_or_null(track_path) == sprite) {
                    if (anim->track_get_key_count(0) > 0) {
                        Array key_frame_value = anim->track_get_key_value(0, 0);
                        if (!key_frame_value.empty()) {
                            Dictionary _ca = key_frame_value.front();
                            if (_ca.has("loop")) item->set_checked(1, _ca["loop"]);
                            if (_ca.has("track_id")) item->set_range(2, _ca["track_id"]);
                        }
                    }
                }
            }

        }

        item = item->get_next();
    }

    err = false;
}

//----- Signals -----
void SpineSpriteAnimateDialog::_on_scene_tree_selected(NodePath path) {
//    print_line(vformat("anime: %s", path));
    auto node = get_node_or_null(path);
    if (node == nullptr) {
        error("The node you chose is null.");
        return;
    }
    if (!node->is_class("AnimationPlayer")) {
        error("The node you chose is not AnimationPlayer.");
        return;
    }
    anim_player_path = path;
}

void SpineSpriteAnimateDialog::_on_animate_button_pressed() {
    anim_player_path = String("");
    auto node = (Node*)the_plugin->get_editor_interface()->get_selection()->get_selected_nodes().back();
    spine_sprite_path = node->get_path();

//    print_line(vformat("sp: %s", spine_sprite_path));

    animate_dialog_override_button->set_visible(false);
    scene_tree_dialog->popup_centered_ratio();
}

void SpineSpriteAnimateDialog::_on_scene_tree_hide() {
    animate_dialog->popup_centered();

    bool err = false;
    load_data_from_sprite((SpineSprite*)get_node_or_null(spine_sprite_path), err);

    if (err) animate_dialog->hide();

    err = false;
    auto node = get_node_or_null(anim_player_path);
    if (node != nullptr) {
        load_data_from_anim_player((AnimationPlayer*)node, err);
        animate_dialog_override_button->set_visible(!err);
    } else {
        animate_dialog_override_button->set_visible(false);
    }


}

void SpineSpriteAnimateDialog::_on_animate_dialog_action(const String &act) {
    bool err = false;
    if (act == "confirmed") {
        gen_new_animation_player((SpineSprite*)get_node_or_null(spine_sprite_path), err);
    } else if (act == "override") {
        gen_animations((SpineSprite*)get_node_or_null(spine_sprite_path), (AnimationPlayer*)get_node_or_null(anim_player_path), get_data_from_tree(), MIN_TRACK_LENGTH, err);
    }
    if (!err) {
        animate_dialog->hide();
    }
}


#endif