#include "common.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <fcntl.h>

#define BUFF_SIZE 2048
#define BUFF_SIZE_DOWN 1024
#define TCP_PORT "2018"
#define BACK_LOG 20

int d_flag = 0;
int client_id = 1;

void debug_print(char *msg, client_state *curr_client){
  if(d_flag == 1){
    fprintf(stderr, "%s | Log: %s\n", curr_client->server_addr, msg);
  }
}

char* stringing_id(){
  char *output = (char*) malloc(BUFF_SIZE);
  sprintf(output, "%d", client_id);
  return output;
}

int recv_func(int client_sock){
  char serv_name[BUFF_SIZE];
  gethostname(serv_name, BUFF_SIZE);
  client_state *curr_client = (client_state*) malloc(sizeof(client_state));
  curr_client->client_id = 0;
  curr_client->sock_fd = -1;
  curr_client->conn_state = IDLE;
  curr_client->server_addr = serv_name;
  char buff[BUFF_SIZE];
  while(1){
    recv(client_sock, buff, BUFF_SIZE, 0);
    debug_print(buff, curr_client);
    if(!strncmp(buff, "Hello", strlen("Hello"))){
      if(curr_client->conn_state == IDLE){
        char* client_id_buff = stringing_id();
        int response_size = strlen("Hello ") + strlen(client_id_buff);
        char response[response_size];
        sprintf(response, "Hello %s", client_id_buff);
        send(client_sock, response, response_size, 0);
        printf("Client %s connected\n", client_id_buff);
        curr_client->conn_state = CONNECTED;
        curr_client->client_id = client_id_buff;
        curr_client->sock_fd = client_sock;
        free(client_id_buff);
      }
      else{
        send(client_sock, "nok state", strlen("nok state"), 0);
      }
    }
    else if(!strncmp(buff, "bye", strlen("bye"))){
      if(curr_client->conn_state == CONNECTED){
        char* client_id_buff = stringing_id();
        printf("Client %s diconnected\n", client_id_buff);
        close(client_sock);
        client_id++;
        free(client_id_buff);
        break;
      }
      else{
        send(client_sock, "nok state", strlen("nok state"), 0);
      }
    }
    else if(!strncmp(buff, "ls", strlen("ls"))){
      if(curr_client->conn_state != CONNECTED){
        char* client_id_buff = stringing_id();
        send(client_sock, "nok state", strlen("nok state"), 0);
        printf("Client %s diconnected\n", client_id_buff);
        close(client_sock);
        client_id++;
        free(client_id_buff);
        break;
      }
      else{
        char *output;
        if((output = list_dir()) != NULL){
          int status = 0;
          status = send(client_sock, "ok", strlen("ok"), 0);
          printf("first send: %d\n", status);
          status = send(client_sock, output, strlen(output), 0);
          printf("second send: %d\n", status);
          char output_buffer[BUFF_SIZE];
          getcwd(output_buffer, BUFF_SIZE);
          printf("Listed files at %s\n", output_buffer);
        }
      }
    }
    else if(!strncmp(buff, "get", strlen("get"))){
      if(curr_client->conn_state == CONNECTED){
        int i = 0;
        while(buff[i++] != ' ');
        long file_s = file_size(buff + i);
        if(file_s == -1){
          char* client_id_buff = stringing_id();
          send(client_sock, "nok file", strlen("nok file"), 0);
          printf("Client %s diconnected\n", client_id_buff);
          close(client_sock);
          client_id++;
          free(client_id_buff);
          break;
        }
        off_t offset=0;
        char* file_name = (buff + i);
        memset(buff, 0, BUFF_SIZE_DOWN);
        sprintf(buff, "ok %ld ", file_s);
        send(curr_client->sock_fd, buff, strlen(buff), 0);
        sleep(1);
        int fd, len = 0;
        fd = open(file_name, O_RDONLY);
        curr_client->conn_state = DOWNLOADING;
        sendfile(curr_client->sock_fd, fd, &offset, file_s);
        memset(buff, 0, BUFF_SIZE_DOWN);
        recv(curr_client->sock_fd, buff, BUFF_SIZE_DOWN, 0);
        if(!strncmp(buff, "done", strlen("done"))){
          curr_client->conn_state = CONNECTED;
          memset(buff, 0, BUFF_SIZE_DOWN);
          send(curr_client->sock_fd, "ok", strlen("ok"), 0);
          printf("Sent file %s\n", file_name);
        }
        else{
          char* client_id_buff = stringing_id();
          send(client_sock, "nok done", strlen("nok done"), 0);
          printf("Client %s diconnected\n", client_id_buff);
          close(client_sock);
          client_id++;
          free(client_id_buff);
          break;
        }
      }
      else{
        char* client_id_buff = stringing_id();
        send(client_sock, "nok state", strlen("nok state"), 0);
        printf("Client %s diconnected\n", client_id_buff);
        close(client_sock);
        client_id++;
        free(client_id_buff);
        break;
      }
    }
    else{
      char* client_id_buff = stringing_id();
      send(client_sock, "nok message", strlen("nok message"), 0);
      printf("Client %s diconnected\n", client_id_buff);
      close(client_sock);
      client_id++;
      free(client_id_buff);
      break;
    }
  }
  free(curr_client);
  return 1;
}

int main(int argc, char const *argv[]){
  int server_sock, client_sock;
  struct sockaddr client_addr;
  socklen_t addr_size = sizeof(struct sockaddr);
  memset(&client_addr, 0, addr_size);
  int status, yes = 1;
  struct addrinfo *hints = (struct addrinfo*) malloc(sizeof(struct addrinfo));
  hints->ai_family = AF_UNSPEC;
  hints->ai_socktype = SOCK_STREAM;
  hints->ai_flags = AI_PASSIVE;

  struct addrinfo *res;
  if(!(status = getaddrinfo(NULL, TCP_PORT, hints, &res))){
    while(res){
      if((server_sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1){
        res = res->ai_next;
        continue;
      }
      else{
        break;
      }
    }
    if(!res){
      perror("no address to connect");
    }
    else{
      while(1){
        setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
        bind(server_sock, res->ai_addr, res->ai_addrlen);
        listen(server_sock, BACK_LOG);
        client_sock = accept(server_sock, &client_addr, &addr_size);
        recv_func(client_sock);
      }
    }
  }
  free(hints);
  return 0;
}