#include "menu.h"

#include <gui/elements.h>
#include <assets_icons.h>
#include <furi.h>
#include <m-array.h>

struct Menu {
    View* view;
};

typedef struct {
    const char* label;
    IconAnimation* icon;
    uint32_t index;
    MenuItemCallback callback;
    void* callback_context;
} MenuItem;

ARRAY_DEF(MenuItemArray, MenuItem, M_POD_OPLIST);

#define M_OPL_MenuItemArray_t() ARRAY_OPLIST(MenuItemArray, M_POD_OPLIST)

typedef struct {
    MenuItemArray_t items;
    size_t position;
} MenuModel;

static void menu_process_up(Menu* menu);
static void menu_process_down(Menu* menu);
static void menu_process_left(Menu* menu);
static void menu_process_right(Menu* menu);
static void menu_process_ok(Menu* menu);

static void menu_draw_callback(Canvas* canvas, void* _model) {
    MenuModel* model = _model;

    canvas_clear(canvas);

    size_t position = model->position;
    size_t items_count = MenuItemArray_size(model->items);
    if(items_count) {
        MenuItem* item;
        FuriString* name = furi_string_alloc();
        size_t shift_position;
        if(position < 2) {
            shift_position = 0;
        } else if(position >= items_count - 2 + (items_count % 2)) {
            shift_position = position - (position % 2) - 4;
        } else {
            shift_position = position - (position % 2) - 2;
        }
        canvas_set_font(canvas, FontSecondary);
        size_t item_i;
        size_t x_off, y_off;
        for(int i = 0; i < 6; i++) {
            item_i = shift_position + i;
            if(item_i >= items_count) break;
            item = MenuItemArray_get(model->items, item_i);
            x_off = (i / 2) * 43 + 1;
            y_off = (i % 2) * 32;
            if(item_i == position) {
                elements_slightly_rounded_box(canvas, 0 + x_off, 0 + y_off, 40, 30);
                canvas_set_color(canvas, ColorWhite);
            }
            if(item->icon) {
                canvas_draw_icon_animation(canvas, 13 + x_off, 3 + y_off, item->icon);
            }
            furi_string_set(name, item->label);
            elements_scrollable_text_line(
                canvas,
                20 + x_off,
                23 + y_off,
                36,
                name,
                0,
                false,
                true);
            if(item_i == position) {
                canvas_set_color(canvas, ColorBlack);
            } else {
                elements_frame(canvas, 0 + x_off, 0 + y_off, 40, 30);
            }
        }
        furi_string_free(name);
    } else {
        canvas_draw_str(canvas, 2, 32, "Empty");
        elements_scrollbar(canvas, 0, 0);
    }
}

static bool menu_input_callback(InputEvent* event, void* context) {
    Menu* menu = context;
    bool consumed = false;

    if(event->type == InputTypeShort) {
        switch(event->key) {
            case InputKeyUp:
                consumed = true;
                menu_process_up(menu);
                break;
            case InputKeyDown:
                consumed = true;
                menu_process_down(menu);
                break;
            case InputKeyLeft:
                consumed = true;
                menu_process_left(menu);
                break;
            case InputKeyRight:
                consumed = true;
                menu_process_right(menu);
                break;
            case InputKeyOk:
                consumed = true;
                menu_process_ok(menu);
                break;
            default:
                break;
        }
    } else if(event->type == InputTypeRepeat) {
        switch(event->key) {
            case InputKeyUp:
                consumed = true;
                menu_process_up(menu);
                break;
            case InputKeyDown:
                consumed = true;
                menu_process_down(menu);
                break;
            case InputKeyLeft:
                consumed = true;
                menu_process_left(menu);
                break;
            case InputKeyRight:
                consumed = true;
                menu_process_right(menu);
                break;
            default:
                break;
        }
    }

    return consumed;
}

static void menu_enter(void* context) {
    Menu* menu = context;
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            MenuItem* item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_start(item->icon);
            }
        },
        false);
}

static void menu_exit(void* context) {
    Menu* menu = context;
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            MenuItem* item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_stop(item->icon);
            }
        },
        false);
}

Menu* menu_alloc() {
    Menu* menu = malloc(sizeof(Menu));
    menu->view = view_alloc(menu->view);
    view_set_context(menu->view, menu);
    view_allocate_model(menu->view, ViewModelTypeLocking, sizeof(MenuModel));
    view_set_draw_callback(menu->view, menu_draw_callback);
    view_set_input_callback(menu->view, menu_input_callback);
    view_set_enter_callback(menu->view, menu_enter);
    view_set_exit_callback(menu->view, menu_exit);

    with_view_model(
        menu->view,
        MenuModel * model,
        {
            MenuItemArray_init(model->items);
            model->position = 0;
        },
        true);

    return menu;
}

void menu_free(Menu* menu) {
    furi_assert(menu);
    menu_reset(menu);
    view_free(menu->view);
    free(menu);
}

View* menu_get_view(Menu* menu) {
    furi_assert(menu);
    return (menu->view);
}

void menu_add_item(
    Menu* menu,
    const char* label,
    const Icon* icon,
    uint32_t index,
    MenuItemCallback callback,
    void* context) {
    furi_assert(menu);
    furi_assert(label);

    MenuItem* item = NULL;
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            item = MenuItemArray_push_new(model->items);
            item->label = label;
            item->icon = icon ? icon_animation_alloc(icon) : icon_animation_alloc(&A_Plugins_14);
            view_tie_icon_animation(menu->view, item->icon);
            item->index = index;
            item->callback = callback;
            item->callback_context = context;
        },
        true);
}

void menu_reset(Menu* menu) {
    furi_assert(menu);
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            for
                M_EACH(item, model->items, MenuItemArray_t) {
                    icon_animation_stop(item->icon);
                    icon_animation_free(item->icon);
                }

            MenuItemArray_reset(model->items);
            model->position = 0;
        },
        true);
}

void menu_set_selected_item(Menu* menu, uint32_t index) {
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            if(index < MenuItemArray_size(model->items)) {
                model->position = index;
            }
        },
        true);
}

static void menu_process_up(Menu* menu) {
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            size_t count = MenuItemArray_size(model->items);
            if(!(model->position == count - 1 && count % 2)) {
                MenuItem* item = MenuItemArray_get(model->items, model->position);
                if(item && item->icon) {
                    icon_animation_stop(item->icon);
                }

                if(model->position % 2) {
                    model->position--;
                } else {
                    model->position++;
                }

                item = MenuItemArray_get(model->items, model->position);
                if(item && item->icon) {
                    icon_animation_start(item->icon);
                }
            }
        },
        true);
}

static void menu_process_down(Menu* menu) {
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            size_t count = MenuItemArray_size(model->items);
            if(!(model->position == count - 1 && count % 2)) {
                MenuItem* item = MenuItemArray_get(model->items, model->position);
                if(item && item->icon) {
                    icon_animation_stop(item->icon);
                }

                if(model->position % 2) {
                    model->position--;
                } else {
                    model->position++;
                }

                item = MenuItemArray_get(model->items, model->position);
                if(item && item->icon) {
                    icon_animation_start(item->icon);
                }
            }
        },
        true);
}

static void menu_process_left(Menu* menu) {
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            MenuItem* item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_stop(item->icon);
            }

            size_t count = MenuItemArray_size(model->items);
            if(model->position < 2) {
                if(count % 2) {
                    model->position = count - 1;
                } else {
                    model->position = count - 1 + model->position % 2;
                }
            } else {
                model->position -= 2;
            }

            item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_start(item->icon);
            }
        },
        true);
}

static void menu_process_right(Menu* menu) {
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            MenuItem* item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_stop(item->icon);
            }

            size_t count = MenuItemArray_size(model->items);
            if(count % 2) {
                if(model->position == count - 1) {
                    model->position = 0;
                } else if(model->position == count - 2) {
                    model->position = count -1;
                } else {
                    model->position += 2;
                }
            } else {
                model->position += 2;
                if(model->position >= count) {
                    model->position = model->position % 2;
                }
            }

            item = MenuItemArray_get(model->items, model->position);
            if(item && item->icon) {
                icon_animation_start(item->icon);
            }
        },
        true);
}

static void menu_process_ok(Menu* menu) {
    MenuItem* item = NULL;
    with_view_model(
        menu->view,
        MenuModel * model,
        {
            if(model->position < MenuItemArray_size(model->items)) {
                item = MenuItemArray_get(model->items, model->position);
            }
        },
        true);
    if(item && item->callback) {
        item->callback(item->callback_context, item->index);
    }
}