/* the arPhy physical layer */

#include <string.h>
#include <stdint.h>

#include "../../net/net.h" // necessario? vedi net_generate_block

#include "../phy.h"
#include "arphy.h"

#include "../../modem/modem_types.h"


// encoda un po di data in un buffer di simboli, torna il numero di simboli encodati

uint8_t arphy_data2symbol(uint8_t *InData, uint8_t *ModulationSymbolsBuffer) {
    uint8_t FEC_index = 0, data_chunk = 0;
    uint8_t i;
    uint16_t bit_index;

    // pulisci buffer simboli - necessario
    memset(ModulationSymbolsBuffer, 0, interleaver.size);

    // cicla i fec contenuti in un blocco di interleave
    for (FEC_index = 0; FEC_index < interleaver.fec_blocks_size; FEC_index++) {
        // spezza dati in pezzi grandi come il netto di un FEC
        data_chunk = phy_data_to_chunk(InData, FEC_index, fec.in_bit_size, 0);

        // pulisci buffer matrice di hadamard
        memset(tx_FHT_Buffer, 0, MAX_FEC_OUTPUT_SIZE);

        // encoda chunk in matrice FEC
        arphy_FEC_encode(data_chunk, fec.in_bit_size, tx_FHT_Buffer);

        // dispone matrice FEC nella costellazione
        for (i = 0; i < fec.out_bit_size; i++) {
            bit_index = (FEC_index * fec.out_bit_size) + i;

            // rimappa
            if (interleaver.type == ARPHY_INTERLEAVER_TYPE_HELIX) {
                bit_index = arphy_index_interleave(bit_index, mod.bits_per_symbol, interleaver.symbols_size);
            } else if (interleaver.type == ARPHY_INTERLEAVER_TYPE_NONE) {
                // nulla
            }


            phy_bit_to_constellation(tx_FHT_Buffer[i], bit_index, ModulationSymbolsBuffer, mod.bits_per_symbol, interleaver.symbols_size);
        }
    }
    return interleaver.symbols_size;
}

// torna bytes dati encodati

uint8_t arphy_symbol2data(uint8_t *OutData, uint8_t *ModulationSymbolsBuffer) {
    uint8_t FECIndex = 0, Chunk = 0;
    uint8_t i;
    uint16_t bit_index;
    for (FECIndex = 0; FECIndex < interleaver.fec_blocks_size; FECIndex++) {
        // pulisci buffer matrice
        memset(rx_FHT_Buffer, 0, MAX_FEC_OUTPUT_SIZE);

        // estrae il binario dalla costellazione e lo mette in matrice
        for (i = 0; i < fec.out_bit_size; i++) {
            bit_index = (FECIndex * fec.out_bit_size) + i;
            // interfoglia!
            if (interleaver.type == ARPHY_INTERLEAVER_TYPE_HELIX) {
                bit_index = arphy_index_deinterleave(bit_index, mod.bits_per_symbol, interleaver.symbols_size);
            } else if (interleaver.type == ARPHY_INTERLEAVER_TYPE_NONE) {
                // nulla
            }

            rx_FHT_Buffer[i] = phy_constellation_to_bit(bit_index, ModulationSymbolsBuffer, mod.bits_per_symbol, interleaver.symbols_size);
        }

        // decodifica il FEC in-place e torna i dati puliti
        Chunk = arphy_FEC_decode(rx_FHT_Buffer);

        // aggrega i chunk su OutData
        phy_chunk_to_data(OutData, FECIndex, fec.in_bit_size, 0, Chunk);
    }
    return interleaver.net_bit_size / 8;
}

uint8_t arphy_generate_symbol_buffer(uint8_t *SymbolBuffer) {
    uint8_t out_symbols = 0;
    uint8_t BlockBuffer[4];
    net_generate_block(BlockBuffer, phy_block_buffer_size);
    out_symbols = arphy_data2symbol(BlockBuffer, SymbolBuffer);

    return out_symbols;
}