#include "state.hpp"

#include <cstring>
#include <cassert>
#include <string>
#include <cmath>
#include <cstdio>

#include <raylib.h>

#include "helpers.hpp"

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
Tri::State::State(int argc, char **argv) :
flags(),
width(DEFAULT_WIDTH),
height(DEFAULT_HEIGHT),
dt(1.0f/60.0f),
notificationAlpha(1.0f),
notificationAmt(0.0F),
notificationText(),
tris(),
currentTri(),
currentTri_state(CurrentState::NONE),
pointCircle({7.0F, 7.0F}, 7.0F, WHITE),
colorPickerColor{255, 255, 255, 255},
bgColorPickerColor{0, 0, 0, 255},
bgColor(BLACK),
saveFilenameBuffer(),
failedMessage(),
drawCache(),
pi(std::acos(-1.0f)),
selectedTri(),
selectedTriColor{255, 255, 255, 255},
prevTriColor{255, 255, 255, 255},
selectedTriBlinkTimer(),
inputWidth(800),
inputHeight(600),
history(),
history_idx(0),
clickTimeout(0.0F)
{
    InitWindow(width, height, "Triangles");
    SetTargetFPS(60);

    flags.set(F_IS_RUNNING); // is running

    set_notification_text("Press \"H\" for help");

    saveFilenameBuffer.fill(0);

    drawCache = LoadRenderTexture(width, height);
    flags.set(F_DRAW_CACHE_INITIALIZED);
    flags.set(F_DRAW_CACHE_DIRTY);

    GuiSetStyle(DEFAULT, BACKGROUND_COLOR, TRI_GUI_BG_COLOR);
    GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, TRI_GUI_BASE_COLOR);
    GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, TRI_GUI_TEXT_COLOR);
    GuiSetStyle(DEFAULT, TEXT_SIZE, TRI_GUI_TEXT_SIZE);
}
#pragma GCC diagnostic pop

Tri::State::Action::Action() :
type(Tri::State::Action::AT_NONE),
idx(0),
color(BLACK),
data{{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}
{}

Tri::State::Action::Action(const Type& type, IndexT idx, const Color& color, float *data) :
type(type),
idx(idx),
color(color),
data()
{
    init(data);
}

Tri::State::Action::Action(Type&& type, IndexT idx, Color&& color, float *data) :
type(type),
idx(idx),
color(color),
data()
{
    init(data);
}

Tri::State::Action &Tri::State::Action::setNewColor(Color color) {
    this->data.newColor = color;
    return *this;
}

void Tri::State::Action::init(float *data) {
    switch(type) {
    case AT_TRI:
    case AT_TRI_DEL:
        for(unsigned int i = 0; i < 6; ++i) {
            this->data.tri[i] = data[i];
        }
        break;
    case AT_POINT:
        this->data.point[0] = data[0];
        this->data.point[1] = data[1];
        break;
    case AT_COLOR:
        break;
    default:
        type = AT_NONE;
        idx = 0;
        color = BLACK;
        this->data = {{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}};
        break;
    }
}

Tri::State::~State() {
    UnloadRenderTexture(drawCache);
    CloseWindow();
}

void Tri::State::handle_events() {
    if(WindowShouldClose()) {
        flags.reset(F_IS_RUNNING);
    }

    int keyPressed = GetKeyPressed();
    while(keyPressed > 0) {
        if(!flags.test(F_DISPLAY_SAVE)) {
            switch(keyPressed) {
            case KEY_H:
                flags.flip(F_DISPLAY_HELP);
                break;
            case KEY_U:
                if (flags.test(F_TRI_EDIT_MODE)) {
                    set_notification_text("Cannot undo during editing tri!");
                    break;
                }
                flags.set(F_DRAW_CACHE_DIRTY);
                if (history_idx > 0) {
                    switch(history[history_idx-1].type) {
                    case Action::AT_TRI:
                        tris.erase(
                            tris.cbegin() + history[history_idx-1].idx);
                        restore_points_on_tri_del(history_idx - 1);
                        break;
                    case Action::AT_TRI_DEL:
                    {
                        tris.emplace(
                            tris.cbegin() + history[history_idx].idx,
                            Triangle(
                                {{
                                    {history[history_idx-1].data.tri[0],
                                     history[history_idx-1].data.tri[1]},
                                    {history[history_idx-1].data.tri[2],
                                     history[history_idx-1].data.tri[3]},
                                    {history[history_idx-1].data.tri[4],
                                     history[history_idx-1].data.tri[5]},
                                }},
                                history[history_idx-1].color
                            )
                        );
                        currentTri_state = CurrentState::NONE;
                        break;
                    }
                    case Action::AT_POINT:
                        assert(history[history_idx-1].idx + 1 == currentTri_state
                            && "Point in history must match point index");
                        assert(currentTri_state > 0
                            && "There must be a point to undo a point");
                        currentTri_state = static_cast<CurrentState>(currentTri_state - 1);
                        break;
                    case Action::AT_COLOR:
                        tris.at(history[history_idx-1].idx).fillColor = history[history_idx-1].color;
                        break;
                    default:
                        assert(!"Unreachable code");
                        break;
                    }
                    --history_idx;
                }
                break;
            case KEY_R:
                flags.set(F_DRAW_CACHE_DIRTY);
                if(history_idx < history.size()) {
                    switch(history[history_idx].type) {
                    case Action::AT_TRI:
                    {
                        tris.emplace(
                            tris.cbegin() + history[history_idx].idx,
                            Triangle(
                                {{
                                    {history[history_idx].data.tri[0],
                                     history[history_idx].data.tri[1]},
                                    {history[history_idx].data.tri[2],
                                     history[history_idx].data.tri[3]},
                                    {history[history_idx].data.tri[4],
                                     history[history_idx].data.tri[5]},
                                }},
                                history[history_idx].color
                            )
                        );
                        currentTri_state = CurrentState::NONE;
                        break;
                    }
                        break;
                    case Action::AT_TRI_DEL:
                        tris.erase(
                            tris.cbegin() + history[history_idx].idx);
                        restore_points_on_tri_del(history_idx);
                        break;
                    case Action::AT_POINT:
                        assert(history[history_idx].idx == currentTri_state
                            && "Point in history must match point index");
                        assert(currentTri_state < CurrentState::SECOND
                            && "Current point state must be 0 or 1");
                        currentTri[currentTri_state].x = history[history_idx].data.point[0];
                        currentTri[currentTri_state].y = history[history_idx].data.point[1];
                        currentTri_state = static_cast<CurrentState>(
                            currentTri_state + 1);
                        pointCircle.fillColor = history[history_idx].color;
                        break;
                    case Action::AT_COLOR:
                        tris.at(history[history_idx].idx).fillColor = history[history_idx].data.newColor;
                        break;
                    default:
                        assert(!"Unreachable code");
                        break;
                    }
                    ++history_idx;
                }
                break;
            case KEY_C:
                if(flags.test(F_DISPLAY_COLOR_P)) {
                    close_color_picker();
                } else {
                    flags.set(F_DISPLAY_COLOR_P);
                }
                break;
            case KEY_B:
                if(flags.test(F_DISPLAY_BG_COLOR_P)) {
                    close_bg_color_picker();
                } else {
                    flags.set(F_DISPLAY_BG_COLOR_P);
                }
                break;
            case KEY_S:
                flags.flip(F_DISPLAY_SAVE);
                break;
            case KEY_P:
                flags.flip(F_COPY_COLOR_MODE);
                if(flags.test(F_COPY_COLOR_MODE)) {
                    set_notification_text(
                        "Copy color mode\n"
                        "Click to change\n"
                        "current draw color\n"
                        "to what was\n"
                        "clicked on");
                } else {
                    clear_notification_alpha();
                }
                break;
            case KEY_I:
                flags.flip(F_DISPLAY_CHANGE_SIZE);
                if(!flags.test(F_DISPLAY_CHANGE_SIZE)) {
                    close_input_width_height_window();
                } else {
                    failedMessage = "Press TAB to switch between width/height";
                }
                break;
            case KEY_E:
                if(flags.test(F_TRI_EDIT_MODE)) {
                    close_selected_tri_mode();
                } else {
                    flags.flip(F_SELECT_TRI_MODE);
                    if(flags.test(F_SELECT_TRI_MODE)) {
                        set_notification_text("Click on a tri\nto edit it");
                    }
                }
                break;
            case KEY_TAB:
                flags.flip(F_TAB_TOGGLE);
                break;
            }
        }
        keyPressed = GetKeyPressed();
    }

    if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && clickTimeout == 0.0F) {
        if(can_draw()) {
            switch(currentTri_state) {
            case CurrentState::NONE: {
                currentTri[0] = {GetMouseX(), GetMouseY()};
                currentTri_state = CurrentState::FIRST;
                if(history_idx < history.size()) {
                    history.resize(history_idx);
                }
                float points[2] = {currentTri[0].x, currentTri[0].y};
                history.push_back(Action(Action::AT_POINT,
                                         0,
                                         pointCircle.fillColor,
                                         points));
                ++history_idx;
                break; }
            case CurrentState::FIRST: {
                currentTri[1] = {GetMouseX(), GetMouseY()};
                currentTri_state = CurrentState::SECOND;
                if(history_idx < history.size()) {
                    history.resize(history_idx);
                }
                float points[2] = {currentTri[1].x, currentTri[1].y};
                history.push_back(Action(Action::AT_POINT,
                                         1,
                                         pointCircle.fillColor,
                                         points));
                ++history_idx;
                break; }
            case CurrentState::SECOND: {
                currentTri[2] = {GetMouseX(), GetMouseY()};
                make_counter_clockwise(currentTri);
                tris.emplace_back(currentTri, pointCircle.fillColor);
                currentTri_state = CurrentState::NONE;
                flags.set(F_DRAW_CACHE_DIRTY);

                if(history_idx < history.size()) {
                    history.resize(history_idx);
                }
                float points[6] = {
                    currentTri[0].x, currentTri[0].y,
                    currentTri[1].x, currentTri[1].y,
                    currentTri[2].x, currentTri[2].y,
                };
                history.push_back(Action(Action::AT_TRI,
                                         tris.size()-1,
                                         pointCircle.fillColor,
                                         points));
                ++history_idx;
                break; }
            }
        } else if(flags.test(F_COPY_COLOR_MODE)) {
            check_draw_cache();
            Image drawImage = LoadImageFromTexture(drawCache.texture);
            Color *colors = LoadImageColors(drawImage);
            int mx = GetMouseX();
            int my = GetMouseY();
            if(mx < 0) { mx = 0; }
            else if(mx >= drawImage.width) { mx = drawImage.width - 1; }
            if(my < 0) { my = 0; }
            else if(my >= drawImage.height) { my = drawImage.height - 1; }

            my = drawImage.height - my;

            colorPickerColor = colors[mx + my * drawImage.width];

            pointCircle.fillColor = colors[mx + my * drawImage.width];
            flags.reset(F_COPY_COLOR_MODE);
            set_notification_text("Color set");

            UnloadImageColors(colors);
            UnloadImage(drawImage);
        } else if(flags.test(F_SELECT_TRI_MODE)) {
            int mx = GetMouseX();
            int my = GetMouseY();
            if(mx < 0) { mx = 0; }
            else if(mx >= (int)width) { mx = width - 1; }
            if(my < 0) { my = 0; }
            else if(my >= (int)height) { my = height - 1; }

            for (unsigned int i = 0; i < tris.size(); ++i) {
                if(is_within_shape(tris[i], {mx, my})) {
                    tris[i].outlineColor = invert_color(tris[i].fillColor);
                    flags.reset(F_SELECT_TRI_MODE);
                    flags.set(F_TRI_EDIT_MODE);
                    flags.set(F_TRI_EDIT_DRAW_TRI);
                    selectedTriBlinkTimer = 1.0f;
                    selectedTriColor = tris[i].fillColor;
                    prevTriColor = tris[i].fillColor;
                    selectedTri = i;
                    clickTimeout = CLICK_TIMEOUT_TIME;
                    break;
                }
            }
            if(!flags.test(F_TRI_EDIT_MODE)) {
                set_notification_text("Did not select\nanything");
            }
        }
    }
}

void Tri::State::update() {
    dt = GetFrameTime();

    if(notificationAlpha > 0.0f) {
        notificationAmt += dt * NOTIFICATION_FADE_RATE;
        if (notificationAmt > 1.0F) {
            clear_notification_alpha();
        } else {
            notificationAlpha = Tri::sq_lerp(1.0F, 0.0F, notificationAmt);
        }
    }

    if(flags.test(F_COLOR_P_COLOR_DIRTY)) {
        flags.reset(F_COLOR_P_COLOR_DIRTY);
        pointCircle.fillColor = colorPickerColor;
    }

    if(flags.test(F_BG_COLOR_P_COLOR_DIRTY)) {
        flags.reset(F_BG_COLOR_P_COLOR_DIRTY);
        bgColor = bgColorPickerColor;
        bgColor.a = 255;
    }

    if(flags.test(F_TRI_EDIT_MODE)) {
        selectedTriBlinkTimer -= dt * TRIANGLES_EDIT_TRI_BLINK_RATE;
        if(selectedTriBlinkTimer <= 0.0f) {
            selectedTriBlinkTimer = 1.0f;
            flags.flip(F_TRI_EDIT_DRAW_TRI);
        }
    }

    if (clickTimeout > 0.0F) {
        clickTimeout -= dt;
        if (clickTimeout < 0.0F) {
            clickTimeout = 0.0F;
        }
    }
}

void Tri::State::draw() {
    // Should be able to directly draw a texture held by the RenderTexture2D
    if(flags.test(F_DRAW_CACHE_INITIALIZED)) {
        // draw cache initialized
        check_draw_cache();
        BeginDrawing();
        // hack to flip in the y direction, since RenderTexture2D's texture
        // is flipped
        DrawTextureRec(
            drawCache.texture,
            {
                0.0f,
                0.0f,
                (float)drawCache.texture.width,
                (float)-drawCache.texture.height
            },
            {0.0f, 0.0f},
            WHITE);
    } else {
        BeginDrawing();
        draw_to_target(nullptr);
    }

    if(flags.test(F_TRI_EDIT_MODE) && flags.test(F_TRI_EDIT_DRAW_TRI)) {
//        tris.at(selectedTri).setOutlineThickness(4.0f);
        tris.at(selectedTri).draw();
//        tris.at(selectedTri).setOutlineThickness(0.0f);
    }

    if(can_draw()) {
        for(unsigned int i = 0; i < currentTri_state; ++i) {
            DrawCircle(currentTri[i].x, currentTri[i].y, pointCircle.getRadius(), pointCircle.fillColor);
        }
    }

    Tri::draw_notification(this);
    Tri::draw_color_picker(this);
    Tri::draw_bg_color_picker(this);
    Tri::draw_edit_tri(this);
    Tri::draw_change_size(this);
    Tri::draw_save(this);
    Tri::draw_help(this);

    EndDrawing();
}

void Tri::State::draw_to_target(RenderTexture2D *target) {
    if(target) {
        BeginTextureMode(*target);
        ClearBackground(bgColor);

        // draw tris
        for(unsigned int i = 0; i < tris.size(); ++i) {
            tris[i].draw();
        }
        EndTextureMode();
    } else {
        // Expects BeginDrawing() already having been called prior to this fn
        ClearBackground(bgColor);

        // draw tris
        for(unsigned int i = 0; i < tris.size(); ++i) {
            tris[i].draw();
        }
    }
}

unsigned int Tri::State::get_width() const {
    return width;
}

unsigned int Tri::State::get_height() const {
    return height;
}

const Tri::State::BitsetType Tri::State::get_flags() const {
    return flags;
}

float Tri::State::get_notification_alpha() const {
    return notificationAlpha;
}

void Tri::State::reset_notification_alpha() {
    notificationAlpha = 1.0F;
    notificationAmt = 0.0F;
}

void Tri::State::clear_notification_alpha() {
    notificationAlpha = 0.0F;
    notificationAmt = 1.0F;
}

const char* Tri::State::get_notification_text() const {
    return notificationText.data();
}

void Tri::State::set_notification_text(const char *text) {
    notificationText.fill(0);
    std::strncpy(notificationText.data(),
        text,
        notificationText.max_size() - 1);
    reset_notification_alpha();
}

void Tri::State::append_notification_text(const char *text) {
    auto length = std::strlen(notificationText.data());
    if(length + 1 >= notificationText.max_size()) {
        return;
    }
    std::strncpy(
        notificationText.data() + length,
        text,
        notificationText.max_size() - length - 1);
    reset_notification_alpha();
}

Color& Tri::State::get_color() {
    flags.set(F_COLOR_P_COLOR_DIRTY);
    return colorPickerColor;
}

Color& Tri::State::get_bg_color() {
    flags.set(F_BG_COLOR_P_COLOR_DIRTY);
    return bgColorPickerColor;
}

std::array<char, 256>* Tri::State::get_save_filename_buffer() {
    return &saveFilenameBuffer;
}

bool Tri::State::do_save() {
    RenderTexture2D saveTexture = LoadRenderTexture(width, height);

    draw_to_target(&saveTexture);

    Image saveImage = LoadImageFromTexture(saveTexture.texture);
    ImageFlipVertical(&saveImage);
    UnloadRenderTexture(saveTexture);
    if(ExportImage(saveImage, saveFilenameBuffer.data())) {
#ifndef NDEBUG
        printf("Saved to \"%s\"\n", saveFilenameBuffer.data());
#endif
        failedMessage.clear();
        UnloadImage(saveImage);
        return true;
    } else {
#ifndef NDEBUG
        printf("ERROR: Failed to save \"%s\"\n", saveFilenameBuffer.data());
#endif
        failedMessage = std::string("Failed to save (does the name end in \".png\"?)");
        UnloadImage(saveImage);
        return false;
    }
}

const std::string& Tri::State::failed_message() const {
    return failedMessage;
}

void Tri::State::close_save() {
    flags.reset(F_DISPLAY_SAVE);
}

bool Tri::State::can_draw() const {
    return !flags.test(F_DISPLAY_HELP)
        && !flags.test(F_DISPLAY_COLOR_P)
        && !flags.test(F_DISPLAY_BG_COLOR_P)
        && !flags.test(F_DISPLAY_SAVE)
        && !flags.test(F_COPY_COLOR_MODE)
        && !flags.test(F_DISPLAY_CHANGE_SIZE)
        && !flags.test(F_SELECT_TRI_MODE)
        && !flags.test(F_TRI_EDIT_MODE);
}

void Tri::State::reset_modes() {
    flags.reset(F_DISPLAY_HELP);
    flags.reset(F_DISPLAY_COLOR_P);
    flags.reset(F_DISPLAY_BG_COLOR_P);
    flags.reset(F_DISPLAY_SAVE);
    flags.reset(F_COPY_COLOR_MODE);
    flags.reset(F_DISPLAY_CHANGE_SIZE);
    flags.reset(F_SELECT_TRI_MODE);
    flags.reset(F_TRI_EDIT_MODE);
}

void Tri::State::close_help() {
    flags.reset(F_DISPLAY_HELP);
}

void Tri::State::close_color_picker() {
    flags.reset(F_DISPLAY_COLOR_P);
    flags.set(F_DRAW_CACHE_DIRTY);
}

void Tri::State::close_bg_color_picker() {
    flags.reset(F_DISPLAY_BG_COLOR_P);
    flags.set(F_DRAW_CACHE_DIRTY);
}

bool Tri::State::change_width_height() {
    if(inputWidth < 0 || inputHeight < 0) {
        failedMessage = "Width or Height cannot be less than 0";
        return false;
    }
    if(inputWidth < 800) {
        inputWidth = 800;
    }
    if(inputHeight < 600) {
        inputHeight = 600;
    }

    notificationText.fill(0);
    std::array<char, 5> tempBuf = {0, 0, 0, 0, 0};

    append_notification_text("Width set to ");
    snprintf(tempBuf.data(), 5, "%u", inputWidth);
    append_notification_text(tempBuf.data());

    append_notification_text(", Height set to ");
    snprintf(tempBuf.data(), 5, "%u", inputHeight);
    append_notification_text(tempBuf.data());

    this->width = inputWidth;
    this->height = inputHeight;

    UnloadRenderTexture(drawCache);
    SetWindowSize(this->width, this->height);
    drawCache = LoadRenderTexture(this->width, this->height);

    flags.set(F_DRAW_CACHE_DIRTY);

    currentTri_state = CurrentState::NONE;

    return true;
}

void Tri::State::close_input_width_height_window() {
    failedMessage.clear();
    inputWidth = width;
    inputHeight = height;
    flags.reset(F_DISPLAY_CHANGE_SIZE);
}

float Tri::State::get_pi() const {
    return pi;
}

Color& Tri::State::get_selected_tri_color() {
    tris.at(selectedTri).fillColor = selectedTriColor;
    return selectedTriColor;
}

void Tri::State::close_selected_tri_mode() {
    // Set tri's new color in history.
    if (prevTriColor != selectedTriColor) {
        if (history_idx < history.size()) {
            history.resize(history_idx);
        }
        history.emplace_back(Action::AT_COLOR, selectedTri, prevTriColor, nullptr);
        history.back().setNewColor(selectedTriColor);
        ++history_idx;
    }

    tris.at(selectedTri).fillColor = selectedTriColor;
    flags.set(F_DRAW_CACHE_DIRTY);

    reset_modes();
}

bool Tri::State::check_draw_cache() {
    if(flags.test(F_DRAW_CACHE_INITIALIZED) && flags.test(F_DRAW_CACHE_DIRTY)) {
        // draw cache initialized and dirty
        flags.reset(F_DRAW_CACHE_DIRTY);
        draw_to_target(&drawCache);
        return true;
    } else {
        return false;
    }
}

int* Tri::State::get_input_width() {
    return &inputWidth;
}

int* Tri::State::get_input_height() {
    return &inputHeight;
}

void Tri::State::restore_points_on_tri_del(Action::IndexT end) {
    assert(end < history.size()
        && "Index on history must be in range");
    currentTri[2].x = history[end].data.tri[4];
    currentTri[2].y = history[end].data.tri[5];
    pointCircle.fillColor = history[end].color;
    unsigned int currentTriIdx = 1;
    while(end-- > 0) {
        assert(history[end].type == Action::AT_POINT
            && "Latest history must be AT_POINT type");
        assert(history[end].idx == currentTriIdx
            && "Last point must be second point");
        currentTri[currentTriIdx].x = history[end].data.point[0];
        currentTri[currentTriIdx].y = history[end].data.point[1];
        if(currentTriIdx > 0) {
            --currentTriIdx;
        } else {
            currentTri_state = CurrentState::SECOND;
            return;
        }
    }

    assert(!"Unreachable code");
    return;
}

float Tri::State::get_click_timeout() const {
    return clickTimeout;
}