#include "MediaKeys.h"

#include <tactility/log.h>
#include <esp_heap_caps.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <tactility/lvgl_fonts.h>
#include <tt_lvgl.h>
#include <tt_lvgl_toolbar.h>

static const char* TAG = "MediaKeys";

// Button layout: two rows of three media-control buttons
static const char* BTN_MAP[] = {
    LV_SYMBOL_PREV, LV_SYMBOL_PLAY, LV_SYMBOL_NEXT, "\n",
    LV_SYMBOL_MUTE, LV_SYMBOL_VOLUME_MID, LV_SYMBOL_VOLUME_MAX, ""
};

// Physical key → button matrix index mapping (B=prev, P=play, N=next, M=mute, D=vol-, U=vol+)
static const struct { uint32_t key; uint32_t btnIdx; } KEY_MAP[] = {
    { 'b', 0 }, { 'B', 0 },
    { 'p', 1 }, { 'P', 1 },
    { 'n', 2 }, { 'N', 2 },
    { 'm', 3 }, { 'M', 3 },
    { 'd', 4 }, { 'D', 4 },
    { 'u', 5 }, { 'U', 5 },
};

// HID Consumer Page (0x0C) usage codes for each button, in BTN_MAP order
static const uint16_t CONSUMER_USAGE[6] = {
    0x00B6, // 0 – PREV:      Previous Track
    0x00CD, // 1 – PLAY:      Play/Pause
    0x00B5, // 2 – NEXT:      Next Track
    0x00E2, // 3 – MUTE:      Mute
    0x00EA, // 4 – VOL_DOWN:  Volume Decrement
    0x00E9, // 5 – VOL_UP:    Volume Increment
};

// Data passed to the one-shot key-send task
struct SendKeyData {
    struct Device* hidDevice;
    uint16_t usage;
};

// ---- Static task / callback implementations ----

void MediaKeys::sendKeyTask(void* param) {
    SendKeyData* data = static_cast<SendKeyData*>(param);

    uint8_t press[2] = {
        static_cast<uint8_t>(data->usage & 0xFF),
        static_cast<uint8_t>((data->usage >> 8) & 0xFF)
    };
    bluetooth_hid_device_send_consumer(data->hidDevice, press, 2);

    vTaskDelay(pdMS_TO_TICKS(50));

    uint8_t release[2] = {0, 0};
    bluetooth_hid_device_send_consumer(data->hidDevice, release, 2);

    delete data;
    vTaskDelete(nullptr);
}

void MediaKeys::onSwitchToggled(lv_event_t* event) {
    if (lv_event_get_code(event) != LV_EVENT_VALUE_CHANGED) return;
    MediaKeys* self = static_cast<MediaKeys*>(lv_event_get_user_data(event));
    if (!self) return;
    bool enabled = lv_obj_has_state(lv_event_get_target_obj(event), LV_STATE_CHECKED);
    self->handleSwitchToggle(enabled);
}

void MediaKeys::onButtonPressed(lv_event_t* event) {
    if (lv_event_get_code(event) != LV_EVENT_VALUE_CHANGED) return;
    MediaKeys* self = static_cast<MediaKeys*>(lv_event_get_user_data(event));
    if (!self) return;
    uint32_t id = lv_btnmatrix_get_selected_btn(lv_event_get_target_obj(event));
    if (id != LV_BTNMATRIX_BTN_NONE) {
        self->handleButtonPress(id);
    }
}

void MediaKeys::onKeyEvent(lv_event_t* event) {
    if (lv_event_get_code(event) != LV_EVENT_KEY) return;
    MediaKeys* self = static_cast<MediaKeys*>(lv_event_get_user_data(event));
    if (!self || !self->_buttonMatrix) return;

    uint32_t key = lv_event_get_key(event);

    // Q or Esc exits key mode and returns focus to normal UI navigation
    if (key == 'q' || key == 'Q' || key == LV_KEY_ESC) {
        self->exitKeyMode();
        return;
    }

    if (!self->_isEnabled) return;

    for (auto& mapping : KEY_MAP) {
        if (mapping.key == key) {
            // Highlight: select the button and mark checked for visual feedback
            self->_activeKeyBtn = mapping.btnIdx;
            lv_buttonmatrix_set_selected_button(self->_buttonMatrix, mapping.btnIdx);
            lv_buttonmatrix_set_button_ctrl(self->_buttonMatrix, mapping.btnIdx, LV_BTNMATRIX_CTRL_CHECKED);

            // Restart the highlight-clear timer
            if (self->_keyHighlightTimer) {
                lv_timer_reset(self->_keyHighlightTimer);
                lv_timer_resume(self->_keyHighlightTimer);
            }

            self->handleButtonPress(mapping.btnIdx);
            return;
        }
    }
}

void MediaKeys::enterKeyMode() {
    if (_keyboardActive || !_buttonMatrix) return;
    lv_group_t* group = lv_group_get_default();
    if (!group) return;
    lv_group_add_obj(group, _buttonMatrix);
    lv_group_focus_obj(_buttonMatrix);
    lv_group_set_editing(group, true);
    _keyboardActive = true;
    LOG_I(TAG, "Key mode: ON (Q/Esc to exit)");
}

void MediaKeys::exitKeyMode() {
    if (!_keyboardActive || !_buttonMatrix) return;
    lv_group_t* group = lv_group_get_default();
    if (group) lv_group_set_editing(group, false);
    lv_group_remove_obj(_buttonMatrix);
    _keyboardActive = false;
    LOG_I(TAG, "Key mode: OFF");
}

void MediaKeys::onKeyHighlightTimer(lv_timer_t* t) {
    MediaKeys* self = static_cast<MediaKeys*>(lv_timer_get_user_data(t));
    if (!self || !self->_buttonMatrix) return;
    if (self->_activeKeyBtn != LV_BTNMATRIX_BTN_NONE) {
        lv_buttonmatrix_clear_button_ctrl(self->_buttonMatrix, self->_activeKeyBtn, LV_BTNMATRIX_CTRL_CHECKED);
        self->_activeKeyBtn = LV_BTNMATRIX_BTN_NONE;
    }
    lv_obj_remove_state(self->_buttonMatrix, LV_STATE_FOCUSED);
    lv_timer_pause(t);
}

void MediaKeys::btEventCallback(struct Device* /*device*/, void* context, struct BtEvent event) {
    MediaKeys* self = static_cast<MediaKeys*>(context);
    if (!self) return;

    if (event.type == BT_EVENT_RADIO_STATE_CHANGED) {
        LOG_I(TAG, "BT radio state: %d", (int)event.radio_state);

        if (event.radio_state == BT_RADIO_STATE_ON) {
            // Radio is now up - start HID (needs LVGL lock for UI update)
            if (tt_lvgl_lock(1000)) {
                // Re-check inside lock to avoid TOCTOU race with handleSwitchToggle(false)
                if (self->_radioEnabling) {
                    self->startHid();
                }
                tt_lvgl_unlock();
            }
        } else if (event.radio_state == BT_RADIO_STATE_OFF && self->_isEnabled) {
            // Radio dropped while we were active - revert UI
            LOG_I(TAG, "BT radio turned off, disabling HID");
            if (tt_lvgl_lock(1000)) {
                if (tt_lvgl_hardware_keyboard_is_available()) self->exitKeyMode();
                self->_hidDevice = nullptr;
                self->_isEnabled = false;
                self->_radioEnabling = false;
                if (self->_switchWidget) lv_obj_remove_state(self->_switchWidget, LV_STATE_CHECKED);
                if (self->_mainWrapper) lv_obj_add_flag(self->_mainWrapper, LV_OBJ_FLAG_HIDDEN);
                tt_lvgl_unlock();
            }
        }
    } else if (event.type == BT_EVENT_PROFILE_STATE_CHANGED && event.profile_state.profile == BT_PROFILE_HID_DEVICE) {
        LOG_I(TAG, "HID device: %s", event.profile_state.state == BT_PROFILE_STATE_CONNECTED ? "connected" : "disconnected");
    }
}

// ---- Instance methods ----

void MediaKeys::startHid() {
    // Called once the BT radio is confirmed ON (either already was, or just came up).
    // May be called from the BT event callback thread - LVGL must already be locked by caller.
    _radioEnabling = false;

    _hidDevice = bluetooth_hid_device_get_device();
    if (!_hidDevice) {
        LOG_E(TAG, "BLE HID device unavailable after radio on");
        if (_btDevice) bluetooth_remove_event_callback(_btDevice, btEventCallback);
        _btDevice = nullptr;
        _isEnabled = false;
        if (_switchWidget) lv_obj_remove_state(_switchWidget, LV_STATE_CHECKED);
        return;
    }

    error_t err = bluetooth_hid_device_start(_hidDevice, BT_HID_DEVICE_MODE_KEYBOARD);
    if (err != ERROR_NONE) {
        LOG_E(TAG, "Failed to start HID device: %d", (int)err);
        if (_btDevice) bluetooth_remove_event_callback(_btDevice, btEventCallback);
        _btDevice = nullptr;
        _hidDevice = nullptr;
        _isEnabled = false;
        if (_switchWidget) lv_obj_remove_state(_switchWidget, LV_STATE_CHECKED);
        return;
    }

    if (_mainWrapper) lv_obj_remove_flag(_mainWrapper, LV_OBJ_FLAG_HIDDEN);
    if (tt_lvgl_hardware_keyboard_is_available()) enterKeyMode();
}

void MediaKeys::teardownBt() {
    // Remove callback FIRST - stops any in-flight BT events from firing against
    // our (possibly already freed) UI widget pointers after this returns.
    if (_btDevice) bluetooth_remove_event_callback(_btDevice, btEventCallback);
    // Do NOT call bluetooth_hid_device_stop here: it calls ble_gatts_reset() /
    // ble_gatts_start() which corrupts NimBLE heap while the host task is still
    // running. HID device is a persistent kernel device; hid_device_start() cleans
    // up stale context on next use. Explicit stop is handled by handleSwitchToggle.
    // Restore the radio/device to the state we found them in.
    if (_btDevice && _radioWasOff) bluetooth_set_radio_enabled(_btDevice, false);
    if (_btDevice && _deviceWasStarted) device_stop(_btDevice);
    _btDevice = nullptr;
    _hidDevice = nullptr;
    _radioWasOff = false;
    _deviceWasStarted = false;
}

void MediaKeys::handleSwitchToggle(bool enabled) {
    LOG_I(TAG, "Switch: %s", enabled ? "ON" : "OFF");
    _isEnabled = enabled;

    if (enabled) {
        _btDevice = device_find_first_by_type(&BLUETOOTH_TYPE);
        if (!_btDevice) {
            LOG_E(TAG, "No Bluetooth device found");
            _isEnabled = false;
            if (_switchWidget) lv_obj_remove_state(_switchWidget, LV_STATE_CHECKED);
            return;
        }

        // Device may not be started yet (BT disabled in DTS by default to save memory).
        if (!device_is_ready(_btDevice)) {
            LOG_I(TAG, "BT device not started, starting now");
            if (device_start(_btDevice) != ERROR_NONE) {
                LOG_E(TAG, "Failed to start BT device");
                _btDevice = nullptr;
                _isEnabled = false;
                if (_switchWidget) lv_obj_remove_state(_switchWidget, LV_STATE_CHECKED);
                return;
            }
            _deviceWasStarted = true;
        }

        bluetooth_set_device_name(_btDevice, "Tactility Media Keys");

        // Register callback before enabling radio so we don't miss the state-change event.
        bluetooth_add_event_callback(_btDevice, this, btEventCallback);

        enum BtRadioState radioState;
        bluetooth_get_radio_state(_btDevice, &radioState);

        if (radioState == BT_RADIO_STATE_ON) {
            // Radio already up - start HID immediately.
            _radioWasOff = false;
            startHid();
        } else {
            // Turn the radio on; startHid() will be called from btEventCallback
            // once BT_RADIO_STATE_ON fires.
            LOG_I(TAG, "BT radio not on (state=%d), enabling...", (int)radioState);
            _radioWasOff = true;
            _radioEnabling = true;
            bluetooth_set_radio_enabled(_btDevice, true);
        }
    } else {
        _radioEnabling = false;
        if (tt_lvgl_hardware_keyboard_is_available()) exitKeyMode();
        // Explicit user toggle-off: stop HID cleanly (safe here since we're on the
        // LVGL task and the user intentionally disabled, so no race with app teardown).
        if (_hidDevice) bluetooth_hid_device_stop(_hidDevice);
        teardownBt();
        if (_mainWrapper) lv_obj_add_flag(_mainWrapper, LV_OBJ_FLAG_HIDDEN);
    }
}

void MediaKeys::handleButtonPress(uint32_t buttonId) {
    if (!_hidDevice || !_isEnabled || buttonId >= 6) return;

    if (!bluetooth_hid_device_is_connected(_hidDevice)) {
        LOG_W(TAG, "Not connected, ignoring button %lu", buttonId);
        return;
    }

    LOG_I(TAG, "Button %lu pressed", buttonId);

    SendKeyData* data = new SendKeyData {_hidDevice, CONSUMER_USAGE[buttonId]};
    if (xTaskCreate(sendKeyTask, "bt_key", 4096, data, tskIDLE_PRIORITY + 1, nullptr) != pdPASS) {
        LOG_E(TAG, "Failed to create send task");
        delete data;
    }
}

void MediaKeys::onShow(AppHandle appHandle, lv_obj_t* parent) {
    _parent = parent;
    lv_obj_remove_flag(parent, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);

    lv_obj_t* toolbar = tt_lvgl_toolbar_create_for_app(parent, appHandle);
    lv_obj_align(toolbar, LV_ALIGN_TOP_MID, 0, 0);

    _switchWidget = tt_lvgl_toolbar_add_switch_action(toolbar);
    lv_obj_add_event_cb(_switchWidget, onSwitchToggled, LV_EVENT_VALUE_CHANGED, this);

    _mainWrapper = lv_obj_create(parent);
    lv_obj_set_style_bg_color(_mainWrapper, lv_palette_darken(LV_PALETTE_GREY, 4), LV_PART_MAIN);
    lv_obj_set_width(_mainWrapper, LV_PCT(100));
    lv_obj_set_flex_grow(_mainWrapper, 1);
    lv_obj_set_style_pad_all(_mainWrapper, 4, LV_PART_MAIN);
    lv_obj_set_style_border_width(_mainWrapper, 0, LV_PART_MAIN);
    lv_obj_remove_flag(_mainWrapper, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_set_flex_flow(_mainWrapper, LV_FLEX_FLOW_COLUMN);

    _buttonMatrix = lv_btnmatrix_create(_mainWrapper);
    lv_btnmatrix_set_map(_buttonMatrix, BTN_MAP);
    lv_obj_set_style_text_font(_buttonMatrix, lvgl_get_text_font(FONT_SIZE_LARGE), LV_PART_ITEMS);
    lv_obj_set_style_pad_all(_buttonMatrix, 5, LV_PART_MAIN);
    lv_obj_set_style_pad_row(_buttonMatrix, 5, LV_PART_MAIN);
    lv_obj_set_style_pad_column(_buttonMatrix, 5, LV_PART_MAIN);
    lv_obj_set_style_border_width(_buttonMatrix, 0, LV_PART_MAIN);
    lv_obj_set_style_bg_opa(_buttonMatrix, 0, LV_PART_MAIN);

    if (lv_display_get_horizontal_resolution(nullptr) <= 240 ||
        lv_display_get_vertical_resolution(nullptr) <= 240) {
        lv_obj_set_size(_buttonMatrix, lv_pct(100), lv_pct(70));
    } else {
        lv_obj_set_size(_buttonMatrix, lv_pct(100), lv_pct(85));
    }
    lv_obj_set_flex_grow(_buttonMatrix, 1);

    lv_obj_add_event_cb(_buttonMatrix, onButtonPressed, LV_EVENT_VALUE_CHANGED, this);

    // Physical keyboard support: key events on the matrix (entered when BT enabled, Q/Esc exits)
    if (tt_lvgl_hardware_keyboard_is_available()) {
        lv_obj_add_event_cb(_buttonMatrix, onKeyEvent, LV_EVENT_KEY, this);
        _keyHighlightTimer = lv_timer_create(onKeyHighlightTimer, 150, this);
        lv_timer_pause(_keyHighlightTimer);
    }

    lv_obj_add_flag(_mainWrapper, LV_OBJ_FLAG_HIDDEN);

    // Auto-enable if BT is already on (turned on via QuickPanel/Settings before opening app).
    struct Device* btDev = device_find_first_by_type(&BLUETOOTH_TYPE);
    if (btDev && device_is_ready(btDev)) {
        enum BtRadioState radioState;
        if (bluetooth_get_radio_state(btDev, &radioState) == ERROR_NONE && radioState == BT_RADIO_STATE_ON) {
            lv_obj_add_state(_switchWidget, LV_STATE_CHECKED);
            handleSwitchToggle(true);
        }
    }
}

void MediaKeys::onHide(AppHandle /*appHandle*/) {
    _radioEnabling = false;
    _isEnabled = false;
    if (tt_lvgl_hardware_keyboard_is_available()) exitKeyMode();
    teardownBt();
    if (_keyHighlightTimer) {
        lv_timer_delete(_keyHighlightTimer);
        _keyHighlightTimer = nullptr;
    }
    _activeKeyBtn = LV_BTNMATRIX_BTN_NONE;

    _parent = nullptr;
    _mainWrapper = nullptr;
    _switchWidget = nullptr;
    _buttonMatrix = nullptr;
}