#include "IR_Encoder.h"
#include "IR_Decoder.h"

#define LoopOut 12
#define ISR_Out 10
#define TestOut 13

IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, IR_Decoder* decPair = nullptr) {
    id = addr;
    this->decPair = decPair;
    signal = noSignal;
    isSending = false;
    #if disablePairDec
    if (decPair != nullptr) {
        blindDecoders = new IR_Decoder * [1] {decPair};
        decodersCount = 1;
    }
    #endif
};
void IR_Encoder::setBlindDecoders(IR_Decoder* decoders [], uint8_t count) {
    #if disablePairDec
    if (blindDecoders != nullptr) delete [] blindDecoders;
    #endif
    decodersCount = count;
    blindDecoders = decoders;
}

IR_Encoder::~IR_Encoder() {
    delete [] bitLow;
    delete [] bitHigh;
};

void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false) {
    if (len > bytePerPack) { return; }
    constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
    memset(sendBuffer, 0x00, dataByteSizeMax);
    uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
    uint8_t msgType =
        ((needAccept ? IR_MSG_DATA_ACCEPT : IR_MSG_DATA_NOACCEPT) << 5) | ((packSize - crcBytes) & IR_MASK_MSG_INFO);

    // формирование массива
    // msg_type
    sendBuffer[0] = msgType;

    // addr_self
    sendBuffer[1] = id >> 8 & 0xFF;
    sendBuffer[2] = id & 0xFF;

    // addr_to
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

    for (uint16_t i = dataStart; i < dataStart + len; i++) {
        sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
    }

    // data crc
    sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF;
    sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF;

    if (decPair != nullptr) {
        decPair->isWaitingAccept = ((msgType >> 5) & IR_MASK_MSG_TYPE == IR_MSG_DATA_ACCEPT);
        if (decPair->isWaitingAccept) {
            decPair->addrWaitingFrom = addrTo;
        }
    }
    // отправка
    rawSend(sendBuffer, packSize);
}

void IR_Encoder::sendACK(uint16_t addrTo, uint8_t addInfo, bool forAll = false) {
    memset(sendBuffer, 0x00, dataByteSizeMax);
    sendBuffer[0] = IR_MSG_ACCEPT << 5;
    sendBuffer[0] |= addInfo & IR_MASK_MSG_INFO;

    // addr_self
    if (!forAll) {
        sendBuffer[1] = id >> 8 & 0xFF;
        sendBuffer[2] = id & 0xFF;
    }

    // data crc
    sendBuffer[3] = crc8(sendBuffer, 0, 3, poly1) & 0xFF;
    sendBuffer[4] = crc8(sendBuffer, 0, 4, poly2) & 0xFF;

    rawSend(sendBuffer, msgBytes + addrBytes + crcBytes);
}

void IR_Encoder::sendRequest(uint16_t addrTo, uint8_t addInfo) {
    memset(sendBuffer, 0x00, dataByteSizeMax);
    sendBuffer[0] = IR_MSG_REQUEST << 5;
    sendBuffer[0] |= addInfo & IR_MASK_MSG_INFO;

    // addr_self
    sendBuffer[1] = id >> 8 & 0xFF;
    sendBuffer[2] = id & 0xFF;

    //addr_to
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

    // data crc
    sendBuffer[5] = crc8(sendBuffer, 0, 5, poly1) & 0xFF;
    sendBuffer[6] = crc8(sendBuffer, 0, 6, poly2) & 0xFF;

    rawSend(sendBuffer, msgBytes + addrBytes + addrBytes + crcBytes);
}

void IR_Encoder::sendBack(uint8_t* data = nullptr, uint8_t len = 0){
    _sendBack(false, 0, data, len);
}

void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len = 0){
    _sendBack(true, addrTo, data, len);
}

void IR_Encoder::_sendBack(bool isAdressed ,uint16_t addrTo,uint8_t* data, uint8_t len){
    if (len > bytePerPack) { return; }
    memset(sendBuffer, 0x00, dataByteSizeMax);
    constexpr uint8_t dataStart = msgBytes + addrBytes;

    uint8_t packSize = msgBytes + addrBytes + len + crcBytes;
    uint8_t msgType =
        (IR_MSG_BACK << 5) | (isAdressed << 4U) | ((packSize - crcBytes) & (IR_MASK_MSG_INFO>>1));

    // формирование массива
    // msg_type
    sendBuffer[0] = msgType;

    // addr_from or data
    sendBuffer[1] = id >> 8 & 0xFF;
    sendBuffer[2] = id & 0xFF;

    // addr_to
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

    for (uint16_t i = dataStart; i < dataStart + len; i++) {
        sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
    }

    // data crc
    sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF;
    sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF;

    // отправка
    rawSend(sendBuffer, packSize);
}

void IR_Encoder::setDecoder_isSending() {
    if (decodersCount) {
        for (uint8_t i = 0; i < decodersCount; i++) {
            blindDecoders[i]->isPairSending ^= id;
        }

    }
}

void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
    if (isSending) {
        //TODO: Обработка повторной отправки
        return;
    }

    setDecoder_isSending();

    cli();
    sendLen = len;
    toggleCounter = preambToggle; // Первая генерация для первого signal

    dataBitCounter = bitPerByte - 1;
    dataByteCounter = 0;

    preambFrontCounter = preambPulse * 2 - 1; // -1 за счёт генерации уже на этапе сразу после инициализации
    dataSequenceCounter = bitPerByte * 2;
    syncSequenceCounter = syncBits * 2;

    signal = preamb;
    isSending = true;
    state = HIGH;

    currentBitSequence = bitHigh;
    isSending = true;
    sei();
}



void IR_Encoder::isr() {
    if (!isSending) return;

    ir_out_virtual = !ir_out_virtual && state;

    if (toggleCounter) {
        toggleCounter--;
    } else {
    IsrStart:
        switch (signal) {
            case noSignal:
                signal = preamb;
                // сброс счетчиков
                // ...
                isSending = false;
                setDecoder_isSending();
                return;
                break;

            case preamb:
                if (preambFrontCounter) {
                    preambFrontCounter--;
                    toggleCounter = preambToggle;   // Вторая и последующие генерации для этого signal
                } else {// Конец преамбулы, переход на следующий signal
                    signal = data;
                    state = !LOW;                   // Инверсное состояние первой генерации следующего signal
                    goto IsrStart;                  // Применение новых параметров в этй же итерации прерывания
                }

                break;

            case data:
                if (dataSequenceCounter) {
                    if (!(dataSequenceCounter & 1U)) { // если чётный - смена бита
                        currentBitSequence = ((sendBuffer[dataByteCounter] >> dataBitCounter) & 1U) ? bitHigh : bitLow; // определение текущего бита
                        dataBitCounter--;
                    }
                    toggleCounter = currentBitSequence[!state];
                    dataSequenceCounter--;
                } else {                            // Конец data, переход на следующий signal
                    syncLastBit = ((sendBuffer[dataByteCounter]) & 1U);
                    dataByteCounter++;
                    dataBitCounter = bitPerByte - 1;
                    dataSequenceCounter = bitPerByte * 2;
                    signal = sync;
                    goto IsrStart;                  // Применение новых параметров в этй же итерации прерывания
                }
                break;

            case sync:
                if (syncSequenceCounter) {
                    if (!(syncSequenceCounter & 1U)) { // если чётный - смена бита
                        if (syncSequenceCounter == 2) { // Если последний бит
                            currentBitSequence = ((sendBuffer[dataByteCounter]) & 0b10000000) ? bitLow : bitHigh;
                        } else {
                            currentBitSequence = syncLastBit ? bitLow : bitHigh; // определение текущего бита
                            syncLastBit = !syncLastBit;
                        }
                    }
                    toggleCounter = currentBitSequence[!state];
                    syncSequenceCounter--;
                } else {                            // Конец sync, переход на следующий signal
                    signal = data;
                    syncSequenceCounter = syncBits * 2;

                    if (dataByteCounter >= sendLen) { // определение конца данных
                        signal = noSignal;
                    }
                    goto IsrStart;                  // Применение новых параметров в этй же итерации прерывания
                }
                break;

            default:
                return;
                break;
        }

        state = !state;
    }
}





void old() {///////////////////////////////////////////////////////
    // void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
    //     /*tmp*/bool LOW_FIRST = false;/*tmp*/

    //     if (decoders != nullptr) { decoders->isPairSending = true; }

    //     bool prev = 1;
    //     bool next;

    //     send_EMPTY(preambPulse); // преамбула
    //     for (uint16_t byteNum = 0; byteNum < len; byteNum++) {
    //         sendByte(ptr[byteNum], &prev, LOW_FIRST);
    //         if (byteNum < len - 1) {
    //             next = ptr[byteNum + 1] & (LOW_FIRST ? 0b00000001 : 0b10000000);
    //         } else {
    //             next = 0;
    //         }
    //         addSync(&prev, &next);
    //     }

    //     if (decoders != nullptr) { decoders->isPairSending = false; }

    // }
}

void IR_Encoder::sendByte(uint8_t byte, bool* prev, bool LOW_FIRST) {
    uint8_t mask = LOW_FIRST ? 0b00000001 : 0b10000000;
    for (uint8_t bitShift = 8; bitShift; bitShift--) {
        digitalWrite(9, HIGH);
        digitalWrite(9, LOW);
        byte& mask ? send_HIGH(prev) : send_LOW();
        *prev = byte & mask;
        LOW_FIRST ? mask <<= 1 : mask >>= 1;
        digitalWrite(9, HIGH);
        digitalWrite(9, LOW);
    }
}

void IR_Encoder::addSync(bool* prev, bool* next) {
    switch (syncBits) {
        case 0: break;
        case 1:
            *prev ? send_LOW() : send_HIGH();
            *prev = !*prev;
            break;
        default:
            for (int16_t i = 0; i < syncBits - 1; i++) {
                *prev ? send_LOW() : send_HIGH();
                *prev = !*prev;
            }
            *next ? send_LOW() : send_HIGH(0);
            *prev = !*next;
            break;
    }
}

void IR_Encoder::send_HIGH(bool prevBite = 1) {

    // if (/* prevBite */1) {
    //     meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
    //     meanderBlock(bitActiveTakts, halfPeriod, HIGH);
    // } else {                                                    // более короткий HIGH после нуля
    //     meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
    //     meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
    // }

}

void IR_Encoder::send_LOW() {
    // meanderBlock(bitPauseTakts, halfPeriod, LOW);
    // meanderBlock(bitActiveTakts, halfPeriod, LOW);
    // meanderBlock(bitPauseTakts, halfPeriod, HIGH);
}

void IR_Encoder::send_EMPTY(uint8_t count) {
    // for (size_t i = 0; i < count * 2; i++) {
        // meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
    //     prevPreambBit = !prevPreambBit;
    // }
    // meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
}