/*

        lv_anim_set_time(&a, 1000);

        lv_anim_set_playback_time(&a, 1000);

        lv_anim_set_var(&a, indic2);

        lv_anim_start(&a);

        lv_anim_set_time(&a, 1000);

        lv_anim_set_playback_time(&a, 2000);

        lv_anim_set_var(&a, indic3);

        lv_anim_start(&a);

        */

    /* page 3 */

}

static void dropdown_event_handler(lv_event_t *e)

{

    lv_event_code_t code = lv_event_get_code(e);

    lv_obj_t *obj = lv_event_get_target(e);

    if (code == LV_EVENT_VALUE_CHANGED)

    {

        char buf[32];

        lv_dropdown_get_selected_str(obj, buf, sizeof(buf));

        LV_LOG_USER("Option: %s", buf);

    }

}

/**

 * @brief dispaly dropdown is rotated 180 degrees (USB to the right is the orentation)

 *

 */

void display_dropdown()

{

    lv_disp_t *dispp = lv_disp_get_default();

    ui_Dropdown2 = lv_dropdown_create(lv_scr_act());

    lv_dropdown_set_options(ui_Dropdown2, "Apple\n"

                                          "Banana\n"

                                          "Orange\n"

                                          "Melon\n"

                                          "Grape\n"

                                          "Raspberry");

    lv_obj_set_width(ui_Dropdown2, 150);

    lv_obj_set_height(ui_Dropdown2, LV_SIZE_CONTENT); /// 1

    lv_obj_set_x(ui_Dropdown2, 0);

    lv_obj_set_y(ui_Dropdown2, -20);

    lv_obj_set_align(ui_Dropdown2, LV_ALIGN_CENTER);

    lv_obj_add_flag(ui_Dropdown2, LV_OBJ_FLAG_SCROLL_ON_FOCUS); /// Flags

    lv_obj_add_event_cb(ui_Dropdown2, dropdown_event_handler, LV_EVENT_ALL, NULL);

}

void display_window()

{

    lv_obj_t *win = lv_win_create(lv_scr_act(), 40);

    assert(win);

    lv_win_add_title(win, "test123!");

}

void display_image()

{

    esp_img_logo = lv_img_create(lv_scr_act());

    lv_img_set_src(esp_img_logo, &esp_logo);

    lv_obj_center(esp_img_logo);

}

void display_red_square()

{

    // ui_Screen1 = lv_obj_create(NULL);

    // lv_obj_clear_flag(ui_Screen1, LV_OBJ_FLAG_SCROLLABLE);      /// Flags

    ui_redsquare = lv_img_create(lv_scr_act());

    lv_img_set_src(ui_redsquare, &red_square);

    lv_obj_set_width(ui_redsquare, LV_SIZE_CONTENT);  /// 1

    lv_obj_set_height(ui_redsquare, LV_SIZE_CONTENT); /// 1

    lv_obj_set_align(ui_redsquare, LV_ALIGN_CENTER);

    lv_obj_add_flag(ui_redsquare, LV_OBJ_FLAG_ADV_HITTEST);  /// Flags

    lv_obj_clear_flag(ui_redsquare, LV_OBJ_FLAG_SCROLLABLE); /// Flags

}

static void slider_event_cb(lv_event_t *e);

static lv_obj_t *slider_label;

void display_slider()

{

    lv_disp_t *dispp = lv_disp_get_default();

    /*Create a slider in the center of the display*/

    lv_obj_t *slider = lv_slider_create(lv_scr_act());

    lv_obj_set_x(slider, 0);

    lv_obj_set_y(slider, -40);

    lv_obj_set_align(slider, LV_ALIGN_CENTER);

    lv_obj_add_event_cb(slider, slider_event_cb, LV_EVENT_VALUE_CHANGED, NULL);

    /*Create a label below the slider*/

    slider_label = lv_label_create(lv_scr_act());

    lv_label_set_text(slider_label, "0%");

    lv_obj_align_to(slider_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);

}

static void slider_event_cb(lv_event_t *e)

{

    lv_obj_t *slider = lv_event_get_target(e);

    char buf[8];

    lv_snprintf(buf, sizeof(buf), "%d%%", (int)lv_slider_get_value(slider));

    lv_label_set_text(slider_label, buf);

    lv_obj_align_to(slider_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);

}

void get_img_color()

{

    lv_color_t pixel_color = lv_img_buf_get_px_color(&red_square, 50, 50, lv_color_make(0, 0, 0));

    uint32_t c32 = lv_color_to32(pixel_color);

    printf("Pixel color: %lu \n", c32);

}

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);

}

void display_process(void)

{

    bsp_display_lock(0);

    // display_slider();

    //Call one at a time to see examples

    display_meter();

    // display_image();

    // display_window();

    //display_dropdown();

    bsp_display_unlock();

}

#ifndef _DISPLAY_H_

#define _DISPLAY_H_

#include "lvgl.h"

#include "esp_lcd_panel_io.h"

#include "esp_lcd_panel_vendor.h"

#include "esp_lcd_panel_ops.h"

#include "driver/gpio.h"

#include "driver/i2c.h"

// #include "esp_lcd_touch_cst816s.h"

//CST816 defines

#define EXAMPLE_I2C_SCL                17

#define EXAMPLE_I2C_SDA                18

#define PIN_TOUCH_RES                  21

#define EXAMPLE_I2C_NUM                 0   // I2C number

#define EXAMPLE_LCD_PIXEL_CLOCK_HZ (20 * 1000 * 1000)

#define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 1

#define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL

#define EXAMPLE_PIN_NUM_DATA0 39    // 6

#define EXAMPLE_PIN_NUM_DATA1 40    // 7

#define EXAMPLE_PIN_NUM_DATA2 41    // 8

#define EXAMPLE_PIN_NUM_DATA3 42    // 9

#define EXAMPLE_PIN_NUM_DATA4 45    // 10

#define EXAMPLE_PIN_NUM_DATA5 46    // 11

#define EXAMPLE_PIN_NUM_DATA6 47    // 12

#define EXAMPLE_PIN_NUM_DATA7 48    // 13

#define EXAMPLE_PIN_NUM_PCLK 8      // 5

#define EXAMPLE_PIN_NUM_CS 6        // 3

#define EXAMPLE_PIN_NUM_DC 7        // 4

#define EXAMPLE_PIN_NUM_RST 5       // 2

#define EXAMPLE_PIN_NUM_BK_LIGHT 38 // 1

#define EXAMPLE_PIN_NUM_POWER 15

#define PIN_LCD_RD 9

// The pixel number in horizontal and vertical

#define EXAMPLE_LCD_H_RES 320

#define EXAMPLE_LCD_V_RES 170

#define LVGL_LCD_BUF_SIZE            (EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES)

// Bit number used to represent command and parameter

#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_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 "usb_cdc.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

    usb_cdc_init();

    // 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);

    // Connect to wifi

    // Initialize canbus

    //can_init();

    while(1)

    {

    }

}

//

// wifi

//

#include "wifi.h"

#include "esp_wifi.h"

#include "esp_event.h"

#include "esp_log.h"

#include "lwip/err.h"

#include "lwip/sys.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;

        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));

        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,

                                                        NULL,

                                                        &instance_any_id));

    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,

                                                        IP_EVENT_STA_GOT_IP,

                                                        &__event_handler,

                                                        NULL,

                                                        &instance_got_ip));

    wifi_config_t wifi_config = {

        .sta = {

            .ssid = EXAMPLE_ESP_WIFI_SSID,

            .password = EXAMPLE_ESP_WIFI_PASS,

            /* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8).

             * If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value

             * to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to

             * WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards.

             */

            .threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD,

            .sae_pwe_h2e = ESP_WIFI_SAE_MODE,

            .sae_h2e_identifier = EXAMPLE_H2E_IDENTIFIER,

        },

    };

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );

    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );

    ESP_ERROR_CHECK(esp_wifi_start() );

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum

     * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,

            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,

            pdFALSE,

            pdFALSE,

            portMAX_DELAY);

    /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually

     * happened. */

    if (bits & WIFI_CONNECTED_BIT) {

        ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",

                 EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

    } else if (bits & WIFI_FAIL_BIT) {

        ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s",

                 EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

    } else {

        ESP_LOGE(TAG, "UNEXPECTED EVENT");

    }

}