#include "stacktsk.h"
#include "dhcp.h"
#include "tick.h"
#include "delay.h"
#include "udp.h"
#include "arp.h"
#include "arptsk.h"
#include "tcp.h"
#include "network.h"



 
/*****************************
 GLOBAL vars
 ****************************/
NODE_INFO rnode;
NetworkState state;
TCP_SOCKET tsock1;

 
unsigned long global_network_amount;
unsigned char global_network_char[16];
unsigned char global_network_charlen;


/*****************************
 network funktions
 ****************************/


void network_init(void)
{
	state = off;
}	


void network_worker(void)
{    
	TickGet();
    StackTask();    
}	

void network_parse_amount(unsigned char buf[])
{
	global_network_amount = buf[0]<<24 + buf[1]<<16 + buf[2]<<8 + buf[3];
}	

void network_read_amount(void)
{
	unsigned char buf[4];
	TCPGetArray(tsock1, buf,4);
	network_parse_amount(buf);
}	

void network_wait(unsigned char n)
{
	int i;
	for (i=0; i<n; i++)
	{
		network_worker();
		Delay10us(1);
	}
}	

char network_read_ack(void)
{
	char ack;
	while(state != Acknowledged)
	{
		if (TCPIsGetReady(tsock1))
		{
			TCPGet(tsock1, &ack);
			TCPDiscard(tsock1);
			state = Acknowledged;
		}
		network_worker();
	}
	
	state = TcpReadyToSend;
	
	if (ack == 1)
		return 0;
	else
		return 4;
}	

//Request ID 0
char network_send_hello( unsigned char termid )
{
	char gotArp = 0;		// if gotArp is 0, the embedded haven't talked to the server since boot.
	static char isBound = 0;

	while( !DHCPIsBound() && isBound == 0 )
		network_worker();

	if ( DHCPIsBound() && isBound == 0 ){
		state = DhcpIsBound;
		isBound = 1;
	}
	
	while( state != HelloDone )
	{
		switch (state)
		{
			case DhcpIsBound:
				if ( ARPIsTxReady() && gotArp == 0 )
					state = ArpIsTxReady;
				else 
					state = ArpIsResolved;
				break;
			
			case ArpIsTxReady:
				ARPResolve(&rnode.IPAddr);
				gotArp = 1;
				state = ArpIsResolved;
				break;
						
			case ArpIsResolved:
				if ( ARPIsResolved(&rnode.IPAddr, &rnode.MACAddr) ){
					state = SockOpening;
				}
				break;
			
			case SockOpening:
				tsock1 = TCPConnect (&rnode, 3000);
				state = SockOpen;
				break;
		
			case SockOpen:
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
					state = TcpSend;
				break;
			
			case TcpSend:
				TCPPut( tsock1, 0x00 );
				TCPPut( tsock1, termid );
				TCPFlush(tsock1);
				//TCPDiscard( tsock1 );
				state = HelloDone;
				break;
		}
		network_worker();
	}
	return network_read_ack();
}

//Request ID 1
char network_send_scan_frame( unsigned char antal, unsigned char buflen )
{
	char i;
	char ack;

	while( state != StregkodeSendDone ) //Sender vare-request-info pakke
	{
		switch (state)
		{
			case TcpReadyToSend:
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
				state = TcpSend;
			case TcpSend:
				TCPPut( tsock1, 0x01 );
				TCPPut( tsock1, antal );
				TCPPut( tsock1, buflen );
				for (i = 0; i < buflen; i++)
				{ 
					TCPPut(tsock1, global_network_char[i] );
				}
				TCPFlush(tsock1);
				state = StregkodeSendDone;
				break;
		}
		network_worker();
	}
	
	while( state != StregkodeRecieveDone ) //venter på svar og parser denne
	{
		switch( state )
		{
			case StregkodeSendDone:
				if( TCPIsGetReady(tsock1) )
					state = ReadyToRecieve;
				break;
			case ReadyToRecieve:
				TCPGet( tsock1, &ack );
				
				if (ack == 0)
				{
					state = TcpReadyToSend;
					TCPDiscard(tsock1);
					return 4;
				}
				
				network_read_amount();
				TCPGet( tsock1, &global_network_charlen);
				TCPGetArray( tsock1, global_network_char, global_network_charlen);
				TCPDiscard(tsock1);
				
				state = StregkodeRecieveDone;				
					
				break;
		}
		network_worker();
	}
	state = TcpReadyToSend;
	return 0;
}

//Request ID 2
char network_send_calc_total(void)
{
	unsigned char ack;
	while(state != TotalRequested)
	{
		switch(state)
		{
			case TcpReadyToSend: 
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
					state = TcpSend;
				break;
				
			case TcpSend:
				TCPPut(tsock1, 0x02);
				TCPFlush(tsock1);
				state = TotalRequested;
				break;
		}
		network_worker();
	}
	
	while (state != TotalRequestedDone)
	{
		if (TCPIsGetReady(tsock1))
		{
			TCPGet(tsock1, &ack);
			if (ack == 0)
			{
				TCPDiscard(tsock1);
				state = TcpReadyToSend;
				return 4;
			}
			network_read_amount();
			TCPDiscard(tsock1);
			state = TotalRequestedDone;
		}
		network_worker();
	}
	
	state = TcpReadyToSend;
	return 0;
}	

//Request ID 3
char network_send_cash_payed(unsigned long amount)
{
	unsigned char ack;
	while (state != ChangeRequested)
	{
		switch(state)
		{
			case TcpReadyToSend: 
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
					state = TcpSend;
				break;
			case TcpSend:
				TCPPut(tsock1, 0x03);
				TCPPut(tsock1, amount>>24);
				TCPPut(tsock1, amount>>16);
				TCPPut(tsock1, amount>>8);
				TCPPut(tsock1, amount);
				TCPFlush(tsock1);
				state = ChangeRequested;	
				break;
		}
		network_worker();
	}
	
	while (state != ChangeRequestedDone)
	{
		if (TCPIsGetReady(tsock1))
		{
			TCPGet(tsock1, &ack);
			if (ack == 0)
			{
				TCPFlush(tsock1);
				state = TcpReadyToSend;
				return 4;
			}
			network_read_amount(); 
			TCPFlush(tsock1);
			state = ChangeRequestedDone;
			
		}
		network_worker();
	}
	state = TcpReadyToSend;
	return 0;
}

//request 4+5
char network_send_cancel_generic(char id)
{
	while(state != CancelDone)
	{
		switch (state)
		{
			case TcpReadyToSend: 
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
					state = TcpSend;
				break;
			case TcpSend:
				TCPPut(tsock1, id);
				TCPFlush(tsock1);
				state = CancelDone;

		}
		network_worker();
	}
	return network_read_ack();
}	

//Request ID 4
char network_send_cancel_last(void)
{
	return network_send_cancel_generic(0x04);	
}

//Request ID 5
char network_send_cancel_all(void)
{
	return network_send_cancel_generic(0x05);
}	

//Request ID 6
char network_send_goodbye(void)
{
	char ack;
	while( state != SockClosed)
	{
		switch (state)
		{
			case TcpReadyToSend: 
				if ( TCPIsConnected(tsock1) && TCPIsPutReady(tsock1) )
					state = TcpSend;
				break;
				
			case TcpSend:
				TCPPut( tsock1, 0x06 );
				TCPFlush( tsock1 );
				state = SockClosing;
				break;
			
			case SockClosing:
				ack = network_read_ack();
				TCPDisconnect( tsock1 );
				state = SockClosed;
				break;
		}
		network_worker();
	}
	if( TCPIsConnected(tsock1))
		return 3;				// Didn't close the socket properly;
	else
		return ack;
	
}	
void network_wait_for_dhcp()
{
	while (!DHCPIsBound())
		network_worker();
}