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

#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

#define SIZE_DATA_BUFFERS 64

int connecting_frame_timeout_bf;

void init_hdlc_client(struct Client* client, int connecting_frame_timeout){
    client->state = IDLE_STATE;
    client->connecting_frame_timeout = connecting_frame_timeout;
    connecting_frame_timeout_bf = connecting_frame_timeout;

    client->current_state_hdlc.control_escape = 0;
    client->current_state_hdlc.fcs = FCS_INIT_VALUE;
    client->current_state_hdlc.start_index = -1;
    client->current_state_hdlc.end_index = -1;
    client->current_state_hdlc.src_index = 0;
    client->current_state_hdlc.dest_index = 0;
}

void connect(struct Client* client, hdlc_control_t* frame){
    client->state = CONNECTING;

    client->frameS.seq_no = 0;
    client->frameS.frame = S_FRAME;

    *frame = client->frameS;

//    if (client->frame1.seq_no == -4){
//        client->frame1.seq_no = 0;
//        client->frame1.frame = S_FRAME;
//
//        *frame = client->frame1;
//    } else if (client->frame1.seq_no == -4){
//        client->frame1.seq_no = 0;
//        client->frame1.frame = S_FRAME;
//
//        *frame = client->frame1;
//    }
}

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

    client->state = RECIVING;

    if (SIZE_DATA_BUFFERS < data_len){
        return ERR_INVALID_DATA_SIZE;
    }

    client->frameI.seq_no = 0;
    client->frameI.frame = I_FRAME;
    client->data_i_frame = *data;
    client->len_data_i_frame = data_len;

    *frame = client->frameI;

    client->state = RECIVING;
};

int hdlc_get_raw_frame(struct Client *client, hdlc_control_t* frame, uint8_t buffer[], size_t lenBuffer) {
    if (frame->frame = S_FRAME){
        int ret = hdlc_frame_data(frame, NULL, 0, buffer, &lenBuffer);
        if (ret < 0){
            printf("err in get_frame: %d\n", ret);
        }
    } else {
        int ret = hdlc_frame_data(frame, &client->data_i_frame,
                                  client->len_data_i_frame, buffer, &lenBuffer);
        if (ret < 0){
            printf("err in get_frame: %d\n", ret);
        }
    }

    return 0;
}

int hdlc_decode_recived_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer){
    hdlc_control_t recv_control;
    uint8_t recive[len_buffer];

    int ret = hdlc_get_data_with_state(&client->current_state_hdlc, &recv_control, buffer, len_buffer, recive,
                            &len_buffer);

    if (ret < 0) {
        return ret;
    }

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

    client->connecting_frame_timeout = connecting_frame_timeout_bf;
    return 0;
}

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

    if (client->connecting_frame_timeout <= 0){
        return ERR_FRAME_TIME_OUT;
    }
}