#include <tt_app.h>
#include <tt_lvgl.h>
#include <tt_lvgl_toolbar.h>
#include <tt_app_alertdialog.h>

#include <tactility/device.h>
#include <tactility/drivers/audio_stream.h>

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "cJSON.h"

#ifdef ESP_PLATFORM
#include <esp_heap_caps.h>
#endif

#define MINIMP3_IMPLEMENTATION
#define MINIMP3_NO_SIMD
#include "minimp3.h"

#define TAG "BookPlayer"
#define MP3_INPUT_BUFFER_SIZE 16384
#define MAX_BOOKS 32
#define MAX_PATH 256
#define MAX_TITLE 128
#define MAX_AUTHOR 128

typedef enum {
    STATE_IDLE,
    STATE_PLAYING,
    STATE_PAUSED
} PlaybackState;

typedef struct {
    char slug[MAX_PATH];
    char title[MAX_TITLE];
    char author[MAX_AUTHOR];
} BookMetadata;

typedef struct {
    struct Device* stream_dev;
    AudioStreamHandle stream_handle;
    PlaybackState  state;
    int            volume;

    // Book picker list data
    BookMetadata   books[MAX_BOOKS];
    int            book_count;

    // Currently loaded book details
    char           current_book_slug[MAX_PATH];
    cJSON*         manifest_root;
    cJSON*         pages_array;
    int            page_count;
    int            current_page;
    int            last_pct;

    // UI elements
    AppHandle      app;
    lv_obj_t*      picker_wrapper;
    lv_obj_t*      lst_books;

    lv_obj_t*      player_wrapper;
    lv_obj_t*      header_bar;
    lv_obj_t*      ctrl_bar;
    lv_obj_t*      lbl_book_title;
    lv_obj_t*      img_page;
    lv_obj_t*      lbl_indicator;
    lv_obj_t*      bar_progress;
    lv_obj_t*      btn_play_pause;
    lv_obj_t*      btn_prev;
    lv_obj_t*      btn_next;

    // Audio State
    char           current_audio_path[512];
    uint8_t*       audio_buf; // Shared MP3 input and WAV buffer
    mp3d_sample_t* pcm_buf;   // MP3 decoded pcm buffer

    TaskHandle_t   playback_task_handle;
} AppCtx;

typedef struct __attribute__((packed)) {
    char riff[4];
    uint32_t overall_size;
    char wave[4];
    char fmt_chunk_marker[4];
    uint32_t length_of_fmt;
    uint16_t format_type;
    uint16_t channels;
    uint32_t sample_rate;
    uint32_t byterate;
    uint16_t block_align;
    uint16_t bits_per_sample;
    char data_chunk_header[4];
    uint32_t data_size;
} WavHeader;

static AppCtx g_ctx;

/* ─── Forward Declarations ─── */
static void update_ui(AppCtx* ctx);
static void wait_for_playback_task_to_exit(AppCtx* ctx);
static void load_page(AppCtx* ctx, int page_index, bool start_audio);
static void return_to_picker(AppCtx* ctx);
static void audio_playback_task(void* arg);
static void play_mp3(AppCtx* ctx);
static void play_wav(AppCtx* ctx);
static void scan_books(AppCtx* ctx);

/* ─── Audio-stream helpers ─── */
static bool find_audio_stream_device(AppCtx* ctx) {
    // Prefer device_find_first_by_type but keep compatibility with name lookup
    struct Device* dev = device_find_by_name("audio-stream");
    if (dev) {
        ctx->stream_dev = dev;
        return true;
    }
    dev = device_find_first_by_type(&AUDIO_STREAM_TYPE);
    if (dev) {
        ctx->stream_dev = dev;
        return true;
    }
    return false;
}

static void close_stream_if_open(AppCtx* ctx) {
    if (ctx->stream_handle) {
        audio_stream_close(ctx->stream_handle);
        ctx->stream_handle = NULL;
    }
}

static bool open_output_stream(AppCtx* ctx, uint32_t sample_rate, uint8_t channels, uint8_t bits) {
    close_stream_if_open(ctx);
    if (!ctx->stream_dev) return false;
    struct AudioStreamConfig cfg = {
        .sample_rate = sample_rate,
        .bits_per_sample = bits,
        .channels = channels
    };
    error_t err = audio_stream_open_output(ctx->stream_dev, &cfg, &ctx->stream_handle);
    if (err != ERROR_NONE) {
        ESP_LOGE(TAG, "audio_stream_open_output failed: %d (rate=%u ch=%u)", err, (unsigned)sample_rate, channels);
        ctx->stream_handle = NULL;
        return false;
    }
    ESP_LOGI(TAG, "audio_stream output opened: %u Hz %u ch %u-bit", (unsigned)sample_rate, channels, bits);
    return true;
}

/* ─── UI Helper to update status labels & button states ─── */
static void update_ui(AppCtx* ctx) {
    if (!ctx->btn_play_pause) return;

    lv_obj_t* lbl_play = lv_obj_get_child(ctx->btn_play_pause, 0);

    // Prev button state
    if (ctx->current_page <= 0) {
        lv_obj_add_state(ctx->btn_prev, LV_STATE_DISABLED);
    } else {
        lv_obj_clear_state(ctx->btn_prev, LV_STATE_DISABLED);
    }

    // Next button state
    if (ctx->current_page >= ctx->page_count - 1) {
        lv_obj_add_state(ctx->btn_next, LV_STATE_DISABLED);
    } else {
        lv_obj_clear_state(ctx->btn_next, LV_STATE_DISABLED);
    }

    switch (ctx->state) {
        case STATE_PLAYING:
            if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PAUSE " Pause");
            break;
        case STATE_PAUSED:
            if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PLAY " Play");
            break;
        case STATE_IDLE:
        default:
            if (lbl_play) lv_label_set_text(lbl_play, LV_SYMBOL_PLAY " Play");
            lv_bar_set_value(ctx->bar_progress, 0, LV_ANIM_OFF);
            break;
    }
}

/* ─── Read entire file to string ─── */
static char* read_full_file(const char* filepath) {
    FILE* file = fopen(filepath, "rb");
    if (!file) {
        ESP_LOGE(TAG, "Failed to open file: %s", filepath);
        return NULL;
    }
    fseek(file, 0, SEEK_END);
    long size = ftell(file);
    if (size <= 0) {
        fclose(file);
        return NULL;
    }
    fseek(file, 0, SEEK_SET);

    char* buf = malloc(size + 1);
    if (!buf) {
        fclose(file);
        return NULL;
    }

    size_t read_bytes = fread(buf, 1, size, file);
    buf[read_bytes] = '\0';
    fclose(file);
    return buf;
}

/* ─── Auto-advance logic using LVGL Timer on main thread ─── */
static void on_auto_advance_timer(lv_timer_t* timer) {
    AppCtx* ctx = (AppCtx*)lv_timer_get_user_data(timer);
    if (ctx->current_page + 1 < ctx->page_count) {
        load_page(ctx, ctx->current_page + 1, true);
    }
}

static void handle_audio_finished(AppCtx* ctx) {
    if (ctx->current_page + 1 < ctx->page_count) {
        lv_timer_t* timer = lv_timer_create(on_auto_advance_timer, 0, ctx);
        lv_timer_set_repeat_count(timer, 1);
    } else {
        ctx->state = STATE_IDLE;
        update_ui(ctx);
    }
}

/* ─── Helper to wait for playback thread to terminate safely ─── */
static void wait_for_playback_task_to_exit(AppCtx* ctx) {
    if (ctx->playback_task_handle != NULL) {
        ctx->state = STATE_IDLE;
        while (ctx->playback_task_handle != NULL) {
            tt_lvgl_unlock();
            vTaskDelay(pdMS_TO_TICKS(10));
            tt_lvgl_lock(portMAX_DELAY);
        }
    }
}

/* ─── Load Page Content (Image, Caption, Audio path) ─── */
static void load_page(AppCtx* ctx, int page_index, bool start_audio) {
    wait_for_playback_task_to_exit(ctx);

    if (page_index < 0 || page_index >= ctx->page_count) return;
    ctx->current_page = page_index;
    ctx->last_pct = -1;

    cJSON* page = cJSON_GetArrayItem(ctx->pages_array, page_index);
    if (!page) return;

    cJSON* img_item = cJSON_GetObjectItem(page, "image");
    cJSON* snd_item = cJSON_GetObjectItem(page, "audio");

    // Load Image file
    if (img_item && img_item->valuestring) {
        char img_path[512];
        snprintf(img_path, sizeof(img_path), "/sdcard/books/%s/%s", ctx->current_book_slug, img_item->valuestring);

        FILE* img_file = fopen(img_path, "rb");
        if (img_file) {
            fclose(img_file);
            char lv_img_path[1024];
#ifdef ESP_PLATFORM
            snprintf(lv_img_path, sizeof(lv_img_path), "A:%s", img_path);
#else
            snprintf(lv_img_path, sizeof(lv_img_path), "A:/%s", img_path);
#endif
            lv_image_set_src(ctx->img_page, lv_img_path);
        } else {
            ESP_LOGW(TAG, "Image file not found: %s", img_path);
            lv_image_set_src(ctx->img_page, LV_SYMBOL_IMAGE);
        }
    } else {
        lv_image_set_src(ctx->img_page, LV_SYMBOL_IMAGE);
    }

    // Update Page index indicator
    char ind_buf[32];
    snprintf(ind_buf, sizeof(ind_buf), "%d / %d", page_index + 1, ctx->page_count);
    lv_label_set_text(ctx->lbl_indicator, ind_buf);

    // Save audio path
    if (snd_item && snd_item->valuestring) {
        snprintf(ctx->current_audio_path, sizeof(ctx->current_audio_path), "/sdcard/books/%s/%s", ctx->current_book_slug, snd_item->valuestring);
    } else {
        ctx->current_audio_path[0] = '\0';
    }

    update_ui(ctx);

    // Start playback if requested and valid
    if (start_audio && ctx->current_audio_path[0] != '\0') {
        FILE* audio_file = fopen(ctx->current_audio_path, "rb");
        if (audio_file) {
            fclose(audio_file);
            ctx->state = STATE_PLAYING;
            update_ui(ctx);
            xTaskCreate(audio_playback_task, "audio_play", 8192, ctx, 5, &ctx->playback_task_handle);
        } else {
            ESP_LOGE(TAG, "Audio file not found: %s", ctx->current_audio_path);
            const char* buttons[] = {"OK"};
            tt_app_alertdialog_start("Playback Error", "The narration audio file is missing.", buttons, 1);
            ctx->state = STATE_IDLE;
            update_ui(ctx);
        }
    } else {
        ctx->state = STATE_IDLE;
        update_ui(ctx);
    }
}

/* ─── Return to Book Picker Screen ─── */
static void return_to_picker(AppCtx* ctx) {
    wait_for_playback_task_to_exit(ctx);

    if (ctx->manifest_root) {
        cJSON_Delete(ctx->manifest_root);
        ctx->manifest_root = NULL;
        ctx->pages_array = NULL;
    }

    lv_obj_add_flag(ctx->player_wrapper, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_flag(ctx->picker_wrapper, LV_OBJ_FLAG_HIDDEN);
}

/* ─── Task Selection (MP3 or WAV) ─── */
static void audio_playback_task(void* arg) {
    AppCtx* ctx = (AppCtx*)arg;

    size_t len = strlen(ctx->current_audio_path);
    bool is_wav = false;
    if (len > 4 && strcasecmp(ctx->current_audio_path + len - 4, ".wav") == 0) {
        is_wav = true;
    }

    if (is_wav) {
        play_wav(ctx);
    } else {
        play_mp3(ctx);
    }
}

/* ─── MP3 Decoder Routine (audio-stream) ─── */
static void play_mp3(AppCtx* ctx) {
    vTaskDelay(pdMS_TO_TICKS(400));

    FILE* file = fopen(ctx->current_audio_path, "rb");
    if (!file) {
        ESP_LOGE(TAG, "Failed to open file: %s", ctx->current_audio_path);
        tt_lvgl_lock(portMAX_DELAY);
        ctx->state = STATE_IDLE;
        update_ui(ctx);
        tt_lvgl_unlock();
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }

    fseek(file, 0, SEEK_END);
    size_t file_size = ftell(file);
    fseek(file, 0, SEEK_SET);
    size_t bytes_read_total = 0;

#ifdef ESP_PLATFORM
    mp3dec_t* decoder = (mp3dec_t*)heap_caps_malloc(sizeof(mp3dec_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
#else
    mp3dec_t* decoder = (mp3dec_t*)malloc(sizeof(mp3dec_t));
#endif
    if (!decoder) {
        ESP_LOGE(TAG, "Failed to allocate MP3 decoder!");
        fclose(file);
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }
    mp3dec_init(decoder);
    size_t buffered_bytes = 0;
    bool eof = false;
    int sample_rate = 0;
    int channels = 0;

    ESP_LOGI(TAG, "Starting MP3 playback via audio-stream: %s (%d bytes)", ctx->current_audio_path, file_size);

    while (ctx->state != STATE_IDLE) {
        if (ctx->state == STATE_PAUSED) {
            if (ctx->stream_handle) {
                close_stream_if_open(ctx);
                sample_rate = 0;
                channels = 0;
            }
            vTaskDelay(pdMS_TO_TICKS(50));
            continue;
        }

        // Fill buffer
        if (!eof && buffered_bytes < MP3_INPUT_BUFFER_SIZE) {
            size_t to_read = MP3_INPUT_BUFFER_SIZE - buffered_bytes;
            size_t read_bytes = fread(ctx->audio_buf + buffered_bytes, 1, to_read, file);
            buffered_bytes += read_bytes;
            bytes_read_total += read_bytes;
            if (read_bytes == 0) eof = true;
        }

        if (buffered_bytes == 0 && eof) {
            ESP_LOGI(TAG, "Reached MP3 EOF");
            break;
        }

        // Decode one frame
        mp3dec_frame_info_t info;
        memset(&info, 0, sizeof(info));
        int samples = mp3dec_decode_frame(decoder, ctx->audio_buf, (int)buffered_bytes, ctx->pcm_buf, &info);

        if (info.frame_bytes <= 0) {
            if (eof) break;
            memmove(ctx->audio_buf, ctx->audio_buf + 1, --buffered_bytes);
            continue;
        }

        size_t consumed = (size_t)info.frame_bytes;
        buffered_bytes -= consumed;
        memmove(ctx->audio_buf, ctx->audio_buf + consumed, buffered_bytes);

        if (samples > 0) {
            // Open/reopen stream on format change
            if (sample_rate != info.hz || channels != info.channels) {
                if (!open_output_stream(ctx, (uint32_t)info.hz, (uint8_t)info.channels, 16)) {
                    ESP_LOGE(TAG, "Failed to open audio stream for MP3: %d Hz %d ch", info.hz, info.channels);
                    break;
                }
                sample_rate = info.hz;
                channels = info.channels;
            }

            // Adjust Volume
            int vol = ctx->volume;
            int16_t* samples_ptr = (int16_t*)ctx->pcm_buf;
            size_t sample_count = (size_t)samples * info.channels;
            for (size_t i = 0; i < sample_count; ++i) {
                int32_t scaled = (int32_t)samples_ptr[i] * vol / 100;
                samples_ptr[i] = (int16_t)scaled;
            }

            // Write via audio_stream (resampled to native 44100 internally)
            size_t offset = 0;
            size_t data_size = sample_count * sizeof(int16_t);
            bool write_err = false;
            while (offset < data_size && ctx->state == STATE_PLAYING) {
                size_t written = 0;
                error_t err = audio_stream_write(ctx->stream_handle, (uint8_t*)ctx->pcm_buf + offset, data_size - offset, &written, pdMS_TO_TICKS(1000));
                if (err != ERROR_NONE || written == 0) {
                    ESP_LOGE(TAG, "audio_stream_write error: %d", err);
                    write_err = true;
                    break;
                }
                offset += written;
            }
            if (write_err) break;
        }

        // Update Progress Bar
        if (file_size > 0) {
            int pct = (int)((bytes_read_total - buffered_bytes) * 100 / file_size);
            if (pct < 0) pct = 0;
            if (pct > 100) pct = 100;
            if (pct != ctx->last_pct) {
                ctx->last_pct = pct;
                tt_lvgl_lock(portMAX_DELAY);
                lv_bar_set_value(ctx->bar_progress, pct, LV_ANIM_OFF);
                tt_lvgl_unlock();
            }
        }

        taskYIELD();
    }

    fclose(file);
    close_stream_if_open(ctx);

    bool stopped_externally = (ctx->state == STATE_IDLE);

    if (!stopped_externally) {
        tt_lvgl_lock(portMAX_DELAY);
        handle_audio_finished(ctx);
        tt_lvgl_unlock();
    }

#ifdef ESP_PLATFORM
    heap_caps_free(decoder);
#else
    free(decoder);
#endif
    ctx->playback_task_handle = NULL;
    vTaskDelete(NULL);
}

/* ─── WAV Decoder Routine (audio-stream) ─── */
static void play_wav(AppCtx* ctx) {
    vTaskDelay(pdMS_TO_TICKS(400));

    FILE* file = fopen(ctx->current_audio_path, "rb");
    if (!file) {
        ESP_LOGE(TAG, "Failed to open WAV: %s", ctx->current_audio_path);
        tt_lvgl_lock(portMAX_DELAY);
        ctx->state = STATE_IDLE;
        update_ui(ctx);
        tt_lvgl_unlock();
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }

    WavHeader header;
    if (fread(&header, 1, sizeof(WavHeader), file) != sizeof(WavHeader)) {
        ESP_LOGE(TAG, "Failed to read WAV header");
        fclose(file);
        tt_lvgl_lock(portMAX_DELAY);
        ctx->state = STATE_IDLE;
        update_ui(ctx);
        tt_lvgl_unlock();
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }

    if (strncmp(header.riff, "RIFF", 4) != 0 || strncmp(header.wave, "WAVE", 4) != 0) {
        ESP_LOGE(TAG, "Invalid WAV signature");
        fclose(file);
        tt_lvgl_lock(portMAX_DELAY);
        ctx->state = STATE_IDLE;
        update_ui(ctx);
        tt_lvgl_unlock();
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }

    size_t data_size = header.data_size;
    if (data_size == 0) {
        fseek(file, 0, SEEK_END);
        data_size = ftell(file) - sizeof(WavHeader);
        fseek(file, sizeof(WavHeader), SEEK_SET);
    }

    if (!open_output_stream(ctx, header.sample_rate, header.channels, header.bits_per_sample)) {
        ESP_LOGE(TAG, "Failed to open audio stream for WAV: %u Hz %u ch", (unsigned)header.sample_rate, header.channels);
        fclose(file);
        tt_lvgl_lock(portMAX_DELAY);
        ctx->state = STATE_IDLE;
        update_ui(ctx);
        tt_lvgl_unlock();
        ctx->playback_task_handle = NULL;
        vTaskDelete(NULL);
        return;
    }

    ESP_LOGI(TAG, "Starting WAV via audio-stream: %s (%u Hz, %u ch)", ctx->current_audio_path, (unsigned int)header.sample_rate, (unsigned int)header.channels);

    size_t total_played = 0;
    bool stream_open = true;

    while (total_played < data_size && ctx->state != STATE_IDLE) {
        if (ctx->state == STATE_PAUSED) {
            if (stream_open) {
                close_stream_if_open(ctx);
                stream_open = false;
            }
            vTaskDelay(pdMS_TO_TICKS(50));
            continue;
        }

        if (!stream_open) {
            if (!open_output_stream(ctx, header.sample_rate, header.channels, header.bits_per_sample)) break;
            stream_open = true;
        }

        size_t to_read = (data_size - total_played < MP3_INPUT_BUFFER_SIZE) ? (data_size - total_played) : MP3_INPUT_BUFFER_SIZE;
        size_t read_bytes = fread(ctx->audio_buf, 1, to_read, file);
        if (read_bytes == 0) break;

        // Scaling Volume
        int vol = ctx->volume;
        int16_t* samples_ptr = (int16_t*)ctx->audio_buf;
        size_t sample_count = read_bytes / sizeof(int16_t);
        for (size_t i = 0; i < sample_count; ++i) {
            int32_t scaled = (int32_t)samples_ptr[i] * vol / 100;
            samples_ptr[i] = (int16_t)scaled;
        }

        // Write via audio_stream
        size_t offset = 0;
        bool write_err = false;
        while (offset < read_bytes && ctx->state == STATE_PLAYING) {
            size_t written = 0;
            error_t err = audio_stream_write(ctx->stream_handle, ctx->audio_buf + offset, read_bytes - offset, &written, pdMS_TO_TICKS(500));
            if (err != ERROR_NONE || written == 0) {
                ESP_LOGE(TAG, "audio_stream WAV write error: %d", err);
                write_err = true;
                break;
            }
            offset += written;
        }

        if (write_err) break;

        total_played += read_bytes;

        int pct = (int)((total_played * 100) / data_size);
        if (pct < 0) pct = 0;
        if (pct > 100) pct = 100;
        if (pct != ctx->last_pct) {
            ctx->last_pct = pct;
            tt_lvgl_lock(portMAX_DELAY);
            lv_bar_set_value(ctx->bar_progress, pct, LV_ANIM_OFF);
            tt_lvgl_unlock();
        }

        taskYIELD();
    }

    fclose(file);
    close_stream_if_open(ctx);

    bool stopped_externally = (ctx->state == STATE_IDLE);

    if (!stopped_externally) {
        tt_lvgl_lock(portMAX_DELAY);
        handle_audio_finished(ctx);
        tt_lvgl_unlock();
    }

    ctx->playback_task_handle = NULL;
    vTaskDelete(NULL);
}

/* ─── Picker events ─── */
static void on_book_selected(lv_event_t* e) {
    int index = (int)(intptr_t)lv_event_get_user_data(e);
    AppCtx* ctx = &g_ctx;

    BookMetadata* book = &ctx->books[index];
    strncpy(ctx->current_book_slug, book->slug, sizeof(ctx->current_book_slug) - 1);

    char manifest_path[512];
    snprintf(manifest_path, sizeof(manifest_path), "/sdcard/books/%s/manifest.json", book->slug);

    char* json_str = read_full_file(manifest_path);
    if (!json_str) {
        const char* buttons[] = {"OK"};
        tt_app_alertdialog_start("Read Error", "Failed to open the book manifest.", buttons, 1);
        return;
    }

    ctx->manifest_root = cJSON_Parse(json_str);
    free(json_str);

    if (!ctx->manifest_root) {
        const char* buttons[] = {"OK"};
        tt_app_alertdialog_start("JSON Error", "The book manifest is not formatted correctly.", buttons, 1);
        return;
    }

    ctx->pages_array = cJSON_GetObjectItem(ctx->manifest_root, "pages");
    if (!ctx->pages_array || !cJSON_IsArray(ctx->pages_array)) {
        const char* buttons[] = {"OK"};
        tt_app_alertdialog_start("Format Error", "No pages found in book manifest.", buttons, 1);
        cJSON_Delete(ctx->manifest_root);
        ctx->manifest_root = NULL;
        ctx->pages_array = NULL;
        return;
    }

    ctx->page_count = cJSON_GetArraySize(ctx->pages_array);
    if (ctx->page_count <= 0) {
        const char* buttons[] = {"OK"};
        tt_app_alertdialog_start("Format Error", "The book does not have pages.", buttons, 1);
        cJSON_Delete(ctx->manifest_root);
        ctx->manifest_root = NULL;
        ctx->pages_array = NULL;
        return;
    }

    lv_label_set_text(ctx->lbl_book_title, book->title);

    // Switch views
    lv_obj_add_flag(ctx->picker_wrapper, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_flag(ctx->player_wrapper, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN);
    lv_obj_remove_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN);

    load_page(ctx, 0, false);
}

/* ─── Scan Books ─── */
static void scan_books(AppCtx* ctx) {
    ctx->book_count = 0;
    lv_obj_clean(ctx->lst_books);

    DIR* dir = opendir("/sdcard/books");
    if (!dir) {
        ESP_LOGE(TAG, "Failed to scan books: /sdcard/books folder missing.");
        lv_list_add_text(ctx->lst_books, "No SD card or books directory found.");
        return;
    }

    struct dirent* entry;
    while ((entry = readdir(dir)) != NULL && ctx->book_count < MAX_BOOKS) {
        if (entry->d_name[0] == '.') continue;

        char manifest_path[512];
        snprintf(manifest_path, sizeof(manifest_path), "/sdcard/books/%s/manifest.json", entry->d_name);

        char* json_str = read_full_file(manifest_path);
        if (json_str) {
            cJSON* root = cJSON_Parse(json_str);
            free(json_str);

            if (root) {
                cJSON* title_item = cJSON_GetObjectItem(root, "title");
                cJSON* author_item = cJSON_GetObjectItem(root, "author");

                BookMetadata* book = &ctx->books[ctx->book_count];
                strncpy(book->slug, entry->d_name, sizeof(book->slug) - 1);

                if (title_item && title_item->valuestring) {
                    strncpy(book->title, title_item->valuestring, sizeof(book->title) - 1);
                } else {
                    strncpy(book->title, entry->d_name, sizeof(book->title) - 1);
                }

                if (author_item && author_item->valuestring) {
                    strncpy(book->author, author_item->valuestring, sizeof(book->author) - 1);
                } else {
                    book->author[0] = '\0';
                }

                cJSON_Delete(root);
                ctx->book_count++;
            }
        }
    }
    closedir(dir);

    if (ctx->book_count == 0) {
        lv_list_add_text(ctx->lst_books, "No book manifest.json files found.");
        return;
    }

    // Bubble sort by title
    for (int i = 0; i < ctx->book_count - 1; i++) {
        for (int j = 0; j < ctx->book_count - i - 1; j++) {
            if (strcmp(ctx->books[j].title, ctx->books[j + 1].title) > 0) {
                BookMetadata temp = ctx->books[j];
                ctx->books[j] = ctx->books[j + 1];
                ctx->books[j + 1] = temp;
            }
        }
    }

    // Add items to screen list
    for (int i = 0; i < ctx->book_count; ++i) {
        char label_text[512];
        if (ctx->books[i].author[0] != '\0') {
            snprintf(label_text, sizeof(label_text), "%s\nby %s", ctx->books[i].title, ctx->books[i].author);
        } else {
            snprintf(label_text, sizeof(label_text), "%s", ctx->books[i].title);
        }
        lv_obj_t* btn = lv_list_add_button(ctx->lst_books, LV_SYMBOL_DIRECTORY, label_text);
        lv_obj_add_event_cb(btn, on_book_selected, LV_EVENT_CLICKED, (void*)(intptr_t)i);
    }
}

/* ─── Player Control Events ─── */
static void on_play_pause_click(lv_event_t* e) {
    AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e);
    if (ctx->current_audio_path[0] == '\0') return;

    if (ctx->state == STATE_IDLE) {
        ctx->state = STATE_PLAYING;
        update_ui(ctx);
        xTaskCreate(audio_playback_task, "audio_play", 8192, ctx, 5, &ctx->playback_task_handle);
    } else if (ctx->state == STATE_PLAYING) {
        ctx->state = STATE_PAUSED;
        update_ui(ctx);
    } else if (ctx->state == STATE_PAUSED) {
        ctx->state = STATE_PLAYING;
        update_ui(ctx);
    }
}

static void on_prev_click(lv_event_t* e) {
    AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e);
    if (ctx->current_page > 0) {
        bool was_playing = (ctx->state == STATE_PLAYING);
        load_page(ctx, ctx->current_page - 1, was_playing);
    }
}

static void on_next_click(lv_event_t* e) {
    AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e);
    if (ctx->current_page < ctx->page_count - 1) {
        bool was_playing = (ctx->state == STATE_PLAYING);
        load_page(ctx, ctx->current_page + 1, was_playing);
    }
}

static void on_image_click(lv_event_t* e) {
    AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e);
    if (!ctx) return;

    bool is_hidden = lv_obj_has_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN);
    if (is_hidden) {
        lv_obj_remove_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN);
        lv_obj_remove_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN);
        lv_obj_remove_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN);
    } else {
        lv_obj_add_flag(ctx->header_bar, LV_OBJ_FLAG_HIDDEN);
        lv_obj_add_flag(ctx->ctrl_bar, LV_OBJ_FLAG_HIDDEN);
        lv_obj_add_flag(ctx->bar_progress, LV_OBJ_FLAG_HIDDEN);
    }
}

static void on_back_click(lv_event_t* e) {
    AppCtx* ctx = (AppCtx*)lv_event_get_user_data(e);
    return_to_picker(ctx);
}

/* ─── App Lifecycle ─── */
static void onShowApp(AppHandle app, void* data, lv_obj_t* parent) {
    memset(&g_ctx, 0, sizeof(g_ctx));
    g_ctx.app = app;
    g_ctx.volume = 80;

    // Allocate shared audio buffers
#ifdef ESP_PLATFORM
    g_ctx.audio_buf = (uint8_t*)heap_caps_malloc(MP3_INPUT_BUFFER_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
    g_ctx.pcm_buf = (mp3d_sample_t*)heap_caps_malloc(MINIMP3_MAX_SAMPLES_PER_FRAME * sizeof(mp3d_sample_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
#else
    g_ctx.audio_buf = (uint8_t*)malloc(MP3_INPUT_BUFFER_SIZE);
    g_ctx.pcm_buf = (mp3d_sample_t*)malloc(MINIMP3_MAX_SAMPLES_PER_FRAME * sizeof(mp3d_sample_t));
#endif

    // Find audio-stream device (provides resampling to native 44100)
    if (!find_audio_stream_device(&g_ctx)) {
        ESP_LOGE(TAG, "audio-stream device not found! Tried 'audio-stream' name and AUDIO_STREAM_TYPE");
    }

    // Create dual layouts
    // 1. Picker Screen wrapper
    g_ctx.picker_wrapper = lv_obj_create(parent);
    lv_obj_set_size(g_ctx.picker_wrapper, LV_PCT(100), LV_PCT(100));
    lv_obj_set_style_border_width(g_ctx.picker_wrapper, 0, 0);
    lv_obj_set_style_pad_all(g_ctx.picker_wrapper, 0, 0);
    lv_obj_set_style_pad_gap(g_ctx.picker_wrapper, 0, 0);
    lv_obj_set_style_bg_color(g_ctx.picker_wrapper, lv_color_hex(0x1E1E2E), 0);

    lv_obj_t* toolbar = tt_lvgl_toolbar_create_for_app(g_ctx.picker_wrapper, app);
    lv_obj_align(toolbar, LV_ALIGN_TOP_MID, 0, 0);

    g_ctx.lst_books = lv_list_create(g_ctx.picker_wrapper);
    lv_obj_set_width(g_ctx.lst_books, LV_PCT(100));
    lv_obj_align_to(g_ctx.lst_books, toolbar, LV_ALIGN_OUT_BOTTOM_MID, 0, 0);
    int32_t toolbar_height = lv_obj_get_height(toolbar);
    int32_t parent_height = lv_obj_get_content_height(parent);
    lv_obj_set_height(g_ctx.lst_books, parent_height - toolbar_height);
    lv_obj_set_style_bg_color(g_ctx.lst_books, lv_color_hex(0x1E1E2E), 0);
    lv_obj_set_style_border_color(g_ctx.lst_books, lv_color_hex(0x313244), 0);

    // 2. Player Screen wrapper (hidden on start)
    g_ctx.player_wrapper = lv_obj_create(parent);
    lv_obj_set_size(g_ctx.player_wrapper, LV_PCT(100), LV_PCT(100));
    lv_obj_set_style_border_width(g_ctx.player_wrapper, 0, 0);
    lv_obj_set_style_pad_all(g_ctx.player_wrapper, 0, 0);
    lv_obj_set_style_pad_gap(g_ctx.player_wrapper, 0, 0);
    lv_obj_set_style_bg_color(g_ctx.player_wrapper, lv_color_hex(0x1E1E2E), 0);
    lv_obj_remove_flag(g_ctx.player_wrapper, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_add_flag(g_ctx.player_wrapper, LV_OBJ_FLAG_HIDDEN);

    g_ctx.img_page = lv_image_create(g_ctx.player_wrapper);
    lv_obj_align(g_ctx.img_page, LV_ALIGN_CENTER, 0, 0);
    lv_obj_set_style_bg_opa(g_ctx.img_page, LV_OPA_TRANSP, 0);
    lv_obj_set_style_pad_all(g_ctx.img_page, 0, 0);
    lv_obj_set_style_border_width(g_ctx.img_page, 0, 0);
    lv_obj_remove_flag(g_ctx.img_page, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_add_flag(g_ctx.img_page, LV_OBJ_FLAG_CLICKABLE);
    lv_obj_add_event_cb(g_ctx.img_page, on_image_click, LV_EVENT_CLICKED, &g_ctx);

    g_ctx.header_bar = lv_obj_create(g_ctx.player_wrapper);
    lv_obj_t* header_bar = g_ctx.header_bar;
    lv_obj_set_size(header_bar, LV_PCT(100), 36);
    lv_obj_align(header_bar, LV_ALIGN_TOP_MID, 0, 0);
    lv_obj_set_style_radius(header_bar, 0, 0);
    lv_obj_set_style_bg_color(header_bar, lv_color_hex(0x11111B), 0);
    lv_obj_set_style_bg_opa(header_bar, LV_OPA_COVER, 0);
    lv_obj_set_style_border_color(header_bar, lv_color_hex(0x313244), 0);
    lv_obj_set_style_border_width(header_bar, 1, LV_PART_MAIN);
    lv_obj_remove_flag(header_bar, LV_OBJ_FLAG_SCROLLABLE);

    lv_obj_t* btn_back = lv_button_create(header_bar);
    lv_obj_set_size(btn_back, 44, 26);
    lv_obj_align(btn_back, LV_ALIGN_LEFT_MID, 0, 0);
    lv_obj_set_style_radius(btn_back, 6, 0);
    lv_obj_set_style_bg_color(btn_back, lv_color_hex(0x313244), 0);
    lv_obj_t* lbl_back = lv_label_create(btn_back);
    lv_label_set_text(lbl_back, LV_SYMBOL_LEFT);
    lv_obj_center(lbl_back);
    lv_obj_add_event_cb(btn_back, on_back_click, LV_EVENT_CLICKED, &g_ctx);

    g_ctx.lbl_book_title = lv_label_create(header_bar);
    lv_obj_align(g_ctx.lbl_book_title, LV_ALIGN_CENTER, 0, 0);
    lv_obj_set_width(g_ctx.lbl_book_title, 180);
    lv_obj_set_style_text_align(g_ctx.lbl_book_title, LV_TEXT_ALIGN_CENTER, 0);
    lv_obj_set_style_text_color(g_ctx.lbl_book_title, lv_color_hex(0xCDD6F4), 0);
    lv_label_set_long_mode(g_ctx.lbl_book_title, LV_LABEL_LONG_DOT);

    g_ctx.lbl_indicator = lv_label_create(header_bar);
    lv_obj_align(g_ctx.lbl_indicator, LV_ALIGN_RIGHT_MID, 0, 0);
    lv_obj_set_style_text_color(g_ctx.lbl_indicator, lv_color_hex(0xA6ADC8), 0);
    lv_label_set_text(g_ctx.lbl_indicator, "1 / 1");

    g_ctx.ctrl_bar = lv_obj_create(g_ctx.player_wrapper);
    lv_obj_t* ctrl_bar = g_ctx.ctrl_bar;
    lv_obj_set_size(ctrl_bar, LV_PCT(100), 40);
    lv_obj_align(ctrl_bar, LV_ALIGN_BOTTOM_MID, 0, 0);
    lv_obj_set_style_radius(ctrl_bar, 0, 0);
    lv_obj_set_style_bg_color(ctrl_bar, lv_color_hex(0x11111B), 0);
    lv_obj_set_style_bg_opa(ctrl_bar, LV_OPA_COVER, 0);
    lv_obj_set_style_border_width(ctrl_bar, 0, 0);
    lv_obj_set_style_pad_all(ctrl_bar, 0, 0);
    lv_obj_set_style_pad_gap(ctrl_bar, 0, 0);
    lv_obj_set_flex_flow(ctrl_bar, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(ctrl_bar, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
    lv_obj_remove_flag(ctrl_bar, LV_OBJ_FLAG_SCROLLABLE);

    g_ctx.bar_progress = lv_bar_create(g_ctx.player_wrapper);
    lv_obj_set_size(g_ctx.bar_progress, LV_PCT(100), 4);
    lv_obj_align_to(g_ctx.bar_progress, ctrl_bar, LV_ALIGN_OUT_TOP_MID, 0, 0);
    lv_bar_set_range(g_ctx.bar_progress, 0, 100);
    lv_bar_set_value(g_ctx.bar_progress, 0, LV_ANIM_OFF);
    lv_obj_set_style_bg_color(g_ctx.bar_progress, lv_color_hex(0x45475A), LV_PART_MAIN);
    lv_obj_set_style_bg_color(g_ctx.bar_progress, lv_color_hex(0x89B4FA), LV_PART_INDICATOR);

    g_ctx.btn_prev = lv_button_create(ctrl_bar);
    lv_obj_set_size(g_ctx.btn_prev, 54, 30);
    lv_obj_set_style_radius(g_ctx.btn_prev, 15, 0);
    lv_obj_set_style_bg_color(g_ctx.btn_prev, lv_color_hex(0x313244), 0);
    lv_obj_t* lbl_prev = lv_label_create(g_ctx.btn_prev);
    lv_label_set_text(lbl_prev, LV_SYMBOL_PREV);
    lv_obj_center(lbl_prev);
    lv_obj_add_event_cb(g_ctx.btn_prev, on_prev_click, LV_EVENT_CLICKED, &g_ctx);

    g_ctx.btn_play_pause = lv_button_create(ctrl_bar);
    lv_obj_set_size(g_ctx.btn_play_pause, 94, 30);
    lv_obj_set_style_radius(g_ctx.btn_play_pause, 15, 0);
    lv_obj_set_style_bg_color(g_ctx.btn_play_pause, lv_color_hex(0x89B4FA), 0);
    lv_obj_set_style_text_color(g_ctx.btn_play_pause, lv_color_hex(0x11111B), 0);
    lv_obj_t* lbl_play_btn = lv_label_create(g_ctx.btn_play_pause);
    lv_label_set_text(lbl_play_btn, LV_SYMBOL_PLAY " Play");
    lv_obj_center(lbl_play_btn);
    lv_obj_add_event_cb(g_ctx.btn_play_pause, on_play_pause_click, LV_EVENT_CLICKED, &g_ctx);

    g_ctx.btn_next = lv_button_create(ctrl_bar);
    lv_obj_set_size(g_ctx.btn_next, 54, 30);
    lv_obj_set_style_radius(g_ctx.btn_next, 15, 0);
    lv_obj_set_style_bg_color(g_ctx.btn_next, lv_color_hex(0x313244), 0);
    lv_obj_t* lbl_next = lv_label_create(g_ctx.btn_next);
    lv_label_set_text(lbl_next, LV_SYMBOL_NEXT);
    lv_obj_center(lbl_next);
    lv_obj_add_event_cb(g_ctx.btn_next, on_next_click, LV_EVENT_CLICKED, &g_ctx);

    // Initial load
    g_ctx.state = STATE_IDLE;
    update_ui(&g_ctx);

    scan_books(&g_ctx);
}

static void onHideApp(AppHandle app, void* data) {
    wait_for_playback_task_to_exit(&g_ctx);
    close_stream_if_open(&g_ctx);

    if (g_ctx.manifest_root) {
        cJSON_Delete(g_ctx.manifest_root);
        g_ctx.manifest_root = NULL;
        g_ctx.pages_array = NULL;
    }

#ifdef ESP_PLATFORM
    if (g_ctx.audio_buf) {
        heap_caps_free(g_ctx.audio_buf);
        g_ctx.audio_buf = NULL;
    }
    if (g_ctx.pcm_buf) {
        heap_caps_free(g_ctx.pcm_buf);
        g_ctx.pcm_buf = NULL;
    }
#else
    if (g_ctx.audio_buf) {
        free(g_ctx.audio_buf);
        g_ctx.audio_buf = NULL;
    }
    if (g_ctx.pcm_buf) {
        free(g_ctx.pcm_buf);
        g_ctx.pcm_buf = NULL;
    }
#endif
}

int main(int argc, char* argv[]) {
    tt_app_register((AppRegistration) {
        .onShow = onShowApp,
        .onHide = onHideApp
    });
    return 0;
}
