#pragma once

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include "esp_err.h"

#ifdef __cplusplus
extern "C" {
#endif

// ---------- platform_bootstrap ----------
esp_err_t platform_bootstrap_init(void);

// ---------- wifi_manager ----------
typedef enum {
    WIFI_MANAGER_EVENT_PROVISIONING_STARTED = 0,
    WIFI_MANAGER_EVENT_STA_CONNECTING,
    WIFI_MANAGER_EVENT_STA_CONNECTED,
    WIFI_MANAGER_EVENT_STA_CONNECT_FAILED,
    WIFI_MANAGER_EVENT_STA_DISCONNECTED,
} wifi_manager_event_t;

typedef void (*wifi_manager_event_cb_t)(wifi_manager_event_t event, void *user_data);

esp_err_t wifi_manager_start(void);
esp_err_t wifi_manager_stop(void);
esp_err_t wifi_manager_set_event_callback(wifi_manager_event_cb_t cb, void *user_data);

bool wifi_manager_is_ready(void);
bool wifi_manager_has_saved_credentials(void);
void wifi_manager_get_ip(char *buf, size_t buf_len);

// ---------- thermal_printer ----------
typedef struct {
    bool has_paper;
    int8_t paper_gpio_level;
    uint8_t paper_present_level;
    bool battery_adc_ready;
    bool ntc_adc_ready;
    int battery_adc_raw;
    int ntc_adc_raw;
    uint16_t battery_mv;
    uint8_t battery_percent;
    float temperature_c;
    int64_t updated_ms;
} platform_printer_sensors_t;

typedef struct {
    uint16_t width;
    uint16_t height;
    const uint8_t *raster;
    size_t raster_len;
    uint16_t strobe_on_time_us;
    uint16_t strobe_interval_us;
    uint16_t motor_step_delay_us;
    uint8_t motor_steps_per_line;
    uint32_t timeout_ms;
    bool ignore_precheck;
    const volatile bool *cancel_flag;
} platform_printer_print_request_t;

esp_err_t platform_printer_init(void);
void platform_printer_deinit(void);
esp_err_t platform_printer_get_sensors(platform_printer_sensors_t *out_sensors);
esp_err_t platform_printer_print(const platform_printer_print_request_t *request,
                                 char *err,
                                 size_t err_len);
esp_err_t platform_printer_gap_move(uint32_t timeout_ms, char *err, size_t err_len);

// ---------- display_st7789 ----------
esp_err_t platform_display_init(void);
esp_err_t platform_display_show_boot_logo(void);
esp_err_t platform_display_show_raster_1bpp(const uint8_t *raster,
                                            size_t raster_len,
                                            uint16_t width,
                                            uint16_t height,
                                            uint32_t timeout_ms,
                                            char *err,
                                            size_t err_len);
esp_err_t platform_display_show_png(const uint8_t *png,
                                    size_t png_len,
                                    uint32_t timeout_ms,
                                    char *err,
                                    size_t err_len);
void platform_display_mark_shared_spi_dirty(void);
void platform_display_deinit(void);

// ---------- mic_key ----------
typedef enum {
    PLATFORM_MIC_KEY_EVENT_PRESS_DOWN = 0,
    PLATFORM_MIC_KEY_EVENT_PRESS_UP,
} platform_mic_key_event_t;

typedef void (*platform_mic_key_event_cb_t)(platform_mic_key_event_t event, void *user_data);

esp_err_t platform_mic_key_init(void);
void platform_mic_key_deinit(void);
esp_err_t platform_mic_key_set_event_callback(platform_mic_key_event_cb_t cb, void *user_data);

// ---------- power_key ----------
typedef enum {
    PLATFORM_POWER_KEY_EVENT_LONG_PRESS = 0,
    PLATFORM_POWER_KEY_EVENT_PRESS_UP,
} platform_power_key_event_t;

typedef void (*platform_power_key_event_cb_t)(platform_power_key_event_t event, void *user_data);

esp_err_t platform_power_key_init(void);
void platform_power_key_deinit(void);
esp_err_t platform_power_key_set_event_callback(platform_power_key_event_cb_t cb, void *user_data);

// Controls the board hold line: true keeps power on, false releases hold.
esp_err_t platform_power_hold_set(bool hold_on);

// ---------- voice_audio ----------
typedef struct {
    uint32_t sample_rate;
    uint8_t channels;
    uint8_t bits_per_sample;
    int output_volume;
    float input_gain_db;
} voice_audio_open_config_t;

esp_err_t voice_audio_open(const voice_audio_open_config_t *cfg, char *err, size_t err_len);
void voice_audio_close(void);

bool voice_audio_is_open(void);

// timeout_ms applies to voice-audio mutex acquisition.
// Underlying codec driver I/O duration depends on driver/clocking state.
esp_err_t voice_audio_read_pcm(int16_t *pcm,
                               size_t samples,
                               uint32_t timeout_ms,
                               char *err,
                               size_t err_len);
// timeout_ms applies to voice-audio mutex acquisition.
// Underlying codec driver I/O duration depends on driver/clocking state.
esp_err_t voice_audio_write_pcm(const int16_t *pcm,
                                size_t samples,
                                uint32_t timeout_ms,
                                char *err,
                                size_t err_len);

// ---------- runtime_policy ----------
uint32_t runtime_policy_wifi_connect_timeout_ms(void);

uint32_t runtime_policy_lifecycle_start_retry_count(void);
uint32_t runtime_policy_lifecycle_retry_backoff_ms(uint32_t attempt);
bool runtime_policy_is_retryable_error(esp_err_t err);

uint32_t runtime_policy_printer_control_lock_timeout_ms(void);
uint32_t runtime_policy_printer_worker_queue_wait_ms(void);
uint32_t runtime_policy_printer_queue_retry_delay_ms(void);
uint32_t runtime_policy_printer_status_poll_interval_ms(void);
uint32_t runtime_policy_printer_stop_timeout_ms(void);

uint32_t runtime_policy_printer_operation_timeout_ms(void);
uint16_t runtime_policy_printer_strobe_on_us(void);
uint16_t runtime_policy_printer_strobe_interval_us(void);
uint16_t runtime_policy_printer_max_dots_per_pulse(void);
uint16_t runtime_policy_printer_motor_step_us(void);
bool runtime_policy_printer_motor_reverse(void);
uint8_t runtime_policy_printer_steps_per_line(void);
uint16_t runtime_policy_printer_gap_steps(void);
float runtime_policy_printer_temp_min_c(void);
float runtime_policy_printer_temp_max_c(void);
uint8_t runtime_policy_printer_battery_min_percent(void);
uint8_t runtime_policy_printer_paper_present_level(void);
uint16_t runtime_policy_printer_battery_empty_mv(void);
uint16_t runtime_policy_printer_battery_full_mv(void);
uint16_t runtime_policy_printer_battery_divider_ratio_x1000(void);
uint32_t runtime_policy_printer_ntc_pullup_ohms(void);
uint32_t runtime_policy_printer_ntc_r25_ohms(void);
uint32_t runtime_policy_printer_ntc_beta(void);

uint32_t runtime_policy_image_generation_timeout_default_ms(void);
uint32_t runtime_policy_image_generation_timeout_min_ms(void);
uint32_t runtime_policy_image_generation_timeout_max_ms(void);

uint32_t runtime_policy_image_download_timeout_default_ms(void);
uint32_t runtime_policy_image_download_timeout_min_ms(void);
uint32_t runtime_policy_image_download_timeout_max_ms(void);

// ---------- product_test_uart ----------
typedef struct {
    int port;
    int baud_rate;
    int tx_pin;
    int rx_pin;
    size_t rx_buffer_size;
    size_t tx_buffer_size;
} platform_test_uart_config_t;

esp_err_t platform_test_uart_init(const platform_test_uart_config_t *cfg);
void platform_test_uart_deinit(void);
esp_err_t platform_test_uart_read_byte(uint8_t *out_byte, uint32_t timeout_ms);
esp_err_t platform_test_uart_write_line(const char *line, uint32_t timeout_ms);

#ifdef __cplusplus
}
#endif