#include "game_client.h"
#include "transactions.h"
#include "../game_source/color.h"

#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/socket.h>


int Connect(game_server* gs) {
    struct sockaddr_in game_serverAddr;
    struct sockaddr_in server_serverAddr;

    gs->game_info.port = 2223;
    gs->game_info.ip = "192.168.254.74";

    gs->server_info.port = 2224;
    gs->server_info.ip = "192.168.254.74";

    game_serverAddr.sin_family = AF_INET;
    game_serverAddr.sin_port = htons(2223);
    game_serverAddr.sin_family = AF_INET;

    server_serverAddr.sin_port = htons(2223);
    server_serverAddr.sin_addr.s_addr = INADDR_ANY;
    server_serverAddr.sin_addr.s_addr = INADDR_ANY;
    int blocking_mode = 1;

    
    gs->game_info.socket = socket(AF_INET, SOCK_STREAM, 0);

    gs->server_info.socket = socket(AF_INET, SOCK_STREAM, 0);
    inet_pton(AF_INET, gs->game_info.ip, &game_serverAddr.sin_addr);

    if(connect(gs->server_info.socket, (struct sockaddr*)&game_serverAddr, sizeof(game_serverAddr)) < 0) {
        //ioctl(gs->server_info.socket, FIONBIO, &blocking_mode); // Shuld be 1
        
        server_transaction st; 
        server_transaction rst; 
        memset(&st, 0, sizeof(server_transaction));

        st.id = SERVER_T_SERVER_FLAG;
        st.action = SERVER_T_CONNECT;
        st.argsize = 0;
        st.serverArg = 0;

        SendServerTransaction(&st, gs->server_info.socket);
        if(RecvServerTransaction(&rst, gs->server_info.socket)) {
            printf("server transaction failed\n");
            return -1;
        }

        if(rst.id == SERVER_T_SERVER_FLAG && rst.action == SERVER_T_CONNECT) {
            memcpy(&gs->game_info.id, rst.serverArg, sizeof(int));

            char* ip = malloc((rst.argsize - sizeof(int)) + 1);
            strncpy(ip, rst.serverArg + sizeof(int), (rst.argsize - sizeof(int)) + 1);
            ip[rst.argsize - sizeof(int)] = '\0';

            printf("Connecting to server %s\n", ip);

            inet_pton(AF_INET, ip, &game_serverAddr.sin_addr);
            if(connect(gs->game_info.socket, (struct sockaddr*)&game_serverAddr, sizeof(game_serverAddr)) <= 0) {
                printf("Could not connect to server \"%s\"\n", ip); 
                free(ip);
                return -1;

            }
            free(ip);

            color rcolor = {rand()%250, rand()%250, rand()%250};
            user_transaction ut = {
                .id = SERVER_T_USER_FLAG,
                .action = SERVER_T_CONNECT,
                .argsize = sizeof(color),
                .userArg = &rcolor,
            };

            user_transaction rut = {0};

            SendUserTransaction(&ut, gs->game_info.socket);

            if(RecvUserTransaction(&rut, gs->game_info.socket)) {
                printf("Could not get other users\n");
                return -1;
            }

            if(rut.id == SERVER_T_GET_PLAYER_DATA && rut.action == SERVER_T_SET_PLAYER_ID) {
                //player *players = malloc(rut.argsize/sizeof(player));
                //memcpy(players, rut.userArg, rut.argsize);
                FreeUserTransaction(&rut);

                
            }
            

        }

        SendServerTransaction(&st, gs->server_info.socket);
        if(RecvServerTransaction(&rst, gs->server_info.socket)) {
            printf("server failed to get Player data");
        }
        

        return 0;
    }
    printf("ng\n");
    return -1;
}
int Client_Send(game_server* gs,packet* packet) {
    int sendPacketSize = sizeof(int) + sizeof(int) + packet->size;
    unsigned char* buffer = malloc(sizeof(int) + sizeof(int) + packet->size);
    memcpy(buffer, &packet->packetTpye, sizeof(int));
    memcpy(buffer+sizeof(int), &packet->size, sizeof(int));
    memcpy(buffer+sizeof(int)+sizeof(int), &packet->packet, packet->size);

    write(gs->game_info.socket, buffer, sendPacketSize);
    return 0;
}

int Client_Recive(game_server* gs, packet* packet) {

    if(read(gs->game_info.socket, &packet->packetTpye, sizeof(int)) <= 0) {
        return 0;
    }
    if(read(gs->game_info.socket, &packet->size, sizeof(int)) <= 0 ) {
        return -1;
    }

    packet->packet = malloc(packet->size);

    if(read(gs->game_info.socket, &packet->packet, packet->size) <= 0) {
        free(packet->packet);
        return -1;
    }
    return 1;
}

int Disconnect(game_server* gs) {
    server_transaction st = {
        .id = SERVER_T_SERVER_FLAG,
        .action = SERVER_T_DISCONNECT,
        .argsize = 0,
        .serverArg = 0,

    };
    SendServerTransaction(&st, gs->server_info.socket);
    close(gs->game_info.socket);
    close(gs->server_info.socket);
    return 0;
}