#include "display.h"

#include "esp_err.h"

#include "esp_log.h"

#include "esp_check.h"

#include "driver/i2c.h"

#include "driver/gpio.h"

#include "driver/spi_master.h"

#include "esp_lcd_panel_io.h"

#include "esp_lcd_panel_vendor.h"

#include "esp_lcd_panel_ops.h"

#include "esp_lvgl_port.h"

#include <stdio.h>

#include "esp_timer.h"

#include "esp_heap_caps.h"

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

// #include "ui_helpers.h"

static const char *TAG = "LVGL_SETUP";

static void lvgl_timer_task(void *arg);

static lv_obj_t *ui_Screen1;

static lv_obj_t *ui_redsquare;

static lv_obj_t *meter;

static lv_obj_t *ue_img_logo;

static lv_obj_t *esp_img_logo;

static lv_obj_t *ui_Dropdown2;

LV_IMG_DECLARE(ue_logo)

LV_IMG_DECLARE(esp_logo)

LV_IMG_DECLARE(red_square)

#define BSP_NULL_CHECK(x, ret) assert(x)

static SemaphoreHandle_t lvgl_mux;  // LVGL mutex

static SemaphoreHandle_t touch_mux; // Touch mutex

static void bsp_touchpad_read(lv_indev_drv_t *drv, lv_indev_data_t *data)

{

    uint16_t touchpad_x[1] = {0};

    uint16_t touchpad_y[1] = {0};

    uint8_t touchpad_cnt = 0;

    /* Read data from touch controller into memory */

    if (xSemaphoreTake(touch_mux, 0) == pdTRUE)

    {

        esp_lcd_touch_read_data(drv->user_data);

    }

    /* Get coordinates */

    bool touchpad_pressed = esp_lcd_touch_get_coordinates(drv->user_data, touchpad_x, touchpad_y, NULL, &touchpad_cnt, 1);

    if (touchpad_pressed && touchpad_cnt > 0)

    {

        data->point.x = touchpad_x[0];

        data->point.y = touchpad_y[0];

        data->state = LV_INDEV_STATE_PRESSED;

        printf("data->point.x = %u \n", data->point.x);

        printf("data->point.y = %u \n", data->point.y);

    }

    else

    {

        data->state = LV_INDEV_STATE_RELEASED;

    }

}

static void touch_callback(esp_lcd_touch_handle_t tp)

{

    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    xSemaphoreGiveFromISR(touch_mux, &xHigherPriorityTaskWoken);

    if (xHigherPriorityTaskWoken)

    {

        portYIELD_FROM_ISR();

    }

}

static void set_value(void *indic, int32_t v)

{

    lv_meter_set_indicator_end_value(meter, indic, v);

}

static bool example_notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)

{

    lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;

    lv_disp_flush_ready(disp_driver);

    return false;

}

static void example_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)

{

    esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;

    int offsetx1 = area->x1;

    int offsetx2 = area->x2;

    int offsety1 = area->y1;

    int offsety2 = area->y2;

    // copy a buffer's content to a specific area of the display

    esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);

}

static void example_increase_lvgl_tick(void *arg)

        .rst_gpio_num = 21,

        .int_gpio_num = 16,

        .levels = {

            .reset = 0,

            .interrupt = 0,

        },

        .flags = {

            .swap_xy = 1,

            .mirror_x = 0,

            .mirror_y = 1,

        },

        .interrupt_callback = touch_callback,

    };

    ESP_LOGI(TAG, "esp_lcd_touch_new_i2c_cst816s");

    esp_lcd_touch_new_i2c_cst816s(tp_io_handle, &tp_cfg, &tp);

    // END OF CST816 TOUCH TESTING FUNCTION

#endif

    lv_init();

    lvgl_mux = xSemaphoreCreateMutex();

    BSP_NULL_CHECK(lvgl_mux, NULL);

    touch_mux = xSemaphoreCreateBinary();

    BSP_NULL_CHECK(touch_mux, NULL);

    // it's recommended to choose the size of the draw buffer(s) to be at least 1/10 screen sized

    lv_color_t *buf1 = heap_caps_malloc(LVGL_LCD_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);

    assert(buf1);

    lv_disp_draw_buf_init(&disp_buf, buf1, NULL, LVGL_LCD_BUF_SIZE);

    ESP_LOGI(TAG, "Register display driver to LVGL");

    lv_disp_drv_init(&disp_drv);

    disp_drv.hor_res = EXAMPLE_LCD_H_RES;

    disp_drv.ver_res = EXAMPLE_LCD_V_RES;

    disp_drv.flush_cb = example_lvgl_flush_cb;

    disp_drv.draw_buf = &disp_buf;

    disp_drv.user_data = panel_handle;

    disp_drv.sw_rotate = 1;

    lv_disp_t *disp = lv_disp_drv_register(&disp_drv);

    ESP_LOGI(TAG, "Install LVGL tick timer");

    // Tick interface for LVGL (using esp_timer to generate 2ms periodic event)

    const esp_timer_create_args_t lvgl_tick_timer_args = {

        .callback = &example_increase_lvgl_tick,

        .name = "lvgl_tick"};

    esp_timer_handle_t lvgl_tick_timer = NULL;

    ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));

    ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000));

#if USE_TOUCH_DISPLAY

    static lv_indev_drv_t indev_drv; // Input device driver (Touch)

    lv_indev_t *indev_touchpad;

    lv_indev_drv_init(&indev_drv);

    indev_drv.type = LV_INDEV_TYPE_POINTER;

    indev_drv.disp = disp;

    indev_drv.read_cb = bsp_touchpad_read;

    indev_drv.user_data = tp;

    indev_touchpad = lv_indev_drv_register(&indev_drv);

    BSP_NULL_CHECK(indev_touchpad, ESP_ERR_NO_MEM);

#endif

    xTaskCreatePinnedToCore(lvgl_timer_task, "lvgl Timer", 10000, NULL, 4, NULL, 1);

}

static void lvgl_timer_task(void *arg)

{

    ESP_LOGI(TAG, "Starting LVGL task");

    while (1)

    {

        bsp_display_lock(0);

        uint32_t task_delay_ms = lv_timer_handler();

        bsp_display_unlock();

        if (task_delay_ms > 500)

        {

            task_delay_ms = 500;

        }

        else if (task_delay_ms < 5)

        {

            task_delay_ms = 5;

        }

        vTaskDelay(pdMS_TO_TICKS(task_delay_ms));

    }

}

void display_meter()

{

bool bsp_display_lock(uint32_t timeout_ms)

{

    BSP_NULL_CHECK(lvgl_mux, NULL);

    const TickType_t timeout_ticks = (timeout_ms == 0) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);

    return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE;

}

void bsp_display_unlock(void)

{

    BSP_NULL_CHECK(lvgl_mux, NULL);

    xSemaphoreGive(lvgl_mux);

}

lv_obj_t *label;

void display_update_text(char* str)

{

    bsp_display_lock(0);

    lv_label_set_text(label, str);

    bsp_display_unlock();

}

void display_process(void)

{

    bsp_display_lock(0);

    lv_label_set_text(label, "Yup");

    // lv_obj_align_to(label, lv_scr_act(), LV_ALIGN_OUT_BOTTOM_MID, 0, 10);

    // display_slider();

    //Call one at a time to see examples

    display_meter();

    // display_image();

    // display_window();

    //display_dropdown();

    bsp_display_unlock();

#define EXAMPLE_LCD_CMD_BITS 8

#define EXAMPLE_LCD_PARAM_BITS 8

#define EXAMPLE_LVGL_TICK_PERIOD_MS 2

// Supported alignment: 16, 32, 64. A higher alignment can enables higher burst transfer size, thus a higher i80 bus throughput.

#define EXAMPLE_PSRAM_DATA_ALIGNMENT 32

//Change this to 0 if you do not wish to use Touch.

#define USE_TOUCH_DISPLAY 0

void display_meter();

void display_window();

void display_image();

void display_slider();

void display_red_square();

void display_dropdown();

void get_img_color();

void bsp_display_unlock(void);

bool bsp_display_lock(uint32_t timeout_ms);

void display_init(void);

void display_update_text(char* string);

void display_process(void);

#endif

//

// Protofusion ESP32S3 Template

//

#include <stdint.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "freertos/event_groups.h"

#include "esp_system.h"

#include "esp_event.h"

#include "esp_log.h"

#include "nvs_flash.h"

#include "sdkconfig.h"

#include "wifi.h"

#include "can.h"

#include "display.h"

// Private variables

static const char *TAG = "main";

// Application entry point

void app_main(void)

{

    // Initialize usb-cdc interface

    // Initialize NVS

    esp_err_t ret = nvs_flash_init();

    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {

        ESP_ERROR_CHECK(nvs_flash_erase());

        ret = nvs_flash_init();

    }

    ESP_ERROR_CHECK(ret);

    // Initialize display

    display_init();

    display_process();

    // Connect to wifi

    wifi_init();

    // Initialize canbus

    //can_init();

    while(1)

    {

    }

}

#include "freertos/task.h"

#include "freertos/event_groups.h"

// Private variables

// FreeRTOS event group to signal when we are connected

static EventGroupHandle_t s_wifi_event_group;

static const char *TAG = "wifi station";

static int s_retry_num = 0;

// Handler for wifi events

static void __event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)

{

    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {

        esp_wifi_connect();

    }

    else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) 

    {

        if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) 

        {

            esp_wifi_connect();

            s_retry_num++;

            ESP_LOGI(TAG, "retry to connect to the AP");

        } 

        else 

        {

            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);

        }

        ESP_LOGI(TAG,"connect to the AP fail");

    } 

    else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) 

    {

        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;

        char out[128] = {0};

        display_update_text(out);

        s_retry_num = 0;

        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);

    }

}

// Initialize wifi and connect to network

void wifi_init(void)

{

    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());

    ESP_ERROR_CHECK(esp_event_loop_create_default());

    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;

    esp_event_handler_instance_t instance_got_ip;

    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,

                                                        ESP_EVENT_ANY_ID,

                                                        &__event_handler,