// Copyright (C) 2026 Actia Nordic AB. All rights reserved.

#include <actia/actia.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>

#include "ipc.h"

#define IPC_MSG_BUF_SIZE 256
#define IPC_OUTBOX_SIZE  512
#define IPC_INBOX_SIZE   512

A_IPC_STATIC_BUFFERS_BYTES(ipc_buffers, IPC_INBOX_SIZE, IPC_OUTBOX_SIZE);
A_IPC_STATIC_MSG(msg, IPC_MSG_BUF_SIZE);

typedef struct {
    bool session_open;
} ipc_state_t;

static a_ipc_handle *a_ipc;
static ipc_state_t ipc_state = {
    .session_open = false,
};
static uint8_t pending_led_state = LED_OFF;

static void ipc_handle_open_session_rsp(a_ipc_msg_ipc_open_session_rsp *msg_rsp)
{
    if (msg_rsp->result != A_IPC_ENUM_IPC_OPEN_SESSION_RESULT_OK) {
        fprintf(stderr, "Error opening session: %d\n", msg_rsp->result);
        set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
        return;
    }

    ipc_state.session_open = true;

    A_IPC_RESULT rc = ipc_set_led(A_IPC_ENUM_LED_PIN_TYPE_GREEN, LED_ON);
    if (rc != A_IPC_RET_OK) {
        fprintf(stderr, "Couldn't send message\n");
        set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
        return;
    }
}

static void ipc_handle_led_set_rsp(a_ipc_msg_led_set_rsp *msg_rsp)
{
    if (msg_rsp->result != A_IPC_ENUM_LED_RESULT_OK) {
        fprintf(stderr, "Error lighting LED: %d\n", msg_rsp->result);
        set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
    } else if (pending_led_state == LED_ON) {
        sleep(1);

        A_IPC_RESULT rc = ipc_set_led(A_IPC_ENUM_LED_PIN_TYPE_GREEN, LED_OFF);
        if (rc != A_IPC_RET_OK) {
            fprintf(stderr, "Couldn't send message\n");
            set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
            return;
        }

    } else {
        set_event_loop_state(EVENT_LOOP_EXIT_OK);
    }
}

int ipc_initialize_actia_ipc(int ipc_id, int epfd)
{
    a_ipc = a_ipc_init(ipc_id, &ipc_buffers);

    if (a_ipc == NULL) {
        return -ENOMEM;
    }

    struct epoll_event ipc_events = {
        .events = EPOLLIN,
        .data.fd = a_ipc_get_fd(a_ipc),
    };

    if (epoll_ctl(epfd, EPOLL_CTL_ADD, a_ipc_get_fd(a_ipc), &ipc_events) == -1) {
        fprintf(stderr, "Error epoll_ctl ipc_fd, EPOLL_CTL_ADD: %d\n", errno);
        int saved_errno = errno;
        a_ipc_destroy(a_ipc);
        return -saved_errno;
    }

    return a_ipc_get_fd(a_ipc);
}

A_IPC_RESULT ipc_send_open_session_req(int to)
{
    A_IPC_RESULT rc = a_ipc_init_ipc_open_session_req(msg);
    if (rc != A_IPC_RET_OK) {
        fprintf(stderr, "Failed to create open session request: %s\n", a_ipc_result_str(rc));
        return rc;
    }

    rc = a_ipc_send(a_ipc, to, msg);
    if (rc != A_IPC_RET_OK) {
        fprintf(stderr, "Failed to send open session request: %s\n", a_ipc_result_str(rc));
        return rc;
    }
}

bool ipc_handle_actia_ipc_event(struct epoll_event *event)
{
    if (!(event->events & EPOLLIN) || event->data.fd != a_ipc_get_fd(a_ipc)) {
        return false;
    }

    int from = -1;
    A_IPC_RESULT rc = a_ipc_recv(a_ipc, &from, msg);

    if (rc != A_IPC_RET_OK) {
        fprintf(stderr, "Failed to fetch message\n");
        set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
        return true;
    }

    (void)from;

    switch (msg->info.type) {
    case A_IPC_MSG_IPC_OPEN_SESSION_RSP:
        ipc_handle_open_session_rsp(&msg->ipc_open_session_rsp);
        break;
    case A_IPC_MSG_LED_SET_RSP:
        ipc_handle_led_set_rsp(&msg->led_set_rsp);
        break;
    default:
        fprintf(stderr, "Unrecognized response received\n");
        set_event_loop_state(EVENT_LOOP_EXIT_ERROR);
        break;
    }

    return true;
}

A_IPC_RESULT ipc_set_led(a_ipc_enum_led_pin_type led, uint8_t state)
{
    A_IPC_RESULT rc = a_ipc_init_led_set_req(msg);
    if (rc != A_IPC_RET_OK) {
        fprintf(stderr, "Could not init A_IPC_LED_SET_REQ message %d\n", rc);
        return rc;
    }

    msg->led_set_req.pin = led;
    msg->led_set_req.value = state;

    pending_led_state = state;

    return a_ipc_send(a_ipc, A_SERVICE_ID_SYSTEM, msg);
}

void ipc_destroy_actia_ipc(void)
{
    if (a_ipc != NULL) {
        a_ipc_destroy(a_ipc);
        a_ipc = NULL;
    }
    ipc_state.session_open = false;
}
