#include <gint/display.h>
#include <gint/keyboard.h>

#include <ft/widgets/gscreen.h>
#include <ft/widgets/fbrowser.h>
#include <ft/widgets/flist.h>
#include <ft/widgets/flog.h>
#include <ft/test.h>
#include <ft/all-tests.h>

#include <fxlibc/printf.h>

#include <gint/hardware.h>
#include <bits/cpucap.h>

/* We don't initialize the test result fields in the ft_list objects below */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"

ft_list headers_libc[] = {
    { _("ctype.h", "<ctype.h>"), (ft_test*[]){
        &ft_ctype_classes,
        &ft_ctype_conversion,
        NULL,
    }},
    { _("inttypes.h", "<inttypes.h>"), (ft_test*[]){
        &ft_inttypes_sizes,
        &ft_inttypes_functions,
        NULL,
    }},
    { _("locale.h", "<locale.h>"), NULL },
    { _("setjmp.h", "<setjmp.h>"), (ft_test*[]){
        &ft_setjmp_simple,
        &ft_setjmp_massive,
        &ft_setjmp_interrupt,
        NULL,
    }},
    { _("signal.h", "<signal.h>"), (ft_test*[]){
        &ft_signal_signal,
        NULL,
    }},
    { _("stdio.h", "<stdio.h>"), (ft_test*[]){
        &ft_stdio_printf_basics,
        &ft_stdio_printf_formats,
        &ft_stdio_printf_fp,
        NULL,
    }},
    { _("stdlib.h", "<stdlib.h>"), (ft_test*[]){
        &ft_stdlib_arith,
        &ft_stdlib_sizes,
        &ft_stdlib_llconv,
        &ft_stdlib_lconv,
        &ft_stdlib_fpconv,
        &ft_stdlib_rand,
        &ft_stdlib_exit,
        &ft_stdlib__Exit,
        &ft_stdlib_abort,
        NULL,
    }},
    { _("string.h", "<string.h>"), (ft_test*[]){
        &ft_string_memset,
        &ft_string_memcpy,
        &ft_string_memmove,
        &ft_string_memcmp,
        &ft_string_memchr,
        &ft_string_strlen,
        &ft_string_naive,
        &ft_string_strerror,
        NULL,
    }},
    { _("time.h", "<time.h>"), NULL },
    { _("uchar.h", "<uchar.h>"), NULL },
    { _("wchar.h", "<wchar.h>"), NULL },
    { _("wctype.h", "<wctype.h>"), NULL },
    { NULL }
};
ft_list headers_posix[] = {
    { "<fcntl.h>", (ft_test*[]){
        &ft_fcntl_open,
        NULL,
    }},
    { "<unistd.h>", (ft_test*[]){
        &ft_unistd_simple_write,
        &ft_unistd_write_odd,
        NULL,
    }},
    { NULL }
};

#pragma GCC diagnostic pop

int main(void)
{
    /* Set up the capabilities for the standard library implementation */
    /* TODO: Set up capabilities directly in gint! */
    if(isSH4())
        __cpucap |= __CPUCAP_SH4ALDSP;

    __printf_enable_fp();
    __printf_enable_fixed();

    // Initialize test results
    for(int i = 0; headers_libc[i].name; i++)
        ft_list_init(&headers_libc[i]);
    for(int i = 0; headers_posix[i].name; i++)
        ft_list_init(&headers_posix[i]);

    // Create GUI
    gscreen *scr = gscreen_create2("FxLibc tests", &img_fbar_main,
        "FxLibc regression and performance tests", "/LIBC;/POSIX;;;;#RUN");
    fbrowser *browser = fbrowser_create(NULL);
    int selected_set = 0;

    gscreen_add_tab(scr, browser, NULL);
    gscreen_set_tab_title_visible(scr, 0, _(false, true));
    fbrowser_set_headers(browser, headers_libc, false);

    jwidget *results = jwidget_create(NULL);
    jlayout_set_stack(results);
    gscreen_add_tab(scr, results, NULL);
    gscreen_set_tab_title_visible(scr, 1, _(false, true));
    gscreen_set_tab_fkeys_visible(scr, 1, false);

    flog *testlog = flog_create(NULL);
    flog_set_line_spacing(testlog, _(1,3));
    flog_set_font(testlog, _(&font_mini, dfont_default()));
    gscreen_add_tab(scr, testlog, testlog);
    gscreen_set_tab_title_visible(scr, 2, _(false, true));
    gscreen_set_tab_fkeys_visible(scr, 2, false);

    // Event handling
    while(1) {
        jevent e = jscene_run(scr->scene);
        int tab = gscreen_current_tab(scr);

        int key = 0;
        if(e.type == JWIDGET_KEY && e.key.type == KEYEV_DOWN) key = e.key.key;

        if(e.type == JSCENE_PAINT) {
            dclear(C_WHITE);
            jscene_render(scr->scene);
            dupdate();
        }

        // Switch lists on F1/F2
        if(tab == 0 && key == KEY_F1 && selected_set != 0) {
            fbrowser_set_headers(browser, headers_libc, false);
            selected_set = 0;
        }
        if(tab == 0 && key == KEY_F2 && selected_set != 1) {
            fbrowser_set_headers(browser, headers_posix, false);
            selected_set = 1;
        }

        // Update F-keys when tests are selected
        if((e.type == FLIST_SELECTED || e.type == JWIDGET_FOCUS_IN ||
            e.type == JWIDGET_FOCUS_OUT) && e.source == browser->tests) {

            ft_test *test = NULL;
            if(jscene_focused_widget(scr->scene) == browser->tests)
                test = fbrowser_current_test(browser);

            jfkeys_set_override(scr->fkeys, 4,
                (test && test->run && test->log) ? "@LOG" : NULL);
            jfkeys_set_override(scr->fkeys, 5,
                (test && test->run && test->widget) ? "@VISUAL" : NULL);
        }

        // Run tests
        if(tab == 0 && key == KEY_F6) {
            ft_list *header = fbrowser_current_header(browser);
            ft_test *test = fbrowser_current_test(browser);

            if(test) {
                ft_test_run(test);
                ft_list_aggregate(header);
                browser->widget.update = 1;
            }
            else if(header) {
                ft_list_run(header);
                browser->widget.update = 1;
            }
            else {
                for(int i = 0; headers_libc[i].name; i++)
                    ft_list_run(&headers_libc[i]);
                for(int i = 0; headers_posix[i].name; i++)
                    ft_list_run(&headers_posix[i]);
                browser->widget.update = 1;
            }
        }

        // Browse test results
        ft_test *test_visual = NULL;
        ft_test *test_log = NULL;

        if(tab == 0 && e.type == FBROWSER_VALIDATED && e.source == browser) {
            ft_test *test = fbrowser_current_test(browser);
            test_visual = test;
            test_log = test;
        }
        if(key == KEY_F4) {
            test_log = fbrowser_current_test(browser);
        }
        if(key == KEY_F5) {
            test_visual = fbrowser_current_test(browser);
        }

        if(test_visual && test_visual->run && test_visual->widget) {
            jwidget *w = test_visual->widget(test_visual);
            if(w) {
                jwidget_add_child(results, w);
                gscreen_show_tab(scr, 1);
                jscene_set_focused_widget(scr->scene, w);
            }
        }
        else if(test_log && test_log->run && test_log->log) {
            flog_set_log(testlog, test_log->log, test_log->log_size);
            gscreen_show_tab(scr, 2);
        }

        // Close test results
        if(tab == 1 && key == KEY_EXIT) {
            jscene_set_focused_widget(scr->scene, browser->tests);
            gscreen_show_tab(scr, 0);
            while(results->child_count > 0) {
                jwidget_destroy(results->children[0]);
            }
        }
        if(tab == 2 && key == KEY_EXIT) {
            flog_set_log(testlog, NULL, -1);
            gscreen_show_tab(scr, 0);
        }
    }

    gscreen_destroy(scr);
    return 1;
}