// GET /api/devices/screen.png?mac=XX — Render and return a PNG for the device's
// current screen Uses LVGL to render the device's XML layout (or a fallback
// label) then encodes to PNG via lodepng.

#include "esp_heap_caps.h"
#include "esp_http_server.h"
#include "esp_log.h"
#include "lodepng/lodepng.h"
#include "lodepng_alloc.hpp"
#include "lv_setup.hpp"
#include "lvgl.h"
#include <string.h>

#include "device.hpp"
#include "types.hpp"

internal const char *kTagDeviceScreenImage = "API_DEV_SCREEN_IMG";

internal esp_err_t api_devices_screen_image_handler(httpd_req_t *req)
{
  httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
  httpd_resp_set_hdr(req, "Cache-Control",
                     "no-cache, no-store, must-revalidate");
  httpd_resp_set_type(req, "image/png");

  // Extract mac query parameter
  char mac[18] = {};
  size_t buf_len = httpd_req_get_url_query_len(req) + 1;
  if (buf_len > 1)
  {
    char query[64] = {};
    if (httpd_req_get_url_query_str(req, query, sizeof(query)) == ESP_OK)
    {
      httpd_query_key_value(query, "mac", mac, sizeof(mac));
    }
  }

  if (mac[0] == '\0')
  {
    httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
                        "Missing 'mac' query param");
    return ESP_FAIL;
  }

  device_t *dev = find_device(mac);
  if (!dev)
  {
    httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Device not registered");
    return ESP_FAIL;
  }

  // --- LVGL rendering (mutex-protected) ---
  if (xSemaphoreTake(g_LvglMutex, pdMS_TO_TICKS(5000)) != pdTRUE)
  {
    ESP_LOGE(kTagDeviceScreenImage, "Failed to get LVGL mutex");
    httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "LVGL busy");
    return ESP_FAIL;
  }

  lv_obj_t *scr = lv_screen_active();

  // Clear all children from the active screen
  lv_obj_clean(scr);

  // White background for grayscale
  lv_obj_set_style_bg_color(scr, lv_color_white(), LV_PART_MAIN);

  // Setup the MAC address subject so the XML can bind to it
  static lv_subject_t mac_subject;
  // Two buffers are needed by LVGL for string observers (current and previous)
  static char mac_buf[18];
  static char mac_prev_buf[18];

  strncpy(mac_buf, mac, sizeof(mac_buf));
  strncpy(mac_prev_buf, mac, sizeof(mac_prev_buf));

  lv_subject_init_string(&mac_subject, mac_buf, mac_prev_buf, sizeof(mac_buf),
                         mac);

  // Register the subject in the global XML scope under the name "device_mac"
  lv_xml_component_scope_t *global_scope =
      lv_xml_component_get_scope("globals");
  if (global_scope)
  {
    lv_xml_register_subject(global_scope, "device_mac", &mac_subject);
    ESP_LOGI(kTagDeviceScreenImage,
             "Registered subject 'device_mac' with value: %s", mac);
  }

  bool render_success = false;

  // 1. Prepare the XML payload
  const char *xml_to_register = NULL;
  static char
      xml_buffer[DEVICE_XML_MAX + 100]; // static buffer to avoid stack overflow

  if (dev->xml_layout[0] == '\0')
  {
    ESP_LOGI(kTagDeviceScreenImage, "Device %s has no layout xml.", mac);
    return ESP_FAIL;
  }

  if (strstr(dev->xml_layout, "<screen") != NULL)
  {
    // The user provided a correct <screen> wrapped XML
    xml_to_register = dev->xml_layout;
    ESP_LOGI(kTagDeviceScreenImage,
             "XML already contains <screen>, passing directly to parser.");
  }

  // 2. Register the XML payload as a component
  lv_result_t res =
      lv_xml_register_component_from_data("current_device", xml_to_register);

  if (res == LV_RESULT_OK)
  {
    ESP_LOGI(kTagDeviceScreenImage, "Successfully registered XML for device %s",
             mac);

    // 3. Since we enforce <screen> now, we always create a screen instance
    lv_obj_t *new_scr = lv_xml_create_screen("current_device");

    if (new_scr)
    {
      // We must load this newly created screen to make it active before
      // rendering
      lv_screen_load(new_scr);
      scr = new_scr; // Update local pointer since active screen changed
      render_success = true;
    }
    else
    {
      ESP_LOGE(kTagDeviceScreenImage,
               "lv_xml_create_screen failed for device %s", mac);
    }
  }
  else
  {
    ESP_LOGE(kTagDeviceScreenImage,
             "lv_xml_register_component_from_data failed for device %s", mac);
  }

  // 3. Fallback if LVGL XML parsing or creation failed
  if (!render_success)
  {
    ESP_LOGW(kTagDeviceScreenImage,
             "XML render failed, falling back to raw text layout");
    lv_obj_t *label = lv_label_create(scr);
    lv_label_set_text(label, "XML Parsing Error\nSee serial log");
    lv_obj_set_style_text_color(label, lv_color_black(), LV_PART_MAIN);
    lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
  }

  // Force LVGL to fully render the screen
  lv_refr_now(g_LvglDisplay);

  lv_draw_buf_t *draw_buf = lv_display_get_buf_active(g_LvglDisplay);
  if (!draw_buf)
  {
    xSemaphoreGive(g_LvglMutex);
    ESP_LOGE(kTagDeviceScreenImage, "No active draw buffer");
    httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
                        "Display uninitialized");
    return ESP_FAIL;
  }

  uint32_t width = CONFIG_CALENDINK_DISPLAY_WIDTH;
  uint32_t height = CONFIG_CALENDINK_DISPLAY_HEIGHT;

  // Allocate bounding memory for quantizing RGB565 buffer into tightly packed
  // 8-bit PNG data.
  uint8_t *packed_data =
      (uint8_t *)heap_caps_malloc(width * height, MALLOC_CAP_SPIRAM);
  if (!packed_data)
  {
    packed_data = (uint8_t *)malloc(width * height);
    if (!packed_data)
    {
      xSemaphoreGive(g_LvglMutex);
      ESP_LOGE(kTagDeviceScreenImage, "Failed to allocate packed buffer");
      httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
                          "Out of memory");
      return ESP_FAIL;
    }
  }

  // LVGL renders into RGB565 (2 bytes per pixel).
  // Parse pixels, extract luminance, and quantize to 4 levels (0, 85, 170, 255).
  for (uint32_t y = 0; y < height; ++y)
  {
    const uint16_t *src_row = (const uint16_t *)((const uint8_t *)draw_buf->data + (y * draw_buf->header.stride));
    uint8_t *dst_row = packed_data + (y * width);

    for (uint32_t x = 0; x < width; ++x)
    {
      uint16_t c = src_row[x];
      // Expand 5/6/5 components
      uint8_t r_5 = (c >> 11) & 0x1F;
      uint8_t g_6 = (c >> 5) & 0x3F;
      uint8_t b_5 = c & 0x1F;

      // Unpack to 8-bit true values
      uint8_t r = (r_5 << 3) | (r_5 >> 2);
      uint8_t g = (g_6 << 2) | (g_6 >> 4);
      uint8_t b = (b_5 << 3) | (b_5 >> 2);

      // Simple luminance
      uint8_t lum = (r * 77 + g * 150 + b * 29) >> 8;

      // 4-level linear quantization (0, 85, 170, 255)
      dst_row[x] = (lum >> 6) * 85;
    }
  }

  // Encode to PNG
  unsigned char *png = nullptr;
  size_t pngsize = 0;

  lodepng_allocator_reset();

  ESP_LOGI(kTagDeviceScreenImage, "Encoding %lux%lu PNG for device %s", width,
           height, mac);
  unsigned error = lodepng_encode_memory(&png, &pngsize, packed_data, width,
                                         height, LCT_GREY, 8);

  free(packed_data);

  xSemaphoreGive(g_LvglMutex);

  if (error)
  {
    ESP_LOGE(kTagDeviceScreenImage, "PNG encoding error %u: %s", error,
             lodepng_error_text(error));
    httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
                        "PNG generation failed");
    return ESP_FAIL;
  }

  ESP_LOGI(kTagDeviceScreenImage, "PNG ready: %zu bytes. Sending...", pngsize);
  esp_err_t sendRes = httpd_resp_send(req, (const char *)png, pngsize);

  return sendRes;
}

internal const httpd_uri_t api_devices_screen_image_uri = {
    .uri = "/api/devices/screen.png",
    .method = HTTP_GET,
    .handler = api_devices_screen_image_handler,
    .user_ctx = NULL};
