/**
* @file main
*
*/

/*********************
*      INCLUDES
*********************/
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include <Windows.h>
#include <SDL.h>
#include "lvgl/lvgl.h"
#include "lv_drivers/display/monitor.h"
#include "lv_drivers/indev/mouse.h"
#include "lv_drivers/indev/keyboard.h"
//#include "lv_examples/lv_apps/demo/demo.h"
#include "lv_examples/src/lv_demo_benchmark/lv_demo_benchmark.h"
#include "lv_examples/src/lv_demo_keypad_encoder/lv_demo_keypad_encoder.h"
#include "lv_examples/src/lv_demo_printer/lv_demo_printer.h"
#include "lv_examples/src/lv_demo_stress/lv_demo_stress.h"
#include "lv_examples/src/lv_demo_widgets/lv_demo_widgets.h"
#include "lv_examples/src/lv_ex_get_started/lv_ex_get_started.h"
#include "lv_examples/src/lv_ex_style/lv_ex_style.h"

/*********************
*      DEFINES
*********************/

/**********************
*      TYPEDEFS
**********************/

/**********************
*  STATIC PROTOTYPES
**********************/
static void hal_init(void);
static int tick_thread(void *data);

/**********************
*  STATIC VARIABLES
**********************/
static lv_indev_t * kb_indev;

lv_fs_drv_t drv;

/**********************
*      MACROS
**********************/

/**********************
*   GLOBAL FUNCTIONS
**********************/

int main(int argc, char** argv)
{
    /*Initialize LittlevGL*/
    lv_init();

    /*Initialize the HAL for LittlevGL*/
    hal_init();

    /*
     * Demo, benchmark, tests and tutorial.
     *
     * Uncomment any one (and only one) of the functions below to run that
     * particular demo, test or tutorial.
     */

    //demo_create();
    //lv_demo_benchmark();
    //lv_demo_keypad_encoder();
    //lv_demo_printer();
    //lv_demo_widgets();

	lv_demo_mp3();

    //lv_test_theme_1(lv_theme_night_init(210, NULL));
    //lv_test_theme_1(lv_theme_night_init(100, NULL));
    //lv_test_theme_1(lv_theme_material_init(210, NULL));
    //lv_test_theme_1(lv_theme_alien_init(210, NULL));
    //lv_test_theme_1(lv_theme_zen_init(210, NULL));
    //lv_test_theme_1(lv_theme_nemo_init(210, NULL));
    //lv_test_theme_1(lv_theme_mono_init(210, NULL));
    //lv_test_theme_1(lv_theme_default_init(210, NULL));
    //lv_tutorial_keyboard(kb_indev);

    while (1) {
        /* Periodically call the lv_task handler.
        * It could be done in a timer interrupt or an OS task too.*/
        lv_task_handler();
        Sleep(10);       /*Just to let the system breathe */
    }

    return 0;
}

/**********************
*   STATIC FUNCTIONS
**********************/

lv_fs_res_t my_open_cb(struct _lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode)
{
	printf("open dir:%s\n", path);

	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;

	file_1->file_d = fopen(path, "r+");

	printf("o_fd:%p\n", file_1->file_d);

	return 0;
}
lv_fs_res_t my_read_cb(struct _lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
{
	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;
	*br = fread(buf, 1, btr, file_1->file_d);

	printf("r_fd:%p\n", file_1->file_d);

	printf("br = %d\n", *br);
	return 0;
}
lv_fs_res_t my_close_cb(struct _lv_fs_drv_t * drv, void * file_p)
{
	printf("close dir\n");
	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;

	fclose(file_1->file_d);
	return 0;
}

bool my_ready_cb(struct _lv_fs_drv_t * drv)
{
	printf("%s\n", __func__);
	return 1;
}

lv_fs_res_t my_remove_cb(struct _lv_fs_drv_t * drv, const char * fn)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_write_cb(struct _lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
{
	printf("%s\n", __func__);
	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;

	*bw = fwrite(buf, 1, btw, file_1->file_d);
	return 0;
}
lv_fs_res_t my_seek_cb(struct _lv_fs_drv_t * drv, void * file_p, uint32_t pos)
{
	

	int size;
	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;

	size = fseek(file_1->file_d, pos, SEEK_SET);

	printf("%s, %d, size=%d\n", __func__, pos, size);

	return 0;
}
lv_fs_res_t my_tell_cb(struct _lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
{
	printf("%s\n", __func__);
	lv_fs_file_t * file_1 = (lv_fs_file_t *)file_p;

	ftell(file_1->file_d);
	return 0;
}
lv_fs_res_t my_trunc_cb(struct _lv_fs_drv_t * drv, void * file_p)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_size_cb(struct _lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_rename_cb(struct _lv_fs_drv_t * drv, const char * oldname, const char * newname)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_free_space_cb(struct _lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_dir_open_cb(struct _lv_fs_drv_t * drv, void * rddir_p, const char * path)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_dir_read_cb(struct _lv_fs_drv_t * drv, void * rddir_p, char * fn)
{
	printf("%s\n", __func__);
	return 0;
}
lv_fs_res_t my_dir_close_cb(struct _lv_fs_drv_t * drv, void * rddir_p)
{
	printf("%s\n", __func__);
	return 0;
}

/**
* Initialize the Hardware Abstraction Layer (HAL) for the Littlev graphics library
*/
static void hal_init(void)
{
    /* Add a display
    * Use the 'monitor' driver which creates window on PC's monitor to simulate a display*/
    monitor_init();

    lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);            /*Basic initialization*/

    static lv_disp_buf_t disp_buf1;
    static lv_color_t buf1_1[LV_HOR_RES_MAX*LV_VER_RES_MAX];
    lv_disp_buf_init(&disp_buf1, buf1_1, NULL, LV_HOR_RES_MAX*LV_VER_RES_MAX);

    disp_drv.buffer = &disp_buf1;
    disp_drv.flush_cb = monitor_flush;
    lv_disp_drv_register(&disp_drv);

    /* Add the mouse (or touchpad) as input device
    * Use the 'mouse' driver which reads the PC's mouse*/
    mouse_init();
    lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);          /*Basic initialization*/
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = mouse_read;         /*This function will be called periodically (by the library) to get the mouse position and state*/
    lv_indev_drv_register(&indev_drv);

    /* If the PC keyboard driver is enabled in`lv_drv_conf.h`
    * add this as an input device. It might be used in some examples. */
#if USE_KEYBOARD
    lv_indev_drv_t kb_drv;
    lv_indev_drv_init(&kb_drv);
    kb_drv.type = LV_INDEV_TYPE_KEYPAD;
    kb_drv.read_cb = keyboard_read;
    kb_indev = lv_indev_drv_register(&kb_drv);
#endif

	lv_fs_drv_init(&drv);                     /*Basic initialization*/

	drv.letter = 'S';                         /*An uppercase letter to identify the drive */
	drv.file_size = sizeof(FILE *);   /*Size required to store a file object*/
	drv.rddir_size = 128;   /*Size required to store a directory object (used by dir_open/close/read)*/
	drv.ready_cb = my_ready_cb;               /*Callback to tell if the drive is ready to use */
	drv.open_cb = my_open_cb;                 /*Callback to open a file */
	drv.close_cb = my_close_cb;               /*Callback to close a file */
	drv.read_cb = my_read_cb;                 /*Callback to read a file */
	drv.write_cb = my_write_cb;               /*Callback to write a file */
	drv.seek_cb = my_seek_cb;                 /*Callback to seek in a file (Move cursor) */
	drv.tell_cb = my_tell_cb;                 /*Callback to tell the cursor position  */
	drv.trunc_cb = my_trunc_cb;               /*Callback to delete a file */
	drv.size_cb = my_size_cb;                 /*Callback to tell a file's size */
	drv.rename_cb = my_rename_cb;             /*Callback to rename a file */

	drv.dir_open_cb = my_dir_open_cb;         /*Callback to open directory to read its content */
	drv.dir_read_cb = my_dir_read_cb;         /*Callback to read a directory's content */
	drv.dir_close_cb = my_dir_close_cb;       /*Callback to close a directory */

	drv.free_space_cb = my_free_space_cb;     /*Callback to tell free space on the drive */

//	drv.user_data = my_user_data;             /*Any custom data if required*/

	lv_fs_drv_register(&drv);                 /*Finally register the drive*/

    /* Tick init.
    * You have to call 'lv_tick_inc()' in every milliseconds
    * Create an SDL thread to do this*/
    SDL_CreateThread(tick_thread, "tick", NULL);
}

/**
* A task to measure the elapsed time for LittlevGL
* @param data unused
* @return never return
*/
static int tick_thread(void *data)
{
    while (1) {
        lv_tick_inc(5);
        SDL_Delay(5);   /*Sleep for 1 millisecond*/
    }

    return 0;
}