//
// Created by cfif on 04.10.2022.
//

#include <stddef.h>
#include <SystemDelayInterface.h>
#include <ComInt.h>
#include <CmsisRtosThreadUtils.h>
#include "SerialPort.h"
#include "ComIntCmd/Vars.h"
#include "ComIntCmd/Tests.h"
#include "ComIntCmd/VersionsInfo.h"
#include "ComIntCmd/AccelCalibration.h"
#include "ComIntAmplifier.h"
#include "ComIntCodec.h"
#include "ext_telematica.h"
#include "ComIntThisSubSystem.h"

static void ComInt_LoadMetadata(tComInt *env) {
    env->versions.firmware = StringStaticInit("2.1.7");

    env->versions.board = (tStringStatic) {
            .data = (char *) (HARDWARE_REVISION),
            .length = sizeof(HARDWARE_REVISION) - 1
    };
};

static void ComIntInitRoot(tComInt *env) {
    XfcProtTable_InitStatic(&env->table, env->memAlloc.table);
    tXfcArray rxArr;
    tXfcArray txArr;
    XfcArrayInitStatic(&rxArr, env->memAlloc.rxArr);
    XfcArrayInitStatic(&txArr, env->memAlloc.txArr);
    XfcProtRespondent_Init(&env->service, NULL, &env->table, rxArr, txArr, XFC_STD_MAGIC_NUMBERS);
    ComInt_LoadMetadata(env);
}

static void ComIntInitPing(tComInt *env, tString16 *deviceId, tStringLink *currentModeName) {
    env->ping.device = String16GetLink(deviceId);
    env->ping.board = StringStaticGetLink(&env->versions.board);
    env->ping.mode = currentModeName;
}

static void ComIntInitVersions(tComInt *env, tString16 *deviceId) {

    VersionsInfoTable_InitStatic(&env->versionsTable, env->memAlloc.versions);

    VersionsInfoTable_AddStatic(
            &env->versionsTable, "DEVICE_ID", String16GetLink(deviceId)
    );
    VersionsInfoTable_AddStatic(
            &env->versionsTable, "FIRMWARE", StringStaticGetLink(&env->versions.firmware)
    );
    VersionsInfoTable_AddStatic(
            &env->versionsTable, "BOARD", StringStaticGetLink(&env->versions.board)
    );
}

static void ComIntInitSerialBridges(
        tComInt *env,
        tSerialPortIO *gsmIo,
        tSerialPortIO *gnssIo,
        tSerialPortIO *cliIo
) {
    SerialBridges_InitStatic(&env->serialBridges, env->memAlloc.serialBridge);
    if (gnssIo)SerialBridges_AddStatic(&env->serialBridges, "GNSS", gnssIo);
    if (gsmIo)SerialBridges_AddStatic(&env->serialBridges, "AT_GSM", gsmIo);
    if (cliIo)SerialBridges_AddStatic(&env->serialBridges, "CLI", cliIo);
}

void ComInt_Init(
        tComInt *env,
        tSerialPortIO *io,
        tSerialPortIO *canIo,
        tString16 *deviceId,
        tVariablesTable *varsTab,
        tDeviceTestsTable *tests,
        tSerialPortIO *gsmIo,
        tSerialPortIO *cliIo,
        tSerialPortIO *gnssIo,
        tStringLink *currentModeName,
        tCarFlipDetection *carFlipDetection,
        tAmplifier *Amplifier,
        tAudioCodec *audioCodec,
        tDeviceTesting *tDeviceTesting,
        tPowerManagement *power,
        bool *playMode,
        eSubSystems *subSystem,
        bool *telematicaIsActive,
        bool *telematicaServerIsActive,
        bool *factoryMode
) {
    env->serialPortIo = io;
    env->serialCanPortIo = canIo;

    ComIntInitRoot(env);
    ComIntInitPing(env, deviceId, currentModeName);
    ComIntInitVersions(env, deviceId);
    ComIntInitSerialBridges(env, gsmIo, gnssIo, cliIo);

    XfcProtMethodsInit_AccelCalibration(&env->accelCalibData, carFlipDetection, varsTab);
    XfcProtMethodsAdd_AmplifierInit(&env->Amplifier, Amplifier, playMode);
    XfcProtMethodsAdd_CodecInit(&env->Codec, audioCodec);
    XfcProtMethodsAdd_PowerManagerInit(&env->Power, power, telematicaIsActive, telematicaServerIsActive);
    XfcProtMethodsAdd_SybSystemInit(&env->XfcSybSystem, subSystem);
    XfcProtMethodsAdd_TestInit( &env->TestButton, tDeviceTesting, factoryMode);

    //Добавляем обработчики комманд
    XfcProtMethodsAdd_Mandatory(&env->table, &env->ping, &env->table);
    XfcProtMethodsAdd_VersionsInfo(&env->table, &env->versionsTable);
    XfcProtMethodsAdd_AccelCalibration(&env->table,&env->accelCalibData);
    XfcProtMethodsAdd_Amplifier(&env->table,&env->Amplifier);
    XfcProtMethodsAdd_Codec(&env->table, &env->Codec);
    XfcProtMethodsAdd_Test(&env->table, &env->TestButton);
    XfcProtMethodsAdd_PowerManager(&env->table, &env->Power);
    XfcProtMethodsAdd_SybSystem(&env->table, &env->XfcSybSystem);

    if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
        EXT_ENV_ADR_TELE.tele_func(&env->table, TELE_MODULE_COM_INT);

    if (varsTab) {
        XfcProtMethodsAdd_Vars(&env->table, varsTab);
    }

    XfcProtMethodsAdd_Tests(&env->table, tests);
    XfcProtMethodsAdd_SerialBridge(&env->table, &env->serialBridges);

    //Инициализируем поток
    InitThreadAtrStatic(&env->thread.attr, "ComInt", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
    env->thread.id = 0;
}


static _Noreturn void ComInt_Thread(tComInt *env) {
    uint8_t byte;
    tSerialPortIO *io = NULL;
//    io = env->serialCanPortIo;
    for (;;) {
        if (SerialPortReceive(env->serialPortIo, &byte, 1, 100)) {
            io = env->serialPortIo;
            break;
        }

        if (SerialPortReceive(env->serialCanPortIo, &byte, 1, 100)) {
            io = env->serialCanPortIo;
            break;
        }
    }

    XfcProtRespondent_AddBytes(&env->service, &byte, 1);

    for (;;) {

        if (SerialPortReceive(io, &byte, 1, SystemWaitForever)) {

            XfcProtRespondent_AddBytes(&env->service, &byte, 1);

            while (XfcArrayGetDataSize(env->service.requestDecoder.buffer)) {

                if (XfcProtRespondent_Step(&env->service)) {

                        SerialPortTransmit(
                                io,
                                env->service.responseEncoder.buffer->data,
                                XfcArrayGetDataSize(env->service.responseEncoder.buffer),
                                1000
                        );


                    XfcProtRespondent_SkipCurrentRequest(&env->service);
                } else {
                    break;
                }
            }
        }
    }

/*
        if (SerialPortReceive(env->serialPortIo, &byte, 1, SystemWaitForever)) {

            XfcProtRespondent_AddBytes(&env->service, &byte, 1);

            while (XfcArrayGetDataSize(env->service.requestDecoder.buffer)) {

                if (XfcProtRespondent_Step(&env->service)) {

                    SerialPortTransmit(
                            env->serialPortIo,
                            env->service.responseEncoder.buffer->data,
                            XfcArrayGetDataSize(env->service.responseEncoder.buffer),
                            1000
                    );

                    XfcProtRespondent_SkipCurrentRequest(&env->service);
                } else {
                    break;
                }
            }
        }
    }
    */
}

void ComInt_StartThread(tComInt *env) {
    if (!env->thread.id) {
        env->thread.id = osThreadNew((osThreadFunc_t) (ComInt_Thread), (void *) (env), &env->thread.attr);
    } else {
        osThreadResume(env->thread.id);
    }
}