---

#include "srtm_camera_client.h"
#include "srtm_heap.h"
#include "srtm_dispatcher.h"
#include "srtm_message.h"
#include "srtm_service_struct.h"
#include "fsl_debug_console.h"
#include <assert.h>

/* Internal client service structure */
typedef struct _srtm_camera_client
{
    struct _srtm_service service;
} *srtm_camera_client_t;

/* Forward declarations of required SRTM lifecycle functions */
static srtm_status_t SRTM_CameraClient_Request(srtm_service_t service, srtm_request_t request);
static srtm_status_t SRTM_CameraClient_Notify(srtm_service_t service, srtm_notification_t notif);

/**
 * @brief Handles responses (ACKs) sent back from Linux (A55) after a command is processed
 */
static srtm_status_t SRTM_CameraClient_ResponseHandler(srtm_dispatcher_t dispatcher,
                                                       srtm_peercore_t peer,
                                                       srtm_packet_t packet,
                                                       void *userParam)
{
    struct _srtm_camera_payload *camResp;
    uint8_t command;

    command = SRTM_CommMessage_GetCommand((srtm_response_t)packet);
    camResp = (struct _srtm_camera_payload *)(void *)SRTM_CommMessage_GetPayload((srtm_response_t)packet);
    
    assert(camResp);

    /* Log the execution result received from Linux */
    if (camResp->retCode == SRTM_CAMERA_RETURN_CODE_SUCCESS)
    {
        PRINTF("[SRTM Camera Client] Linux successfully executed command %d for cameraID %d\r\n", 
               command, camResp->cameraID);
    }
    else
    {
        PRINTF("[SRTM Camera Client] Linux FAILED command %d for cameraID %d (Error code: %d)\r\n", 
               command, camResp->cameraID, camResp->retCode);
    }

    return SRTM_Status_Success;
}

/**
 * @brief Helper function to construct and deliver an SRTM request packet to Linux
 */
static srtm_status_t SRTM_CameraClient_SendCmd(srtm_service_t service, srtm_peercore_t core, uint8_t cmd, uint8_t cameraID)
{
    srtm_channel_t channel;
    srtm_request_t request;
    struct _srtm_camera_payload *camReq;

    assert(service);
    assert(service->dispatcher);

    if (!core || !SRTM_PeerCore_IsConnected(core))
    {
        PRINTF("[SRTM Camera Client] Error: Linux peer core is not connected yet!\r\n");
        return SRTM_Status_InvalidParameter;
    }

    /* Get the communication channel associated with this peer core */
    channel = SRTM_PeerCore_GetChannel(core, SRTM_CAMERA_CATEGORY);
    if (!channel)
    {
        PRINTF("[SRTM Camera Client] Error: No channel found for Camera category!\r\n");
        return SRTM_Status_InvalidParameter;
    }

    /* Allocate an SRTM Request message */
    request = SRTM_Request_Create(channel, SRTM_CAMERA_CATEGORY, SRTM_CAMERA_VERSION, cmd, 
                                  (uint16_t)sizeof(struct _srtm_camera_payload));
    if (request == NULL)
    {
        return SRTM_Status_OutOfMemory;
    }

    /* Fill the message payload data */
    camReq = (struct _srtm_camera_payload *)(void *)SRTM_CommMessage_GetPayload(request);
    camReq->cameraID = cameraID;
    camReq->retCode  = 0; /* Clear return code field before sending */

    PRINTF("[SRTM Camera Client] Sending command %d for cameraID %d to Linux...\r\n", cmd, cameraID);

    /* Hand over the request packet to the SRTM dispatcher to send it over RPMsg */
    return SRTM_Dispatcher_DeliverRequest(service->dispatcher, request);
}

/**
 * @brief Public API to send a START camera request
 */
srtm_status_t SRTM_CameraClient_SendStart(srtm_service_t service, srtm_peercore_t core, uint8_t cameraID)
{
    return SRTM_CameraClient_SendCmd(service, core, SRTM_CAMERA_CMD_START, cameraID);
}

/**
 * @brief Public API to send a STOP camera request
 */
srtm_status_t SRTM_CameraClient_SendStop(srtm_service_t service, srtm_peercore_t core, uint8_t cameraID)
{
    return SRTM_CameraClient_SendCmd(service, core, SRTM_CAMERA_CMD_STOP, cameraID);
}

/**
 * @brief Allocates and initializes the Camera Client service
 */
srtm_service_t SRTM_CameraClient_Create(void)
{
    srtm_camera_client_t handle;

    handle = (srtm_camera_client_t)SRTM_Heap_Malloc(sizeof(struct _srtm_camera_client));
    assert(handle);

    /* Standard SRTM service baseline configuration */
    SRTM_List_Init(&handle->service.node);
    handle->service.dispatcher = NULL;
    handle->service.category   = SRTM_CAMERA_CATEGORY;
    handle->service.destroy    = SRTM_CameraService_Destroy; /* Handled by implementation below */
    handle->service.request    = SRTM_CameraClient_Request;
    handle->service.notify     = SRTM_CameraClient_Notify;

    /* Register the handler to process async responses coming back from Linux server */
    SRTM_Service_RegisterResponseHandler(&handle->service, SRTM_CAMERA_CATEGORY, 
                                         SRTM_CameraClient_ResponseHandler, NULL);

    return &handle->service;
}

void SRTM_CameraService_Destroy(srtm_service_t service)
{
    srtm_camera_client_t handle = (srtm_camera_client_t)(void *)service;
    assert(service);
    assert(SRTM_List_IsEmpty(&service->node));
    SRTM_Heap_Free(handle);
}

void SRTM_CameraService_Reset(srtm_service_t service, srtm_peercore_t core)
{
    assert(service);
}

/* Unused for client architecture since M7 only sends requests, doesn't handle inbound requests */
static srtm_status_t SRTM_CameraClient_Request(srtm_service_t service, srtm_request_t request)
{
    return SRTM_Status_ServiceNotFound;
}

/* Unused for client architecture */
static srtm_status_t SRTM_CameraClient_Notify(srtm_service_t service, srtm_notification_t notif)
{
    return SRTM_Status_ServiceNotFound;
}