/*
 * This file is part of the Palacios Virtual Machine Monitor developed
 * by the V3VEE Project with funding from the United States National 
 * Science Foundation and the Department of Energy.  
 *
 * The V3VEE Project is a joint project between Northwestern University
 * and the University of New Mexico.  You can find out more at 
 * http://www.v3vee.org
 *
 * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu> 
 * Copyright (c) 2008, Lei Xia <xiaxlei@gmail.com>
 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org> 
 * All rights reserved.
 *
 * Author: Jack Lange <jarusl@cs.northwestern.edu>
 * Author: Lei Xia <xiaxlei@gmail.com>
 *
 * This is free software.  You are permitted to use,
 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
 */

#include <geekos/socket.h>
#include <geekos/malloc.h>
#include <geekos/ne2k.h>

#ifdef UIP

#include <uip/uip.h>
#include <uip/uip_arp.h>

#include <geekos/vmm_stubs.h>
#include <geekos/debug.h>
#include <geekos/timer.h>

#define BUF ((struct uip_eth_hdr *)&uip_buf[0])

#define MAX_SOCKS 1024
#define BUF_SIZE 1000

struct socket sockets[MAX_SOCKS];

void socket_appcall(void);
#ifndef UIP_APPCALL
#define UIP_APPCALL socket_appcall
#endif /* UIP_APPCALL */


static int Packet_Received(struct NE2K_Packet_Info* info, uchar_t *pkt);
static void periodic_caller(int timer_id, void * arg);

void init_socket_layer() {
	
   int i = 0;
   bool iflag;

   
   for (i = 0; i < MAX_SOCKS; i++) {
      sockets[i].in_use = 0;
      sockets[i].send_buf = NULL;
      sockets[i].recv_buf = NULL;
      sockets[i].state = CLOSED;
   }

    //initiate uIP
    uip_init();
    uip_arp_init();
	
    //setup device driver 
    Init_Ne2k(&Packet_Received); 

    iflag = Begin_Int_Atomic();
    Start_Timer(2, periodic_caller, NULL);
    End_Int_Atomic(iflag);
}

void set_ip_addr(uchar_t addr[4]) {
  uip_ipaddr_t ipaddr;
  uip_ipaddr(ipaddr, addr[0], addr[1], addr[2], addr[3]);  /* Local IP address */
  uip_sethostaddr(ipaddr);
}

static int allocate_socket_fd() {
  int i = 0;
  
  for (i = 0; i < MAX_SOCKS; i++) {
    if (sockets[i].in_use == 0) {
      sockets[i].in_use = 1;
      sockets[i].send_buf = create_ring_buffer(BUF_SIZE);
      if (sockets[i].send_buf == NULL)
	  	return -1;
      sockets[i].recv_buf = create_ring_buffer(BUF_SIZE);
      if (sockets[i].recv_buf == NULL){
	  	free_ring_buffer(sockets[i].send_buf);
	  	return -1;
      }
      return i;
    }
  }

  return -1;
}

static int release_socket_fd(int sockfd){
       if (sockfd >= 0 && sockfd < MAX_SOCKS){
		sockets[sockfd].in_use = 0;
		free_ring_buffer(sockets[sockfd].send_buf);
		free_ring_buffer(sockets[sockfd].recv_buf);
		sockets[sockfd].send_buf = NULL;
		sockets[sockfd].recv_buf = NULL;
		sockets[sockfd].state = CLOSED;
       }

	return 0;
}


struct socket * get_socket_from_fd(int fd) {
  return &(sockets[fd]);
}


static void periodic_caller(int timer_id, void * arg) {
  int i;
  //handle the periodic calls of uIP
  
  //PrintBoth("Timer CALLBACK handler\n");

  for(i = 0; i < UIP_CONNS; ++i) {
    uip_periodic(i);
    if(uip_len > 0) {
      //devicedriver_send();
      PrintBoth("Sending Packet\n");
      NE2K_Transmit(uip_len);
    }
  }
  for(i = 0; i < UIP_UDP_CONNS; i++) {
    uip_udp_periodic(i);
    if(uip_len > 0) {
    //devicedriver_send();
      NE2K_Transmit(uip_len);
    }
  }
}


int connect(const uchar_t ip_addr[4], ushort_t port) {
  int sockfd = -1;
  sockfd = allocate_socket_fd();
  static uip_ipaddr_t ipaddr;
  
  if (sockfd == -1) {
    return -1;
  }

  uip_ipaddr(&ipaddr, ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]);  
  
  sockets[sockfd].con = uip_connect(&ipaddr, htons(port));


  if (sockets[sockfd].con == NULL){
    release_socket_fd(sockfd);
    return -1;
  }


  PrintBoth("Connection start\n");
  Wait(&(sockets[sockfd].recv_wait_queue));
  
    
  PrintBoth("Connected\n");




  return sockfd;
}

int recv(int sockfd, void * buf, uint_t len){
  uint_t recvlen;

  struct socket *sock = get_socket_from_fd(sockfd);


  // here we need some lock mechnism, just disable interrupt may not work properly because recv() will be run as a kernel thread 
buf_read:
  recvlen = rb_read(sock->recv_buf, buf, len);

  if (recvlen == 0){
  	Wait(&(sock->recv_wait_queue));
	goto buf_read;
  }

  return recvlen;
}



// a series of utilities to handle conncetion states
static void connected(int sockfd) {
  struct socket * sock = get_socket_from_fd(sockfd);

  PrintBoth("Connected Interrupt\n");

  sock->state = ESTABLISHED;

  Wake_Up(&(sock->recv_wait_queue));
}

static void closed(int sockfd){

}

static void acked(int sockfd){

}

static void newdata(int sockfd){
  uint_t len;
  char *dataptr;
  uint_t wrlen;
  struct socket *sock;
    
  len = uip_datalen();
  dataptr = (char *)uip_appdata;

  if (len == 0)
  	return;

  sock = get_socket_from_fd(sockfd);

  wrlen = rb_write(sock->recv_buf, dataptr, len);

  if (wrlen < len){ //write error, what should I do?
	return;
  }

  Wake_Up(&(sock->recv_wait_queue));

  return;    

}

// not finished yet
static void send_to_driver(int sockfd) {

  PrintBoth("Sending data to driver\n");

}



int send(int sockfd, void * buf, uint_t len) {
  struct socket * sock = get_socket_from_fd(sockfd);
  //int mss = uip_mss();
  //int pending_bytes = rb_data_len(sock->send_buf);
  //int len = (mss < pending_bytes) ? mss: pending_bytes;
  int bytes_read = 0;
  uchar_t * send_buf = uip_appdata;
  
  bytes_read = rb_peek(sock->send_buf, send_buf, len);

  if (bytes_read == 0) {
    // no packet for send
    return -1;
  }

  uip_send(send_buf, len);

  return len;
}



//get the socket id by the local tcp port
static int get_socket_from_port(ushort_t lport) {
  int i;
  

  for (i = 0; i < MAX_SOCKS; i++){
    if (sockets[i].con->lport == lport) {
      return i;
    }
  }
  
  return -1;
}



void socket_appcall(void) {

  int sockfd; 
  
  sockfd = get_socket_from_port(uip_conn->lport);

  PrintBoth("Appcall\n");

  
  if (sockfd == -1) {
    return;
  }

  if (uip_connected()) {
    connected(sockfd);

  }
  
  if (uip_closed() ||uip_aborted() ||uip_timedout()) {
     closed(sockfd);
     return;
  }
  
  if (uip_acked()) {
     acked(sockfd);
  }
  
  if (uip_newdata()) {
     newdata(sockfd);
  }
  
  if (uip_rexmit() ||
      uip_newdata() ||
      uip_acked() ||
      uip_connected() ||
      uip_poll()) {
    send_to_driver(sockfd);
  }
}




static int Packet_Received(struct NE2K_Packet_Info * info, uchar_t * pkt) {
  //int i;
  uip_len = info->size; 

  //  for (i = 0; i < info->size; i++) {
  //  uip_buf[i] = *(pkt + i);
  //}

  PrintBoth("Packet REceived\n");

  memcpy(uip_buf, pkt, uip_len);


  Free(pkt);

  if (BUF->type == htons(UIP_ETHTYPE_ARP)) {
    PrintBoth("ARP PACKET\n");

    uip_arp_arpin();


    if (uip_len > 0) {
      PrintBoth("Transmitting\n");
      NE2K_Transmit(uip_len);
    }	
			

  } else {
    PrintBoth("Data PACKET\n");
    uip_arp_ipin();
    uip_input();


    if (uip_len > 0) {
      PrintBoth("Transmitting\n");
      uip_arp_out();
      NE2K_Transmit(uip_len);
    }
    
  }

  return 0;
}


#endif  /* UIP */