//
// Created by xemon on 05.05.2022.
//

#include <XfcProtResponseCodes.h>
#include <stddef.h>
#include "XfcProtListener.h"


void XfcProtListener_Reset(tXfcProtListener *env) {
    XfcArrayClear(&env->requestBuffer);
}

void XfcProtListener_Init(
        tXfcProtListener *env,

        void *commonArgs,
        tXfcProtTable *processors,

        tXfcArray requestBuffer,
        uint8_t requestMagic
) {
    env->commonArgs = commonArgs;
    env->processors = processors;

    env->requestBuffer = requestBuffer;
    env->requestDecoder.magic = requestMagic;
    env->requestDecoder.buffer = &env->requestBuffer;

    XfcProtListener_Reset(env);
}


void XfcTransPackServiceListenerAddByte(tXfcProtListener *env, uint8_t byte) {
    if (XfcArrayAddByte(&env->requestBuffer, byte)) {
        ENV_COUNTER_INC(rx)
    } else {
        ENV_COUNTER_INC(rx_skip)
    }
}

void XfcProtListener_AddBytes(tXfcProtListener *env, uint8_t *bytes, uint16_t size) {
    for (uint8_t *end = bytes + size; end > bytes; ++bytes) {
        XfcTransPackServiceListenerAddByte(env, *bytes);
    }
}

void XfcProtListener_SkipToNextMagic(tXfcProtListener *env, uint16_t begin) {

    uint16_t skip = XfcTransPackDecoderNextMagicFrom(&env->requestDecoder, begin);

    XfcArrayRemoveBytesFront(&env->requestBuffer, skip);

//    ENV_COUNTER_ADD(rx_skip, nextMagic)
}

bool XfcProtListener_isValidHeader(tXfcProtListener *env) {
    return XfcArrayGetDataSize(&env->requestBuffer) &&
           XfcTransPackDecoderIsStartsWithMagick(&env->requestDecoder) &&
           XfcTransPackDecoderHasHeader(&env->requestDecoder);
}

bool XfcProtListener_HasPacket(tXfcProtListener *env) {


    while (XfcArrayGetDataSize(&env->requestBuffer)) {

        if (!XfcTransPackDecoderIsStartsWithMagick(&env->requestDecoder)) {
            XfcProtListener_SkipToNextMagic(env, 1);
            continue;
        }


        if (!XfcTransPackDecoderHasHeader(&env->requestDecoder)) {
            return false;
        }

        if (XfcTransPackDecoderGetRequiredFullPackLength(&env->requestDecoder) >
            env->requestBuffer.limit) {

            ////Packet size bigger than buffer
            XfcProtListener_SkipToNextMagic(env, 1);
            continue;

        }

        if (!XfcTransPackDecoderHasRequiredLength(&env->requestDecoder)) {
            return false;
        }

        if (XfcTransPackDecoderIsCrcCorrect(&env->requestDecoder)) {
            return true;
        } else {
            XfcProtListener_SkipToNextMagic(env, 1);
            continue;
        }

    }

    return false;
}


void XfcTransPackServiceListenerProcessRequest(tXfcProtListener *env) {

    uint8_t packId = XfcTransPackDecoderGetId(&env->requestDecoder);

    tXfcArray requestData = XfcTransPackDecoderGetDataSegmentAsArray(&env->requestDecoder);

    tXfcProtProcessor *proc = XfcProtTable_GetForId(env->processors, packId);
    if (proc) {

        void *args = proc->args ? proc->args : env->commonArgs;
        proc->process(&requestData, NULL, args);

    }
}

void XfcProtListener_SkipCurrentRequest(tXfcProtListener *env) {
    XfcProtListener_SkipToNextMagic(env, XfcTransPackDecoderGetRequiredFullPackLength(&env->requestDecoder));
}

bool XfcProtListener_Step(tXfcProtListener *env) {


    if (XfcProtListener_HasPacket(env)) {
        XfcTransPackServiceListenerProcessRequest(env);
        return true;
    }

    return false;
}