#include "client.h"
#include "hdlc.h"
#include "stdio.h"

#define CONNECT_FRAME_PERIOD 200
#define SIZE_DATA_BUFFER 64
#define COUNT_BUFFERS 4

#define ERR_INVALID_DATA_SIZE -1
#define ERR_ALL_BUFFERS_FILL -2
#define ERR_INVALID_PARAMS -3
#define ERR_INVALID_STATE -4
#define ERR_FRAME_TIME_OUT -5
#define ERR_INVALID_SEQ_NUMBER_FRAME -6
#define ERR_TIMEOUT_ANSWER -7

uint8_t buffer_data[COUNT_BUFFERS][SIZE_DATA_BUFFER];

int init_hdlc_client(int count_buffers, int size_data_buffer, int connecting_frame_timeout, struct Client* client){
    if (count_buffers <= 0){
        return ERR_INVALID_PARAMS;
    }

    if (size_data_buffer <= 0){
        return ERR_INVALID_PARAMS;
    }

    if (connecting_frame_timeout <= 0){
        return ERR_INVALID_PARAMS;
    }

    client->state = IDLE_STATE;
    client->connecting_frame_timeout = connecting_frame_timeout;
    client->count_buffers = count_buffers;
    client->size_data_buffer = size_data_buffer;
    client->number_seq_frame = 0;

    for (int i = 0; i < sizeof(buffer_data); i++){
        for (int x = 0; x < sizeof(buffer_data[i]); x++){
            buffer_data[i][x] = -1;
        }
    }
    return 0;
}

void connect(struct Client* client){
    client->state = CONNECTING;
}

int send_data(struct Client* client, uint8_t* data, size_t data_len){
    if (client->state != READY_STATE){
        return ERR_INVALID_STATE;
    }

    if (client->size_data_buffer < data_len){
        return ERR_INVALID_DATA_SIZE;
    }

    for(int i = 0; i < COUNT_BUFFERS; i++){
        if (buffer_data[i][0] == -1){
            for (int x = 0; x < data_len; x++){
                buffer_data[i][x] = data[x];
            }
        }

        if (i == COUNT_BUFFERS - 1){
            return ERR_ALL_BUFFERS_FILL;
        }
    }

    client->state = RECIVING;
};

int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer) {
    hdlc_control_t control_send;

    switch (client->state) {
        case CONNECTING:
            if (client->connecting_frame_timeout <= 0){
                control_send.frame = S_FRAME;
                control_send.seq_no = 1;
                client->number_seq_frame = control_send.seq_no;

                int ret = hdlc_frame_data(&control_send, NULL, 0, buffer, &lenBuffer);
                if (ret < 0){
                    printf("err in get_frame ACK: %d\n", ret);
                }

                client->connecting_frame_timeout = CONNECT_FRAME_PERIOD;
            }
            break;
        case READY_STATE:
            control_send.frame = I_FRAME;
            control_send.seq_no = 1;
            for(int i = 0; i < COUNT_BUFFERS; i++){
                if (buffer_data[i][0] == -1){
                    int ret = hdlc_frame_data(&control_send, buffer_data[i], SIZE_DATA_BUFFER, buffer, &lenBuffer);
                    if (ret < 0){
                        printf("err in get_frame DATA: %d\n", ret);
                    }
                }

                if (i == COUNT_BUFFERS - 1){
                    return ERR_ALL_BUFFERS_FILL;
                }
            }
            break;
    }

//   Yf

    return 0;
}

int hdlc_get_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer){
    if (client->connecting_frame_timeout <= 0){
        return ERR_FRAME_TIME_OUT;
    }

    hdlc_control_t recv_control;
    uint8_t recive[len_buffer];

    int ret = hdlc_get_data(&recv_control, buffer, len_buffer, recive,
                            &len_buffer);
    if (recv_control.seq_no != client->number_seq_frame){
        return ERR_INVALID_SEQ_NUMBER_FRAME;
    }

    if (ret < 0 && client->connecting_frame_timeout < 0){
        return ERR_TIMEOUT_ANSWER;
    }

    switch (recv_control.frame) {
        case S_FRAME:
            client->state = READY_STATE;
            break;
        case I_FRAME:
            break;
        case S_FRAME_NACK:
            break;
    }
    return 0;
}

void hdlc_timeout_handler(struct Client* client, int delta_time){
    client->connecting_frame_timeout -= delta_time;
}