# include <string>
# include <iostream>
#include <libsocket/exception.hpp>
#include <libsocket/unixclientstream.hpp>
#include <unistd.h>
#include <chrono>
#include "json.hpp"
#include <complex>
#include <fstream>
#include <math.h>
# include <csignal>

#define DEBUG
#define RMSHALF_LENGHT  24
#define WAVEFORM_LENGHT  2048
#define CHANNELS_NUMBER  7
#define BUFFER_SIZE 500000UL

using namespace std;
using namespace nlohmann;
using libsocket::unix_stream_client;
using std::string;


/*  [MessagePackObject]
    public class ProtocolStructTemplate
    {
        [Key("BID")]
        public UInt16 BlockNumber;

        [Key("Time")]
        public UInt64 TimeStamp;

        [Key("Hz")]
        public Single Frequency;

        [Key("CH")]
        public ProtocolChannelTemplate[] Channels;
    }

    [MessagePackObject]
    public class ProtocolChannelTemplate
    {
        [Key("RMS12")]
        public Single RMS12; // Valor RMS 12 ciclos: float, 4 bytes;

        [Key("THD12")]
        public Single THD12; // Valor THD 12 ciclos: float, 4 bytes;

        [Key("RMSH")]
        public Single[] RMSHalf; // 24 valores RMS de ½ ciclo: float, 4 bytes cada;
        // Dados da forma de onda
        [Key("Wave")]
        public UInt16[] Waveform; //  Forma de onda: array de 2048 x 2 bytes para cada canal;
        // Dados de FFT após dizimação
        [Key("FFTIndex")]
        public UInt16[] FFTIndex; // N índices: inteiro, 2 bytes * N;
        [Key("FFTR")]
        public Single[] FFTReal; // N valores reais: float, 4 bytes * N;
        [Key("FFTI")]
        public Single[] FFTImaginary; // N valores imaginários: float, 4 bytes * N.
    }
*/

struct Channel
{
    float RMS12;
    float THD12;
    uint16_t RMSHSize;
    float *RMSH;

    int16_t WaveformSize;
    int16_t *Waveform;

    uint16_t FFTSize;
    uint16_t *FFTIndex;
    float *FFTReal;
    float *FFTImaginary;
};

struct Protocol
{
    uint16_t BlockID;
    uint64_t TimeStamp;
    float Frequency;
    struct Channel Channels[CHANNELS_NUMBER];
    ulong deltaTime;
    int operationMode;   //0-registro, 1-adaptativos, 2-cálculos
    int OperationOption; //0-detalhe, 1-normal, 2-mínimo, 3-custo1, 4-custo2, 5-custo3, 6-qualidade/custo
    float ThresholdVoltage;
    float ThresholdCurrent;
    uint16_t QualimetroID;
} ProtocolData;

vector<uint16_t> FFTIndex[CHANNELS_NUMBER];
vector<float> FFTReal[CHANNELS_NUMBER];
vector<float> FFTImag[CHANNELS_NUMBER];
vector<int16_t> Waveform[CHANNELS_NUMBER];
vector<float> RMSH[CHANNELS_NUMBER];
vector<float> Calibration[CHANNELS_NUMBER];

unix_stream_client *Socket;

const int MAX_SPARSE_SIZE = 256;
const int N_CHAN = 7;
const int VECTOR_SIZE = 1024;
const int MAX_SIZE = 682; //4096 (amostras) / 6 (bytes, tamanho da FFT no arquivo para cada raia - index, real e imag)

int num_of_bins_changed[N_CHAN];
int c = 0;
int w = 5; //quantas amostras para esquerda e direita
float m = (0.1/100.0); //delta em amplitude

complex<float> Ref[N_CHAN][VECTOR_SIZE];
float magRef[N_CHAN][VECTOR_SIZE];
complex<float> New[N_CHAN][VECTOR_SIZE];
float magNew[N_CHAN][VECTOR_SIZE];
float maxMagnitude;
int16_t RefWave[4][WAVEFORM_LENGHT];

int16_t indexChanged[N_CHAN][MAX_SIZE];

float epsilon_perc = 0.0001;     // percentual da raia máxima abaixo da qual as raias são zeradas
float maximo_erro_perc = 0.005;  // máximo erro percentual permitido

bool fixed_ratio = false;
bool reference_fft = false;
bool reference_current = false;
int no_change = 0;
uint16_t last_block = 0;
bool create_file = true;
bool flag_finish = false;
bool flag_shutdown = false;

uint32_t segmento;
uint32_t aquisicao;
string path = "/media/extern/CompressionFiles/";
string pathDebug = "/media/extern/CompressionFiles/Debug/";

//arquivos de compressão
std::ofstream comp_file_v1;
std::ofstream comp_file_v2;
std::ofstream comp_file_v3;
std::ofstream comp_file_i1;
std::ofstream comp_file_i2;
std::ofstream comp_file_i3;
std::ofstream comp_file_in;
std::ofstream comp_atual;
std::ofstream timestamp_file;

//arquivos para debug das formas de onda
std::ofstream wave_file_v1;
std::ofstream wave_file_v2;
std::ofstream wave_file_v3;
std::ofstream wave_file_i1;
std::ofstream wave_file_i2;
std::ofstream wave_file_i3;
std::ofstream wave_file_in;
std::ofstream wave_file;
std::ofstream timestamp_aux;

int compression(struct Protocol &CompressionData);
void my_qsort(void *base, uint16_t *base_idx, uint16_t nmemb);
inline static void swap_int(uint16_t *src, uint16_t *dest);
inline static void swap_float(float *src, float *dest);
void selectFile();
void changeFile();

void int_handler(int x)
{
    // Setal flag para finalizar arquivo no próximo processamento de bloco
    flag_shutdown = true;

}

int main(void)
{
    signal(SIGINT, int_handler);   // Registra evento para tratar sinal
    signal(SIGQUIT, int_handler);
    signal(SIGHUP, int_handler);
    signal(SIGTERM, int_handler);
//  signal(SIGKILL, int_handler);

    string path = "/tmp/protocol.sock";

    // Ler arquivo json para obter informações da aquisição e do segmento
    json j;  // cria objeto json
    std::ifstream i("/home/ubuntu/compression/compression.json");   //Usar try e catch neste segmento caso não houver arquivo ou seu conteúdo for vazio.
    i >> j;
    aquisicao = j["aquisicao"].get<uint32_t>();
    segmento = j["segmento"].get<uint32_t>();
    i.close();  // Fecha Arquivo

    cout << "Aquisicao: " << aquisicao << endl;
    cout << "Segmento: " << segmento << endl;

    char *answer = new char[BUFFER_SIZE];

INIT:
    try
    {
        Socket = new unix_stream_client(path);
    }
    catch (const libsocket::socket_exception& exc)
    {
        std::cerr << exc.mesg;
   std::cout << "Retryng reconnection " << std::endl;
   sleep(1);
   goto INIT;
    }

    while (true)
    {

        usleep(1000);
        int size;
        try
        {
            size = Socket->rcv(answer, BUFFER_SIZE);
        }
        catch (const std::exception&)
        {

        }

    if(size==0) {
      sleep(1);
      std::cout << "Retryng reconnection " << std::endl;
      goto INIT;
    }

#ifdef DEBUG
        cout << "Bytes: " << size << endl;
        auto start = std::chrono::high_resolution_clock::now();
#endif



        std::vector<char> vec(answer, answer + size);

        json protocol;

        try
        {
            usleep(1000);
            protocol = json::from_msgpack(vec);

            if (protocol.is_object())
            {
                try
                {
                    ProtocolData.BlockID = protocol["BID"].get<uint16_t>();
                    ProtocolData.TimeStamp = protocol["Time"].get<uint64_t>();
                    ProtocolData.Frequency = protocol["Hz"].get<float>();
                    ProtocolData.QualimetroID = protocol["QID"].get<uint16_t>();

                    json channels = protocol["CH"];
                    uint8_t channelsNumber = channels.size();

                    for (uint8_t i = 0; i < channelsNumber; i++)
                    {
                        json currentChannel = channels[i];

                        //ProtocolData.Channels[i].RMS12 = currentChannel["RMS12"].get<float>();
                        //ProtocolData.Channels[i].THD12 = currentChannel["THD12"].get<float>();

                        //RMSH[i] = currentChannel["RMSH"].get<vector<float>>();
                        //ProtocolData.Channels[i].RMSHSize = RMSH[i].size();
                        //ProtocolData.Channels[i].RMSH = RMSH[i].data();

                        json Wave = currentChannel.at("Wave");

                        if (!Wave.is_null())
                        {
                            Waveform[i] = Wave.get<vector<int16_t>>();
                            ProtocolData.Channels[i].WaveformSize = Waveform[i].size();
                            ProtocolData.Channels[i].Waveform = Waveform[i].data();
                        }
                        else
                        {
                            ProtocolData.Channels[i].WaveformSize = 0;
                        }

                        json FFT = currentChannel.at("FFTIndex");

                        if (!FFT.is_null())
                        {
                            FFTIndex[i] = FFT.get<vector<uint16_t>>();
                            ProtocolData.Channels[i].FFTSize = FFTIndex[i].size();

                            ProtocolData.Channels[i].FFTIndex = FFTIndex[i].data();

                            FFTReal[i] = currentChannel["FFTR"].get<vector<float>>();
                            ProtocolData.Channels[i].FFTReal = FFTReal[i].data();

                            FFTImag[i] = currentChannel["FFTI"].get<vector<float>>();
                            ProtocolData.Channels[i].FFTImaginary = FFTImag[i].data();
                        }
                        else
                        {
                            ProtocolData.Channels[i].FFTSize = 0;
                        }

                        Calibration[i] = protocol["CL"].get<vector<float>>();
                    }
                    ProtocolData.operationMode = protocol["OM"].get<int>();
                    ProtocolData.OperationOption = protocol["OO"].get<int>();
                    ProtocolData.ThresholdVoltage = protocol["THV"].get<float>();
                    ProtocolData.ThresholdCurrent = protocol["THI"].get<float>();
                    ProtocolData.deltaTime = protocol["DT"].get<ulong>();

                    compression(ProtocolData);

#ifdef DEBUG

                    auto elapsed = std::chrono::high_resolution_clock::now() - start;
                    long long microseconds = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
                    cout << "Processing time: " << microseconds << " us" << endl;
                    cout << "-------------------\n";
#endif
                }
                catch (const std::exception&)
                {
                    cout << "Parsing Error" << endl;
                }
            }
            else
            {
                cout << "Parsing Error" << endl;
            }
        }
        catch (const std::exception&)
        {
        }
    }
    return 0;
}

//******************************************************************************
// Troca valores em ponto flutuante
//------------------------------------------------------------------------------
inline static void swap_float(float *src, float *dest)
{
    float temp = *src;
    *src  = *dest;
    *dest = temp;
}

//******************************************************************************
// Troca valores inteiros
//------------------------------------------------------------------------------

inline static void swap_int(uint16_t *src, uint16_t *dest)
{
    int temp = *src;
    *src = *dest;
    *dest = temp;
}

//******************************************************************************
//  Realiza Quicksort
//------------------------------------------------------------------------------

void my_qsort(void *base, uint16_t *base_idx, uint16_t nmemb)
{
    uint16_t  *basep = (uint16_t *)base; /* POINTER TO ARRAY OF ELEMENTS */
    uint16_t  *basei = base_idx; /* POINTER TO ARRAY OF ELEMENTS */
    uint16_t  i = 0; /* left scan index  */
    uint16_t  j = 2 * (nmemb - 1); /* right scan index */
    uint16_t  pivot = nmemb & 0xFFFE; /* Want closest even value */
    uint16_t  *pivp = basep + pivot;

    if (nmemb <= 1) return;

    while (i < j)
    {
        while (*(float*)(basep + i) > *(float*)pivp) i = i + 2;
        while (*(float*)(basep + j) < *(float*)pivp) j = j - 2;

        if (i < j)
        {
            swap_float((float*)(basep + i), (float*)(basep + j));
            swap_int((uint16_t*)(basei + (i >> 1)), (uint16_t*)(basei + (j >> 1)));

            if (pivot == i) { pivot = j; pivp = basep + pivot; }
            else if (pivot == j) { pivot = i; pivp = basep + pivot; }
            i = i + 2; j = j - 2;
        }
        else if (i == j) { i = i + 2; j = j - 2; break; }
    }

    if (j > 0) my_qsort(basep, basei, (j >> 1) + 1);
    if ((i >> 1) < nmemb - 1) my_qsort(basep + i, basei + (i >> 1), nmemb - (i >> 1));
}

//******************************************************************************
//  Zera vetor full
//------------------------------------------------------------------------------
void clear_full_vector(complex <float> * vetor)
{
    for (int i = 0; i < VECTOR_SIZE; i++)
    {
        vetor[i] = 0.0;
    }
}

//******************************************************************************
//  Cria vetor full a partir dos vetores recebidos pelo protocolo
//------------------------------------------------------------------------------
void create_full_vector(complex <float> * vetor, float real_full_vector[], float img_full_vector[], uint16_t ind[], uint16_t size)
{
    clear_full_vector(vetor);
    for (int i = 0; i < size; i++)
    {
        vetor[ind[i]] = complex <float>(real_full_vector[i], img_full_vector[i]);
    }
}

//******************************************************************************
//  Calcula valor rms
//------------------------------------------------------------------------------
float rmsf(float vetor[])
{
    float rms = 0;
    float reg;

    for (int j = 0; j < VECTOR_SIZE; j++)
    {
        rms += vetor[j] * vetor[j];
    }
    reg = sqrtf(rms);
    return reg;
}

//******************************************************************************
//  Compressão, retorna número de raias que mudaram
//------------------------------------------------------------------------------
int compress_diff(complex <float> * ref_vector, complex <float> * new_vector, int16_t * index)
{
    float maximo_erro;
    float erro, errot, sub;

    //vetor dif completo
    float Diff_full[VECTOR_SIZE];
    //variáveis vetor dif esparso
    float diff[VECTOR_SIZE];
    uint16_t diffIndex[VECTOR_SIZE];
    uint16_t sizeDiff;

    //calcular diferença entre Ref e New
    for(int i = 0 ; i < VECTOR_SIZE ; i++)
    {
        complex<float> dif = ref_vector[i] - new_vector[i];
        Diff_full[i] = abs(dif);
    }

    //zerar vetor diff
    sizeDiff = 0;
    for (int i = 0; i < VECTOR_SIZE; i++)
    {
        diff[i] = 0;
    }

    //Preencher vetor diff apenas com os valores que não estão zerados
    for(int i = 0 ; i < VECTOR_SIZE ; i++)
    {
        if (Diff_full[i])
        {
            diff[sizeDiff] = Diff_full[i];
            diffIndex[sizeDiff] = i;
            sizeDiff++;
        }
    }

    // Realiza Quicksort
    my_qsort(diff, diffIndex, sizeDiff);

    if (!fixed_ratio) // sem taxa fixa
    {
        maximo_erro = maxMagnitude * maximo_erro_perc;
        erro = rmsf(Diff_full);

        if (erro < maximo_erro)
            return 0;

        errot = erro;

        for (int j = 0; j < MAX_SIZE; j++)
        {
            ref_vector[diffIndex[j]] = new_vector[diffIndex[j]];
            sub = Diff_full[diffIndex[j]];
            errot = sqrtf(errot * errot - sub * sub);

            //guardar qual o índica que foi alterado
            index[j] = diffIndex[j];
            //cout << "Ind: " << index[j] << endl;

            if(errot < maximo_erro)
                return j;
        }

        return -1;
    }
    else //com taxa fixa
    {
        for (int j = 0; j < MAX_SIZE; j++)
        {
            ref_vector[diffIndex[j]] = new_vector[diffIndex[j]];
            sub = Diff_full[diffIndex[j]];

            //guardar qual o índica que foi alterado
            index[j] = diffIndex[j];
        }
        return MAX_SIZE;
    }
}

//******************************************************************************
//  Compressão, diferença da forma de onda
//------------------------------------------------------------------------------
int compress_waveform(int16_t * ref_wave, int16_t * new_wave)
{
    float excursao = 0;
    float limtop[WAVEFORM_LENGHT];
    float limbot[WAVEFORM_LENGHT];
    float lsup[WAVEFORM_LENGHT];
    float linf[WAVEFORM_LENGHT];
    int indleft = 0;
    int indright = 0;
    float metrica = 0;

    //calcular média da referência
    for (int i = 0; i < WAVEFORM_LENGHT-1; i++)
    {
        excursao += abs(ref_wave[i + 1] - ref_wave[i]);
    }

    metrica = m * excursao;

    for (int i = 0; i < WAVEFORM_LENGHT; i++)
    {
        limtop[i] = ref_wave[i] + metrica;
        limbot[i] = ref_wave[i] - metrica ;
    }

    //calcular limites
    for (int i = 0; i < WAVEFORM_LENGHT; i++)
    {
        //encontrar limite da esquerda
        if (i - w > 0)
            indleft = i - w;
        else
            indleft = 0;

        //encontrar limite da direita
        if(i + w < WAVEFORM_LENGHT)
            indright = i + w;
        else
            indright = WAVEFORM_LENGHT-1;

        //encontrar máximo no intervalo
        float maximo = limtop[indleft];
        for (int j = indleft; j < indright+1; j++)
        {
            if (limtop[j] > maximo)
                maximo = limtop[j];
        }

        //encontrar mínimo no intervalo
        float minimo = limbot[indleft];
        for (int j = indleft; j < indright+1; j++)
        {
            if (limbot[j] < minimo)
                minimo = limbot[j];
        }

        lsup[i] = maximo;
        linf[i] = minimo;
    }

    //condições de violação
    //verificar se algum valor da referência é maior que lsup, ou menor que linf
    //se não for, o sinal novo é cópia suficiente da referência
    //caso contrário, enviar forma de onda completa
    for (int i = 0; i < WAVEFORM_LENGHT; i++)
    {
        if (new_wave[i] > lsup[i])
            return 0;

        if (new_wave[i] < linf[i])
            return 0;
    }

    return 1;

}

int16_t onda[WAVEFORM_LENGHT];
int16_t blockNumber = 0;  //1 a 1500 em cada arquivo
bool flag_save_waveform = true;

const std::string currentDateTime() {
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%d-%m-%Y.%X", &tstruct);

    return buf;
}

//******************************************************************************
//  Encontra diferenças entre referência e novo e gera arquivo de compressão
//------------------------------------------------------------------------------
int compression(struct Protocol &CompressionData)
{
    blockNumber++;

    if (flag_finish)
        blockNumber += 3000;

    cout << "Packet ID: " << blockNumber << endl;
    cout << "Frequency: " << CompressionData.Frequency << endl;
    cout << "TimeStamp: " << CompressionData.TimeStamp << endl;
    cout << "Delta Time: " << CompressionData.deltaTime << endl;

    cout << "Operation mode: " << CompressionData.operationMode << endl;
    cout << "Operation option: " << CompressionData.OperationOption << endl;
    cout << "Threshold voltage: " << CompressionData.ThresholdVoltage << endl;
    cout << "Threshold current: " << CompressionData.ThresholdCurrent << endl;

    //cout << "currentDateTime()=" << currentDateTime() << endl;

    if (!reference_fft) //se o sistema ainda não tem referência
    {
        reference_fft = true;

        //zerar referência no início
        for(int j = 0 ; j < CHANNELS_NUMBER ; j++)
        {
            for (int i = 0; i < VECTOR_SIZE; i++)
            {
                Ref[j][i] = 0;
                magRef[j][i] = 0;
            }
        }
    }

    //Transformar timestamp para string
    ostringstream ostr;
    ostr << CompressionData.TimeStamp;
    string timestampString = ostr.str();

    //Criar arquivos
    if(create_file)
    {
        create_file = false;

        cout << "Gerar arquivos" << endl;
        cout << "currentDateTime()=" << currentDateTime() << endl;

        segmento++;

        char s[25];
        sprintf(s, ".%07d.%07d", aquisicao, segmento);
        cout << s << endl;

        char q[5];
        sprintf(q, "%03d", ProtocolData.QualimetroID);
        cout << "Qualimetro: " << q << endl;

        comp_file_v1.open(path + timestampString + s + ".01." + q + ".bin", ios::binary | ios::app);       //arquivo compressao
        comp_file_v2.open(path + timestampString + s + ".02." + q + ".bin", ios::binary | ios::app);       //arquivo compressao
        comp_file_v3.open(path + timestampString + s + ".03." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
        comp_file_i1.open(path + timestampString + s + ".04." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
        comp_file_i2.open(path + timestampString + s + ".05." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
        comp_file_i3.open(path + timestampString + s + ".06." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
        comp_file_in.open(path + timestampString + s + ".07." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
        timestamp_file.open(path + timestampString + s + ".08." + q + ".bin", ios::app);                    //arquivo delta timestamp

        if(flag_save_waveform)
        {
            wave_file_v1.open(pathDebug + timestampString + s + ".01_wave_v1.bin", ios::binary | ios::app);      //arquivo forma de onda
            wave_file_v2.open(pathDebug + timestampString + s + ".02_wave_v2.bin", ios::binary | ios::app);        //arquivo forma de onda
            wave_file_v3.open(pathDebug + timestampString + s + ".03_wave_v3.bin", ios::binary | ios::app);        //arquivo forma de onda
            wave_file_i1.open(pathDebug + timestampString + s + ".04_wave_i1.bin", ios::binary | ios::app);        //arquivo forma de onda
            wave_file_i2.open(pathDebug + timestampString + s + ".05_wave_i2.bin", ios::binary | ios::app);        //arquivo forma de onda
            wave_file_i3.open(pathDebug + timestampString + s + ".06_wave_i3.bin", ios::binary | ios::app);        //arquivo forma de onda
            wave_file_in.open(pathDebug + timestampString + s + ".07_wave_in.bin", ios::binary | ios::app);        //arquivo forma de onda
            timestamp_aux.open(pathDebug + timestampString + s + "_timestamp.txt", ios::binary | ios::app);      //arquivo auxiliar de timestamp completo
        }
    }

    long calc_delta = (CompressionData.deltaTime - 200000);
    int delta = trunc(calc_delta / 100);
    cout << "Delta: " << delta << endl;

    if (blockNumber > 1)
    {
        timestamp_file.write((const char *)(&delta), sizeof(int8_t));
        timestamp_file.flush();

        //timestamp_aux.write((const char *)(&calc_delta), sizeof(long));
        timestamp_aux << CompressionData.TimeStamp << "\n";
        timestamp_aux.flush();
    }

    c = 0;
    while (c < 7) //percorrer todos os canais
    {
        cout << "Canal: " << c << endl;

        //zerar nível dc da FFT
        CompressionData.Channels[c].FFTReal[0] = 0;
        CompressionData.Channels[c].FFTImaginary[0] = 0;

        selectFile();   //atribuir para o comp_atual em qual arquivo deve salvar

        //escrever arquivo da forma de onda, para debug
        wave_file.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
        wave_file.flush();

        if(c < 3)
        {
            //calcular magnitude máxima da referência
            maxMagnitude =  abs(Ref[c][0]);
            for (int i = 0; i < VECTOR_SIZE; i++)
            {
                magRef[c][i] = abs(Ref[c][i]);
                if (magRef[c][i] > maxMagnitude)
                    maxMagnitude = magRef[c][i];
            }

            //criar vetor New
            create_full_vector(New[c], CompressionData.Channels[c].FFTReal, CompressionData.Channels[c].FFTImaginary, CompressionData.Channels[c].FFTIndex, CompressionData.Channels[c].FFTSize);

            //calcular valor de epsilon
            float epsilon = maxMagnitude * epsilon_perc;

            //calcular magnitudes do vetor new
            for(int i = 0 ; i < VECTOR_SIZE ; i++)
            {
                magNew[c][i] = abs(New[c][i]);
                if (magNew[c][i] < epsilon) //se magnitude for menor que valor, zerar valores da raia
                    {
                        New[c][i].real(0);
                        New[c][i].imag(0);
                        magNew[c][i] = 0;
                    }
            }

            //realiza compressão e calcula quantas raias mudaram
            num_of_bins_changed[c] = compress_diff(Ref[c], New[c], indexChanged[c]);

            cout << "Changed: " << num_of_bins_changed[c] << endl;

            /*****  IGUAL A REFERÊNCIA  *****/
            if (num_of_bins_changed[c] == 0)
            {
                cout << "Nao mudou" << endl;

                if (blockNumber >= 3000) //está finalizando arquivo, escrever número do bloco e 0 no tamanho
                {
                    //Escrever número do bloco no arquivo
                    comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));

                    uint16_t size = 0;
                    //Escrever quantidade de raias
                    comp_atual.write((const char *)(&size), sizeof(uint16_t));

                }

            }
            /*****  MUDOU ALGUMAS RAIAS  *****/
            else if(num_of_bins_changed[c] > 0)
            {
                cout << "Mudou" << endl;

                //Escrever número do bloco no arquivo
                comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));

                //Escrever quantidade de raias
                comp_atual.write((const char *)(&num_of_bins_changed[c]), sizeof(uint16_t));

                //Escrever Index
                comp_atual.write((const char *)(&indexChanged[c]), num_of_bins_changed[c] * sizeof(uint16_t));

                //Escrever Raias (real, imaginário)
                for(int i = 0 ; i < num_of_bins_changed[c] ; i++)
                {
                    int16_t value_real;
                    value_real = round(Ref[c][indexChanged[c][i]].real() * 1.5);

                    int16_t value_im;
                    value_im = round(Ref[c][indexChanged[c][i]].imag() * 1.5);

                    comp_atual.write((const char *)(&value_real), sizeof(int16_t));
                    comp_atual.write((const char *)(&value_im), sizeof(int16_t));
                }
            }
            /*****  MUDOU MUITAS RAIAS, ENVIAR FORMA DE ONDA  *****/
            else if(num_of_bins_changed[c] == -1)
            {
                cout << "Forma de onda" << endl;

                //Escrever número do bloco no arquivo
                comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));
                //salvar FFT completa
                for(int j = 0 ; j < VECTOR_SIZE ; j++)
                {
                    Ref[c][j] = New[c][j];
                }

                //escrever quantos mudou
                uint16_t size = WAVEFORM_LENGHT;
                comp_atual.write((const char *)(&size), sizeof(uint16_t));
                //escrever forma de onda no arquivo
                comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
            }

            //for (int i = 0; i < VECTOR_SIZE; i++)
            //{
            //  fft_file.write((const char *)(&CompressionData.Channels[c].FFTReal[i]), sizeof(float));
            //  fft_file.write((const char *)(&CompressionData.Channels[c].FFTImaginary[i]), sizeof(float));
            //}
            comp_atual.flush();
        }

        int result = 0;

        if (c >= 3) //corrente
        {
            if (reference_current)
            {

                result = compress_waveform(RefWave[c-3], CompressionData.Channels[c].Waveform);
                //cout << "Resultado: " << result << endl;
                if (!result) //diferente, salvar forma de onda
                {
                    cout << "Mudou" << endl;
                    int16_t block;
                    block = -blockNumber;

                    //Escrever número do bloco no arquivo
                    comp_atual.write((const char *)(&block), sizeof(block));
                    //Escrever forma de onda no arquivo
                    comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));

                    //Copiar forma de onda para referência
                    memcpy(RefWave[c-3], CompressionData.Channels[c].Waveform, WAVEFORM_LENGHT*(sizeof(int16_t)));
                }
                else //nada mudou
                {
                    cout << "Não mudou" << endl;
                    if (blockNumber >= 3000) //está finalizando arquivo, escrever número do bloco e 0 no tamanho
                    {
                        int16_t block;
                        block = -blockNumber;

                        //Escrever número do bloco no arquivo
                        comp_atual.write((const char *)(&block), sizeof(block));

                        uint16_t size = 0;
                        //Escrever quantidade de raias
                        comp_atual.write((const char *)(&size), sizeof(uint16_t));
                    }
                }
            }
            else
            {
                if(c==6)
                    reference_current = true;

                //Copiar forma de onda para referência
                memcpy(RefWave[c-3], CompressionData.Channels[c].Waveform, WAVEFORM_LENGHT*(sizeof(int16_t)));

                int16_t block;
                block = -blockNumber;

                cout << "Bloco: " << block << endl;
                //Escrever número do bloco no arquivo
                comp_atual.write((const char *)(&block), sizeof(int16_t));
                //Escrever forma de onda no arquivo
                comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
            }

        }

        comp_atual.flush();
        changeFile();

        c++;
    }

    if (blockNumber == 1500 || blockNumber >= 3000) //terminou arquivo, fechar arquivo e reiniciar variáveis
    {
        int16_t block;
        block = 0xAAAA;
        //Escrever número do bloco no arquivo
        comp_file_v1.write((const char *)(&block), sizeof(block));
        comp_file_v2.write((const char *)(&block), sizeof(block));
        comp_file_v3.write((const char *)(&block), sizeof(block));
        comp_file_i1.write((const char *)(&block), sizeof(block));
        comp_file_i2.write((const char *)(&block), sizeof(block));
        comp_file_i3.write((const char *)(&block), sizeof(block));
        comp_file_in.write((const char *)(&block), sizeof(block));

        blockNumber = 0;
        //fechar arquivos
        comp_file_v1.close();
        comp_file_v2.close();
        comp_file_v3.close();
        comp_file_i1.close();
        comp_file_i2.close();
        comp_file_i3.close();
        comp_file_in.close();
        timestamp_file.close();

        wave_file_v1.close();
        wave_file_v2.close();
        wave_file_v3.close();
        wave_file_i1.close();
        wave_file_i2.close();
        wave_file_i3.close();
        wave_file_in.close();
        timestamp_aux.close();

        create_file = true;

        cout << "Fim do arquivo" << endl;

        if (flag_finish)
        {
            aquisicao++;
            // Criar objeto json
            json j;
            j["aquisicao"] = aquisicao;
            j["segmento"] = segmento;  // criar chave "segmento" para contem unsigned int (uint32_t)
            std::ofstream o("/home/ubuntu/compression/compression.json"); // escrever JSON formatado para arquivo
            o << std::setw(4) << j << std::endl;
            o.close();   // Fecha Arquivo
            cout << "Arquivo gerado" << endl;

            exit(0);
        }
    }

    if (flag_shutdown)
    {
        flag_shutdown = false;
        flag_finish = true;
    }


    return 1;
}

void selectFile()
{
    switch (c)
    {
        case 0:
            comp_atual = move(comp_file_v1);
            wave_file = move(wave_file_v1);
        break;
        case 1:
            comp_atual = move(comp_file_v2);
            wave_file = move(wave_file_v2);
            break;
        case 2:
            comp_atual = move(comp_file_v3);
            wave_file = move(wave_file_v3);
            break;
        case 3:
            comp_atual = move(comp_file_i1);
            wave_file = move(wave_file_i1);
            break;
        case 4:
            comp_atual = move(comp_file_i2);
            wave_file = move(wave_file_i2);
            break;
        case 5:
            comp_atual = move(comp_file_i3);
            wave_file = move(wave_file_i3);
            break;
        case 6:
            comp_atual = move(comp_file_in);
            wave_file = move(wave_file_in);
            break;
    }
}

void changeFile()
{
    switch (c)
    {
    case 0:
        comp_file_v1 = move(comp_atual);
        wave_file_v1 = move(wave_file);
        break;
    case 1:
        comp_file_v2 = move(comp_atual);
        wave_file_v2 = move(wave_file);
        break;
    case 2:
        comp_file_v3 = move(comp_atual);
        wave_file_v3 = move(wave_file);
        break;
    case 3:
        comp_file_i1 = move(comp_atual);
        wave_file_i1 = move(wave_file);
        break;
    case 4:
        comp_file_i2 = move(comp_atual);
        wave_file_i2 = move(wave_file);
        break;
    case 5:
        comp_file_i3 = move(comp_atual);
        wave_file_i3 = move(wave_file);
        break;
    case 6:
        comp_file_in = move(comp_atual);
        wave_file_in = move(wave_file);
        break;
    }
}