#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>
#include <sys/timeb.h>


#define RESP_HDR_LEN 176

#define HEADERS "Accept: */*\r\nHost: 129.105.44.194\r\nConnection: Keep-Alive\r\n\r\n"

#define PAGE_NAME "/~jrl829/test.cgi"
#define INDEX_SIZE 1000

pthread_t  con_threads[10];
int thread_ids[10];


struct timeb starttime;

typedef struct obj_req_t {
  int id;
  char * server_ip;
  int port; 
  unsigned long long obj_size;
} obj_req_t;

obj_req_t obj_req;


int get_index(char * server_ip, int port, int req_size);
void *get_object(void * arg);
int get_first_obj(int fd, int size);

int psend(int fd, char * msg, int len);
int precv(int fd, char * resp, int num_bytes);

void usage() {
  printf("Usage: phttpc <server_ip> <num_conn> <data_size> [-i]\n");

}


int main (int argc, char ** argv) {
  char * server_ip = NULL;
  int port = 80;
  int num_conns = 1;
  unsigned long long data_size = 100;
  unsigned long long obj_req_size = 0;
  int i;
  int index_fd;



  if (argc != 4) {
    usage();
    exit(-1);
  }

  server_ip = argv[1];
  num_conns = atoll(argv[2]);
  data_size = atoi(argv[3]);

 
  //  printf("Num Conns: %d\n", num_conns);

  obj_req.server_ip = (char*)malloc(sizeof(char) * strlen(server_ip));
  strncpy(obj_req.server_ip, server_ip, strlen(server_ip));
  obj_req.port = port;
  obj_req.obj_size = data_size / num_conns;

  ftime(&starttime);
  printf("Starttime:%d.%d\n", starttime.time, starttime.millitm);
  index_fd = get_index(server_ip, port, obj_req.obj_size);


  if (index_fd == -1) {
    // error
  }

  for (i = 0; i < (num_conns - 1); i++) {
    thread_ids[i] = i;
    pthread_create(&(con_threads[i]),NULL, get_object, (void*)&thread_ids[i]);
    //printf("Created Thread %d\n",i);
  }
  
  get_first_obj(index_fd, obj_req.obj_size);
  pthread_exit(NULL);
}

int get_first_obj(int fd, int size) {
  char obj_str[512];
  int ret;
  struct timeb data_time;

  //  sprintf(obj_str, "GET %s?size=%d HTTP/1.1\r\n%s", PAGE_NAME, size, HEADERS);
  /*
    if (psend(fd, obj_str, strlen(obj_str)) == -1) {
    printf("Sending error\n");
    return -1;
    }
    printf("Original socket: sent req\n");
  */
  //  ret = precv(fd, NULL, RESP_HDR_LEN);

  ret = precv(fd, NULL, size);
  ftime(&data_time);
  printf("ORIG:data=%d\n", ret);
  printf("ORIG:data_time=%d.%d\n", data_time.time, data_time.millitm);
  close(fd);

  return 0;
}

void *  get_object(void * arg) {
  int id = *((int*)arg);
  struct sockaddr_in address_in;
  int ret;
  int obj_fd;
  char obj_str[1024];
  struct timeb connect_time;
  struct timeb data_time;


  obj_fd = socket(AF_INET, SOCK_STREAM, 0);
  if (obj_fd == -1) {
    fprintf(stderr, "Could not initialize Index Socket\n");
    pthread_exit(NULL);
  }



  address_in.sin_family = AF_INET;
  address_in.sin_port = htons(obj_req.port);
  inet_aton(obj_req.server_ip, &(address_in.sin_addr));
  bzero(&(address_in.sin_zero), 8);


  /* first connect... */
  // printf("Thread %d: Connecting\n", id);

  ret = connect(obj_fd, (struct sockaddr *)&address_in, sizeof(struct sockaddr));
  ftime(&connect_time);
  printf("ID%d:con_time=%d.%d\n", id, connect_time.time, connect_time.millitm);
 
 if (ret == -1) {
    printf("Thread %d: Could not connect the index socket\n", id);
    close(obj_fd);
    pthread_exit(NULL);
  }
  //printf("Thread %d: connected\n", id);


  sprintf(obj_str, "GET %s?size=%d HTTP/1.1\r\n", PAGE_NAME, obj_req.obj_size);
  sprintf(obj_str, "%s%s", obj_str, HEADERS);

  ret = psend(obj_fd, obj_str, strlen(obj_str));

  if (ret == -1) {
    close(obj_fd);
    pthread_exit(NULL);
  }


  ret = precv(obj_fd, NULL, obj_req.obj_size);
  ftime(&data_time);
  printf("ID%d:data=%d\n", id, ret);
  printf("ID%d:data_time=%d.%d\n", id, data_time.time, data_time.millitm);

  close(obj_fd);

  pthread_exit(NULL);

}


int get_index(char * server_ip, int port, int req_size) {
  struct sockaddr_in address_in;
  int ret;
  int index_fd;
  char index_req[512];
  struct timeb connect_time;
  struct timeb data_time;


  index_fd = socket(AF_INET, SOCK_STREAM, 0);
  if (index_fd == -1) {
    fprintf(stderr, "Could not initialize Index Socket\n");
    return -1;
  }

  
  address_in.sin_family = AF_INET;
  address_in.sin_port = htons(port);
  inet_aton(server_ip, &(address_in.sin_addr));
  bzero(&(address_in.sin_zero), 8);


  /* first connect... */

  ret = connect(index_fd, (struct sockaddr *)&address_in, sizeof(struct sockaddr));
  ftime(&connect_time);
  printf("IND:con_time=%d.%d\n", connect_time.time, connect_time.millitm);

  if (ret == -1) {
    fprintf(stderr, "Could not connect the index socket\n");
    return -1;
  }

  
  sprintf(index_req, "GET %s?size=%d HTTP/1.1\r\n%s", PAGE_NAME, INDEX_SIZE + req_size, HEADERS);
  // printf("GET REQ: %s\n", index_req);
  if (psend(index_fd, index_req, strlen(index_req)) == -1) {
    return -1;
  }

  /*  {
    char * hdr = malloc(RESP_HDR_LEN);
    ret = precv(index_fd, hdr, RESP_HDR_LEN);
    printf("Header: %s\n", hdr);
    free(hdr);
    }*/

  //  {
  //char * resp = malloc(INDEX_SIZE);
  ret = precv(index_fd, NULL, INDEX_SIZE);
  ftime(&data_time);
  printf("IND:data=%d\n", ret);
  printf("IND:data_time=%d.%d\n", data_time.time, data_time.millitm);
  //    printf("Index: %s\n", resp);
  //free(resp);
  
  if (ret != INDEX_SIZE) {
    printf("Error: Did not receive correct index\n");
    return -1;
  }
  // }
  return index_fd;
}

int psend(int fd, char * msg, int len) {
  int total = 0;
  int bytesleft = len;
  int n = 0;

  while (total < len) {
    /*time_t now;
      now = time(NULL);
      dprintf("Sending %s at %s", msg, ctime(&now));*/
    // pthread_mutex_lock(&send_lock);
    n = send(fd, msg + total, bytesleft, 0);
    //pthread_mutex_unlock(&recv_lock);

    if (n == -1) break;
    total += n;
    bytesleft -= n;
  }
  return n == -1 ? -1 : 0;
}


int precv(int fd, char * resp, int num_bytes) {
  int total = 0;
  int nbytes = 0;
  char * buf = (char*)malloc(sizeof(char) * (num_bytes + 1));


  while (total < num_bytes) {
    nbytes = recv(fd, buf + total, num_bytes - total, 0);
    if (nbytes <= 0) {
    // error
      //      close(fd);
      if (nbytes == 0)
        return 0;   // connection closed
      else 
        return -1; // error
    }
    *(buf + nbytes) = '\0';
    total += nbytes;
  }

  if (resp) {
    memcpy(resp, buf, num_bytes);
  }
  free(buf);
  return total;
}