#include "CmdLineOptions.hpp"
#include "Thread.hpp"
#include "GnuStr.hpp"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

classConnectionThread : public Thread{
  public:
	ConnectionThread(int csd){
		clientsd = csd;
		}

	~ConnectionThread(void){}

	virtual void Run( void );

  private:
	int clientsd;
        int serversd;
};


class ConfThread : public Thread{
    public:
        ConfThread(int sd){ confsd = sd;}
        ~ConfThread(void){}
        
        virtual void Run(void);
    private:
        int confsd;

};
int ConnectToServer( void);
void DoMsg( int sock);
int SetupServerSock(int port);
void DoMainLoop(int server, int confserver);

void HandleServerConfig(GnuStr& param);
void HandlePortConfig(GnuStr& param);
void HandleLogClientConfig(GnuStr& param);
void HandleLogServerConfig(GnuStr& param);

//Global structure that stores command line parameters
struct Params{
  GnuStr server;
  int port;
  int stage;
  int localport;
  bool logclient;
  bool logserver;
};
Params params;

CmdLineOptions opts[] = {
 { "server = s", 0, &params.server, "--server=s	The host the server application runs on"},
 { "port = i", 0, &params.port, "--port=i	The port of server application listens on"},
 { "stage = i", 0, &params.stage, "--stage=i	Defines implementation stage of project"},
 { "local = i", 0, &params.localport, "--local=i	The port to listen for requests for clients" }, 
 { "logclient = b", 0, &params.logclient, "--logclient=b	copy information sent from client to stdout" },
 { "logserver = b", 0, &params.logserver, "--logserver=b	copy information sent from server to stdout" },
 { "confport = i", 0, &params.confport, "---confport=i  The port to change eavesdropper configuration" },
 { 0, 0, 0, 0}
};

int main(int argc, char** argv){
 params.server = "rohan";
 params.server = 9999;
 params.server = 2;
 params.localport = 9090;
 params.logclient = false;
 params.logserver = false;
 
 ReadCmdLineOptions(argc, argv, opts);
 cout<<"Options: "<<endl
	<<"	--server = " << params.server<<endl
	<<"	--port = " << params.port <<endl
	<<"	--stage = " << params.stage <<endl
	<<"	--local = " << params.localport<<endl
	<<"	--logclient = " << params.logclient <<endl
	<<"	--logserver = " << params.logserver <<endl
        <<"     --confport = " <<params.confport << endl;

 if( params.stage == 1){
	char* msg = "Hello: Darrell\r\n";
	int serversd = ConnectToServer();
	DoMsg(serversd);
	return 0;
	}

 int serversock = SetupServerSock();
 int confserver = -1;
 if (params.confport != -1)
    confserver = SetupServerSock( params.confport);
 DoMainLoop(serversock, confserver);

 return 0;
}

void DoMainLoop(int sock){
 sockaddr_in sin;
 socklen_t length;

 while( 1 ){
	fd_set readfds;
	FD_ZERO( &readfds);
	FD_SET( eaveserver, &readfds );
	if ( params.confport != -1 ) FD_SET( confserver, &readfds );
	
	int retval = select(1024, &readfds, NULL, NULL, NULL);
	if (retval <= 0) continue;

	if( FD_ISSET( eaveserver, &readfds ) ){
	  length = sizeof( sin );
	  int client = accept( eaveserver, (sockaddr*) &sin, &length);
	  if (client <= 0){
		cerr<<"Accept call failed...ignoring."<<endl;
		perror("accept");
		continue;
		}

	  ConnectionThread* ct = new ConnectionThread( client );
	  ct->StartDetached();
	  }

	else if (FD_ISSET( confserver, &readfds ) ) {
	  length = sizeof(sin);
	  int client = accept(confserver, (sockaddr*) &sin, &length);
	  if ( client <= 0 ){
		cerr<<"Accept call failed...ignoring."<<endl;
		perror( "accept" );
		continue;
		}

	  ConfThread* ct = new ConfThread( client );
	  ct->StartDetached();
	  }
	}
  }

int ConnectToServer(void){
    NetAddress addr;
    addr.SetAddress( params.server, params.port );
    int sock = socket( PF_INET, SOCK_STREAM, 0 );
    if( sock == -1 ){
        cerr<<"Socket call failed." << endl;
        perror("socket");
        exit(-1);
        }

    sockaddr_in sin = addr;
    int retval = connect( sock, (sockaddr*)&sin, sizeof(sin));
    if( retval < 0 ){
        cerr<<"Could not connect to server: "<<params.server <<':' <<params.port<<endl;
        perror("connect");
        exit(-1);
        }
    return sock;
}

void DoMsg(int sock){
    GnuStr msg = "Hi Darrell\r\n";
    write(sock, msg.chars(), msg.length() );
    close (sock);
    }

int SetupServerSock( int port ){
    int sock = socket(PF_INET, SOCK_STREAM, 0);
    if( sock == -1){
        cerr<<"Socket call failed."<<endl;
        perror("socket");
        exit(-1);
        }
        
    int optval = 1;
    int retval = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, 
        sizeof(optval) );
    if ( retval < 0 ){
        cerr<<"Could not set socket as a reusable."<<endl;
        perror("setsockopt(...SO_REUSEADDR...)");
        }

    NetAddress local(port);
    sockaddr_in sin = local;
    retval = bind(sock, (sockaddr*) &sin, sizeof(sin));
    if( retval < 0){
        cerr<<"Could not connect to server: "<<params.server << ':' <<
            params.port<<endl;
        perror("connect");
        exit(-1);
        }
    listen(sock, 1024);
    return sock;
    }

void ConnectionThread::Run(void){
    serversd = ConnectToServer();
    char buffer [1024];
    while(1){
        fd_set readfds;
        FD_ZERO (&readfds); 
        FD_SET(clientsd, &readfds);
        FD_SET(serversd, &readfds); 
        
        int retval = select(clientsd+serversd, &readfds, NULL, NULL, NULL);
        if (retval <= 0) continue;
        if (FD_ISSET( clientsd, &readfds)){
            int bytesread = read(clientsd, buffer, 1024);
            if (bytesread == 0) break;
            
            if (params.logclient) 
                write(1, buffer, bytesRead);
                
        write(serversd, buffer, bytesRead);
        }

        if (FD_ISSET(serversd, &readfds )){
            int bytesRead = read( serversd, buffer, 1024 );
            if ( bytesRead == 0)  break;
            
            if (params.logserver)
                write(1, buffer, bytesRead);

            write( clientsd, buffer, bytesRead );
            }
        }

        if (params.logserver || params.logclient )
            cout<<"Connection Closed.";
        close( serversd );
        close( clientsd );
    }

void ConfThread::Run(void){
    char buffer[1025];
    GnuStr line = "";
    while(1){
        int bytesRead = read( confsd, buffer, 1024);    
        if ( bytesRead == 0 ) break;
        buffer[ bytesRead ] = '\0';
        line += buffer;
        
    }
    close(confsd);
    
    cout<<"Received command: "<<line<<endl;
    int idx = line.index('=');
    if ( idx <= 0 ) {
        "CONFIG: Could not parse command." << endl;
        return;
        }
    
    GnuStr cmd = line.before(idx);  
    GnuStr param = line.after(idx);
    cout<<"##Command name: "<<line.before(idx) << endl;
    cout<<"##Command parameter: "<<line.after(idx) <<endl;
    
    if( cmd == "server" ) HandleServerConfig (param);
    if( cmd == "port" ) HandlePortConfig( param);
    if( cmd == "logclient" ) HandleLogClientConfig(param);
    if( cmd == "logserver" ) HandleLogServerConfig(param);
    }

void HandleServerConfig(GnuStr& param){
    int idx = param.index('\r');
    if( idx == -1 ) idx = param.index('\n');
    if( idx == -1 || idx == 0){
        cerr<<"CONFIG: Server hostname empty."<<endl;
        return;
        }

    cout<<"##Setting Server: " <<param.before(idx) <<endl;
    params.server = param.before(idx);
    }

void HandlePortConfig( GnuStr& param ){
    int tempport = strtol(param.chars(), NULL, 0);
    if( tempport = 0){
        cerr<< "CONFIG: Could not convert port number."<<endl;
        return;
        }

    cout<< "##Setting port: "<<tempport <<endl;
    params.port = tempport;
    }

void HandleLogClientConfig( GnuStr& param ){
    int idx = param.index('\r');
    if( idx == -1) idx = param.index('\n');
    
    if( idx == -1 || idx == 0){
        cerr<<"Config: LogClient field empty."<<endl;
        return;
        }

    cout<<"##Setting LogClient: "<<params.before(idx) <<endl;
    GnuStr boolvalue = param.before(idx);
    if( boolvalue == "true" )
        params.logclient = true;
    else if( boolvalue == "false")
        params.logclient = false;
    else
        cerr<<"Config: Could not parse parameter to logclient."<<endl;
    }
    return;
}

void HandleLogServerConfig( GnuStr& param ){
    int idx = param.index('\r');
    if( idx == -1) idx = param.index('\n');
    
    if( idx == -1 || idx == 0){
        cerr<<"Config: LogServer field empty."<<endl;
        return;
        }

    cout<<"##Setting LogServer: "<<params.before(idx) <<endl;
    GnuStr boolvalue = param.before(idx);
    if( boolvalue == "true" )
        params.logclient = true;
    else if( boolvalue == "false")
        params.logclient = false;
    else
        cerr<<"Config: Could not parse parameter to logserver."<<endl;
    }
    return;
}