/*
 * IR camera session, recovered from libmagcore.so.2.1.1:
 *
 * Link:   enumerate VID 0x833C -> open -> set_auto_detach(1) ->
 *         set_configuration(2) -> claim_interface(0)
 * Commands: write 8-byte {u32 magic, u32 param} on EP 0x03, then read up to
 *         0x1000 bytes on EP 0x82 with 2000 ms timeout; success requires > 3
 *         bytes.  Response magic 0x5BB5B55B carries the camera info block.
 * Start:  allocate 2*len+0x470 read buffer, create reader thread (EP 0x81)
 *         + dispatcher thread, sleep 50 ms, send 0x6BB6B673.
 * Stop:   send 0x6BB6B674, join threads.
 * FFC:    0x6BB6B672 (+param).
 *
 * 2026-08-10 hardware: commands are 4-byte (magic only); only FFC is 8-byte
 * {magic, param}.  FFC(1) switches the stream to type=0 frames, FFC(0) back
 * to type=1.  The official demo alternates FFC(0)/FFC(1) (FFC(1) exactly 9
 * frames after FFC(0)) to keep the type=0 stream alive; verified 1400+
 * type=0 frames at 15 fps with zero stalls using the mag160c_ffc_scheduler.
 */
#include "mag160c_internal.h"
#include "mag160c/mag160c_display.h"

#include <stdlib.h>
#include <time.h>

#if MAG160C_HAS_LIBUSB
#include <libusb.h>
#endif

#if MAG160C_HAS_THREADS
#include <pthread.h>
#endif

struct mag160c_ctx_t {
    int dummy;
};

struct mag160c_ir_t {
#if MAG160C_HAS_LIBUSB
    libusb_context *usb;         /* kept alive for the lifetime of the handle */
    libusb_device_handle *handle;
#endif
    uint32_t pid;
    uint32_t width;
    uint32_t height;
    uint32_t frame_len;          /* expected frame data length (bytes) */
    uint32_t ffc_mode;
    uint32_t info[8];            /* 0x5bb5b55b block cache */
    int linked;
    int running;
    int prepared;

#if MAG160C_HAS_THREADS
    pthread_t reader_thread;
    pthread_t dispatch_thread;
    int threads_up;
#endif

    mag160c_frame_cb_t frame_cb;
    void *frame_cb_user;

    /* optional FFC scheduler: replicated official cadence keeps the type=0
     * stream alive (verified 1400+ frames).  When set, the reader thread
     * issues FFC commands after complete frames as the scheduler dictates. */
    mag160c_ffc_scheduler_t *ffc_sched;
    int ffc_sched_owned;
};

mag160c_error_t mag160c_init(mag160c_ctx_t **out_ctx) {
    if (out_ctx == NULL) {
        mag160c_set_error("mag160c_init: out_ctx null");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    *out_ctx = (mag160c_ctx_t *)calloc(1, sizeof(mag160c_ctx_t));
    if (*out_ctx == NULL) {
        mag160c_set_error("mag160c_init: allocation failed");
        return MAG160C_ERR_NO_MEMORY;
    }
    mag160c_clear_error();
    return MAG160C_OK;
}

void mag160c_shutdown(mag160c_ctx_t *ctx) {
    free(ctx);
}

#if MAG160C_HAS_LIBUSB

/* ---- command channel: EP 0x03 write + EP 0x82 read ---------------------- */

static mag160c_error_t cmd_transfer(mag160c_ir_t *ir, const uint8_t *cmd, size_t cmd_len) {
    int transferred = 0;
    int rc = libusb_bulk_transfer(ir->handle, MAG160C_IR_EP_CMD_OUT,
                                  (uint8_t *)cmd, (int)cmd_len, &transferred, 500);
    if (rc != 0 || (size_t)transferred != cmd_len) {
        mag160c_set_error("cmd: write EP 0x03 failed (%s)", libusb_error_name(rc));
        return MAG160C_ERR_USB;
    }

    uint8_t resp[0x1000];
    rc = libusb_bulk_transfer(ir->handle, MAG160C_IR_EP_CMD_IN, resp, sizeof(resp),
                              &transferred, 2000);
    if (rc != 0) {
        mag160c_set_error("cmd: read EP 0x82 failed (%s)", libusb_error_name(rc));
        return MAG160C_ERR_USB;
    }
    if (transferred <= 3) {
        mag160c_set_error("cmd: short response (%d bytes)", transferred);
        return MAG160C_ERR_BAD_FRAME;
    }

    const uint32_t magic = (uint32_t)resp[0] | ((uint32_t)resp[1] << 8) |
                           ((uint32_t)resp[2] << 16) | ((uint32_t)resp[3] << 24);
    const int payload_len = transferred - 4;
    switch (magic) {
    case MAG160C_MAG_RSP_INFO_0:
        /* 0x5bb5b55b carries the camera info block (pid, width@+0x10,
           height@+0x14); the 0x5bb5b55c block has a different layout and
           must NOT be parsed as info */
        if (payload_len >= (int)sizeof(ir->info)) {
            memcpy(ir->info, resp + 4, sizeof(ir->info));
            ir->width = ir->info[4];   /* +0x10 */
            ir->height = ir->info[5];  /* +0x14 */
            ir->frame_len = ir->width * ir->height * 2;
        }
        break;
    default:
        break;
    }
    mag160c_clear_error();
    return MAG160C_OK;
}

static mag160c_error_t send_cmd32(mag160c_ir_t *ir, uint32_t magic, uint32_t param) {
    uint8_t cmd[8];
    cmd[0] = (uint8_t)(magic);
    cmd[1] = (uint8_t)(magic >> 8);
    cmd[2] = (uint8_t)(magic >> 16);
    cmd[3] = (uint8_t)(magic >> 24);
    cmd[4] = (uint8_t)(param);
    cmd[5] = (uint8_t)(param >> 8);
    cmd[6] = (uint8_t)(param >> 16);
    cmd[7] = (uint8_t)(param >> 24);
    return cmd_transfer(ir, cmd, sizeof(cmd));
}

/* Verified on hardware (WinUSB, VID 0x833C PID 0x0001):
 * most commands are 4 bytes (magic only); only FFC (0x6bb6b672) carries an
 * 8-byte {magic, param} payload.  The official demo sends 66b/66c/66f as
 * 4-byte packets and FFC before START, then FFC(0/1 alternating) after every
 * ~10 frames. */
static mag160c_error_t send_cmd4(mag160c_ir_t *ir, uint32_t magic) {
    uint8_t cmd[4];
    cmd[0] = (uint8_t)(magic);
    cmd[1] = (uint8_t)(magic >> 8);
    cmd[2] = (uint8_t)(magic >> 16);
    cmd[3] = (uint8_t)(magic >> 24);
    return cmd_transfer(ir, cmd, sizeof(cmd));
}

/* ---- frame reader thread (recovered 0x170a4) ----------------------------- */

typedef struct reader_ctx_t {
    mag160c_ir_t *ir;
    uint8_t *buf;       /* 2*frame_len + 0x470 */
    size_t buf_cap;
    size_t buf_len;
    size_t aligned;
} reader_ctx_t;

static void reader_align(reader_ctx_t *r) {
    size_t i = 0;
    for (; i + 4 <= r->buf_len; i += 4) {
        if (r->buf[i] == 0x1b && r->buf[i + 1] == 0xb1 &&
            r->buf[i + 2] == 0xb1 && r->buf[i + 3] == 0x1b) {
            break;
        }
    }
    if (i == r->buf_len) {
        r->buf_len = 0;
        return;
    }
    if (i != 0) {
        memmove(r->buf, r->buf + i, r->buf_len - i);
        r->buf_len -= i;
    }
    r->aligned = 1;
}

static void *reader_thread_fn(void *arg) {
    reader_ctx_t *r = (reader_ctx_t *)arg;
    mag160c_ir_t *ir = r->ir;
    uint8_t tmp[0x8000];

    while (ir->running) {
        int transferred = 0;
        int rc = libusb_bulk_transfer(ir->handle, MAG160C_IR_EP_STREAM_IN, tmp,
                                      (int)sizeof(tmp), &transferred, 500);
        if (rc != 0 || transferred <= 0) {
            continue;
        }
        if ((size_t)transferred > r->buf_cap - r->buf_len) {
            r->buf_len = 0; /* buffer full: drop and resync */
            r->aligned = 0;
        }
        memcpy(r->buf + r->buf_len, tmp, (size_t)transferred);
        r->buf_len += (size_t)transferred;

        if (!r->aligned) {
            reader_align(r);
        }

        /* complete frame = 0x38 + data_length */
        while (r->aligned && r->buf_len >= MAG160C_FRAME_OVERHEAD) {
            const uint32_t len = (uint32_t)r->buf[8] | ((uint32_t)r->buf[9] << 8) |
                                 ((uint32_t)r->buf[10] << 16) | ((uint32_t)r->buf[11] << 24);
            const size_t total = (size_t)MAG160C_FRAME_OVERHEAD + len;
            if (len > r->buf_cap) {
                r->buf_len = 0;
                r->aligned = 0;
                break;
            }
            if (r->buf_len < total) {
                break;
            }
            const size_t trail = (size_t)MAG160C_FRAME_DATA_OFFSET + len;
            if (r->buf[trail] == 0x1c && r->buf[trail + 1] == 0xb1 &&
                r->buf[trail + 2] == 0xb1 && r->buf[trail + 3] == 0x1b) {
                /* valid frame: notify dispatcher via callback */
                if (ir->frame_cb != NULL) {
                    const uint32_t idx = (uint32_t)r->buf[4] | ((uint32_t)r->buf[5] << 8) |
                                         ((uint32_t)r->buf[6] << 16) |
                                         ((uint32_t)r->buf[7] << 24);
                    ir->frame_cb(idx, r->buf, total, ir->frame_cb_user);
                }
                /* official FFC cadence: tick after every complete frame and
                 * send the requested FFC command (0/1) immediately */
                if (ir->ffc_sched != NULL) {
                    const int32_t param = mag160c_ffc_scheduler_tick(ir->ffc_sched);
                    if (param >= 0) {
                        (void)send_cmd32(ir, MAG160C_MAG_CMD_FFC, (uint32_t)param);
                    }
                }
                memmove(r->buf, r->buf + total, r->buf_len - total);
                r->buf_len -= total;
                if (r->buf_len == 0) {
                    r->aligned = 0;
                }
            } else {
                r->buf_len = 0;
                r->aligned = 0;
                break;
            }
        }
    }
    return NULL;
}

#endif /* MAG160C_HAS_LIBUSB */

mag160c_error_t mag160c_ir_open(mag160c_ctx_t *ctx, mag160c_ir_t **out_ir) {
    if (ctx == NULL || out_ir == NULL) {
        mag160c_set_error("mag160c_ir_open: null argument");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    *out_ir = NULL;

#if !MAG160C_HAS_LIBUSB
    mag160c_set_error("mag160c_ir_open: built without libusb support");
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    mag160c_ir_t *ir = (mag160c_ir_t *)calloc(1, sizeof(mag160c_ir_t));
    if (ir == NULL) {
        mag160c_set_error("mag160c_ir_open: allocation failed");
        return MAG160C_ERR_NO_MEMORY;
    }
    ir->pid = 0;
    ir->linked = 0;

    libusb_context *usb = NULL;
    int rc = libusb_init(&usb);
    if (rc != 0) {
        mag160c_set_error("mag160c_ir_open: libusb_init failed");
        free(ir);
        return MAG160C_ERR_USB;
    }

    libusb_device **list = NULL;
    const ssize_t count = libusb_get_device_list(usb, &list);
    libusb_device_handle *handle = NULL;
    for (ssize_t i = 0; i < count && handle == NULL; ++i) {
        struct libusb_device_descriptor desc;
        if (libusb_get_device_descriptor(list[i], &desc) != 0) {
            continue;
        }
        if (desc.idVendor != MAG160C_IR_VENDOR_ID) {
            continue;
        }
        if (libusb_open(list[i], &handle) != 0) {
            continue;
        }
        libusb_set_auto_detach_kernel_driver(handle, 1);
        /* vendor tries config 2 first, then falls back to config 1
           (libmagcore 0x1856a -> 0x1865b); this unit has only config 1 */
        if (libusb_set_configuration(handle, 2) != 0) {
            if (libusb_set_configuration(handle, 1) != 0) {
                libusb_close(handle);
                handle = NULL;
                continue;
            }
        }
        if (libusb_claim_interface(handle, MAG160C_IR_INTERFACE_NUMBER) != 0) {
            libusb_close(handle);
            handle = NULL;
            continue;
        }
        ir->pid = desc.idProduct;
    }
    libusb_free_device_list(list, 1);

    if (handle == NULL) {
        libusb_exit(usb);
        mag160c_set_error("mag160c_ir_open: no device with VID 0x%04x",
                          MAG160C_IR_VENDOR_ID);
        free(ir);
        return MAG160C_ERR_NOT_OPEN;
    }

    ir->usb = usb;       /* keep context alive; released in mag160c_ir_close */
    ir->handle = handle;
    ir->linked = 1;

    /* query camera info: verified on hardware the sequence is
       0x6bb6b66b (4B), 0x6bb6b66c (4B), 0x6bb6b66f (4B) */
    (void)send_cmd4(ir, MAG160C_MAG_CMD_PREPARE1);
    (void)send_cmd4(ir, MAG160C_MAG_CMD_PREPARE2);
    (void)send_cmd4(ir, MAG160C_MAG_CMD_GET_INFO);

    *out_ir = ir;
    mag160c_clear_error();
    return MAG160C_OK;
#endif
}

void mag160c_ir_close(mag160c_ir_t *ir) {
    if (ir == NULL) {
        return;
    }
    if (ir->running) {
        (void)mag160c_ir_stop(ir);
    }
#if MAG160C_HAS_LIBUSB
    if (ir->handle != NULL) {
        libusb_release_interface(ir->handle, MAG160C_IR_INTERFACE_NUMBER);
        libusb_close(ir->handle);
        ir->handle = NULL;
    }
    if (ir->usb != NULL) {
        libusb_exit(ir->usb);
        ir->usb = NULL;
    }
#endif
    if (ir->ffc_sched_owned && ir->ffc_sched != NULL) {
        free(ir->ffc_sched);
        ir->ffc_sched = NULL;
    }
    free(ir);
}

mag160c_error_t mag160c_ir_is_linked(mag160c_ir_t *ir) {
    if (ir == NULL) {
        mag160c_set_error("mag160c_ir_is_linked: ir null");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    return ir->linked ? MAG160C_OK : MAG160C_ERR_NOT_OPEN;
}

mag160c_error_t mag160c_ir_get_info(mag160c_ir_t *ir, mag160c_ir_info_t *out_info) {
    if (ir == NULL || out_info == NULL) {
        mag160c_set_error("mag160c_ir_get_info: null argument");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    memset(out_info, 0, sizeof(*out_info));
    out_info->width = ir->width ? ir->width : 160;
    out_info->height = ir->height ? ir->height : 120;
    out_info->fpa_width = out_info->width;
    out_info->fpa_height = out_info->height;
    out_info->pid = ir->pid;
    out_info->serial_lo = ir->info[1]; /* +0x08 */
    out_info->serial_hi = ir->info[2]; /* +0x10 upper */
    out_info->max_fps = 25;
    snprintf(out_info->name, sizeof(out_info->name), "MAG-IR-0x%04x", ir->pid);
    mag160c_clear_error();
    return MAG160C_OK;
}

mag160c_error_t mag160c_ir_set_frame_callback(mag160c_ir_t *ir, mag160c_frame_cb_t cb,
                                              void *user) {
    if (ir == NULL) {
        mag160c_set_error("mag160c_ir_set_frame_callback: ir null");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    ir->frame_cb = cb;
    ir->frame_cb_user = user;
    return MAG160C_OK;
}

mag160c_error_t mag160c_ir_prepare(mag160c_ir_t *ir) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_prepare: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
#if !MAG160C_HAS_LIBUSB
    (void)ir;
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    mag160c_error_t e = send_cmd4(ir, MAG160C_MAG_CMD_PREPARE1);
    if (e != MAG160C_OK) {
        return e;
    }
    e = send_cmd4(ir, MAG160C_MAG_CMD_PREPARE2);
    if (e != MAG160C_OK) {
        return e;
    }
    ir->prepared = 1;
    return MAG160C_OK;
#endif
}

mag160c_error_t mag160c_ir_start(mag160c_ir_t *ir) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_start: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
    if (ir->running) {
        mag160c_set_error("mag160c_ir_start: already running");
        return MAG160C_ERR_NOT_READY;
    }
#if !MAG160C_HAS_LIBUSB
    (void)ir;
    return MAG160C_ERR_NOT_SUPPORTED;
#elif !MAG160C_HAS_THREADS
    (void)ir;
    mag160c_set_error("mag160c_ir_start: built without thread support");
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    if (ir->frame_len == 0) {
        ir->frame_len = 160 * 120 * 2; /* 38400 default */
    }
    reader_ctx_t *r = (reader_ctx_t *)calloc(1, sizeof(reader_ctx_t));
    if (r == NULL) {
        mag160c_set_error("mag160c_ir_start: allocation failed");
        return MAG160C_ERR_NO_MEMORY;
    }
    r->ir = ir;
    r->buf_cap = ir->frame_len * 2 + 0x470;
    r->buf = (uint8_t *)malloc(r->buf_cap);
    if (r->buf == NULL) {
        free(r);
        mag160c_set_error("mag160c_ir_start: allocation failed");
        return MAG160C_ERR_NO_MEMORY;
    }

    ir->running = 1;
    if (pthread_create(&ir->reader_thread, NULL, reader_thread_fn, r) != 0) {
        ir->running = 0;
        free(r->buf);
        free(r);
        mag160c_set_error("mag160c_ir_start: pthread_create failed");
        return MAG160C_ERR_INTERNAL;
    }
    ir->threads_up = 1;

    /* vendor sleeps 50 ms before issuing START */
    struct timespec ts;
    ts.tv_sec = 0;
    ts.tv_nsec = 50 * 1000 * 1000;
    nanosleep(&ts, NULL);

    /* verified on hardware: FFC(0) twice before START switches the unit into
       the live imaging mode (type=0 frames); the official demo does this */
    (void)send_cmd32(ir, MAG160C_MAG_CMD_FFC, 0);
    (void)send_cmd32(ir, MAG160C_MAG_CMD_FFC, 0);
    ts.tv_nsec = 300 * 1000 * 1000;
    nanosleep(&ts, NULL);

    mag160c_error_t e = send_cmd4(ir, MAG160C_MAG_CMD_START);
    if (e != MAG160C_OK) {
        ir->running = 0;
        pthread_join(ir->reader_thread, NULL);
        ir->threads_up = 0;
        free(r->buf);
        free(r);
        return e;
    }
    return MAG160C_OK;
#endif
}

mag160c_error_t mag160c_ir_stop(mag160c_ir_t *ir) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_stop: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
#if !MAG160C_HAS_LIBUSB
    (void)ir;
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    if (ir->running) {
        ir->running = 0;
        (void)send_cmd4(ir, MAG160C_MAG_CMD_STOP);
#if MAG160C_HAS_THREADS
        if (ir->threads_up) {
            pthread_join(ir->reader_thread, NULL);
            ir->threads_up = 0;
        }
#endif
    }
    return MAG160C_OK;
#endif
}

mag160c_error_t mag160c_ir_trigger_ffc(mag160c_ir_t *ir, uint32_t param) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_trigger_ffc: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
#if !MAG160C_HAS_LIBUSB
    (void)ir;
    (void)param;
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    return send_cmd32(ir, MAG160C_MAG_CMD_FFC, param);
#endif
}

mag160c_error_t mag160c_ir_set_ffc_mode(mag160c_ir_t *ir, uint32_t mode) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_set_ffc_mode: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
    ir->ffc_mode = mode; /* ffc mode stored locally; affects start behavior */
    return MAG160C_OK;
}

/* Attach an FFC scheduler.  The scheduler is ticked after every complete
 * frame in the reader thread; when it returns 0/1 the corresponding FFC
 * command is sent (official demo cadence keeps the type=0 stream alive).
 * If sched is NULL, the scheduler is disabled.  A stack-allocated scheduler
 * must outlive the stream; pass own=1 to let the IR session free it. */
mag160c_error_t mag160c_ir_set_ffc_scheduler(mag160c_ir_t *ir,
                                             mag160c_ffc_scheduler_t *sched,
                                             int own) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_set_ffc_scheduler: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
    if (ir->ffc_sched_owned && ir->ffc_sched != NULL) {
        free(ir->ffc_sched);
    }
    ir->ffc_sched = sched;
    ir->ffc_sched_owned = own;
    mag160c_clear_error();
    return MAG160C_OK;
}

mag160c_error_t mag160c_ir_reset(mag160c_ir_t *ir) {
    if (ir == NULL || !ir->linked) {
        mag160c_set_error("mag160c_ir_reset: not linked");
        return MAG160C_ERR_NOT_OPEN;
    }
#if !MAG160C_HAS_LIBUSB
    (void)ir;
    return MAG160C_ERR_NOT_SUPPORTED;
#else
    return send_cmd32(ir, MAG160C_MAG_CMD_FFC, 0);
#endif
}

mag160c_error_t mag160c_ir_read_temperature(mag160c_ir_t *ir, uint32_t x, uint32_t y,
                                            int32_t *out_temp) {
    (void)x;
    (void)y;
    if (ir == NULL || out_temp == NULL) {
        mag160c_set_error("mag160c_ir_read_temperature: null argument");
        return MAG160C_ERR_INVALID_ARGUMENT;
    }
    *out_temp = 0;
    if (!ir->linked) {
        return MAG160C_ERR_NOT_OPEN;
    }
    /* requires the host pipeline; temperature map is maintained by the
     * frame callback (mag160c_temp_calibrate).  Without a live frame the
     * vendor SDK returns 0xe4ae0001. */
    mag160c_set_error("mag160c_ir_read_temperature: no temperature map available "
                      "(feed frames via mag160c_temp_calibrate first)");
    return MAG160C_ERR_NOT_READY;
}