#include "mbed.h"
#include <stdio.h>
#include <string.h>
#include "RHT03.h"
#include "WiflyInterface.h"

#define PORT   4446
#define READTIME 4
#define TIMEOUT 2000
#define ALLGOOD 3000
#define TOMUCH  1024

/* wifly object where:
*     - p28 and p27 are for the serial communication (p28 to pin3(UART_RX) on wifly)(p27 to pin2(UART_TX) on wifly)
*     - p26 is for the reset pin (p26 to pin5(RESET)on wifly)
*     - p25 is for the connection status (p25 to pin15(GPIO 6/SEN 7)on wifly)
*/

WiflyInterface wifly(p28, p27, p26, p25, "myssid", "mypassword", WPA);

TCPSocketServer svr;
bool serverIsListened = false;

TCPSocketConnection client;
bool clientIsConnected = false;

DigitalOut led1(LED1); //server listning status
DigitalOut led2(LED2); //socket connecting status
DigitalOut sensorLed(LED4); //sensor reading indicator
DigitalOut connectionTestLed(LED3); // wifly connection testing indicator

RHT03 humtemp(p24);  // DTH22 sensor on pin 24 with pull up resistor of 5k.

float temp,hum;
int readingAge = 0;

Ticker ledTick;
Ticker Sensors;
Ticker TestConnection;

void ledTickfunc()
{
    if(serverIsListened)  {
        led1 = !led1;
    } else {
        led1 = false;
    }
}

void Sensorsread()
{
    if(serverIsListened) {
        readingAge = readingAge + READTIME;
        sensorLed=true;
        if(humtemp.readData() == RHT_ERROR_NONE) {
            temp = humtemp.getTemperatureC(); //Gets the current temperature in centigrade
            hum = humtemp.getHumidity(); //Gets the current humidity in percentage
            readingAge = 0;
        }
        sensorLed=false;
    }
}

void TestWiflyConnection()
{
    bool test = true;
    connectionTestLed = test;
    if(!wifly.is_connected()) {
        if(wifly.cmdMode()) {
            wifly.sendCommand("ping i\r");  // note infact this code does not currently check the response of the wifly module 
            wifly.exit();                   // the response will need to be checked once i get this working!
            test = false;
        }
        connectionTestLed = test;
    }
}

int main (void)
{
    ledTick.attach(&ledTickfunc,1.0);
    Sensors.attach(&Sensorsread,READTIME);
    //TestConnection.attach(&TestWiflyConnection,60);

    printf("Starting Wifly!\r\n");
    //wifly.init(); // use DHCP
    wifly.init("192.168.0.120","255.255.255.0","192.168.0.10");  // use static ip address
    while (!wifly.connect()); // join the network
    printf("IP Address is %s\n\r", wifly.getIPAddress());
    printf("Wifly set comm idle 2 test %d\r\n",wifly.sendCommand("set comm idle 2"));
    // note this Wifly command "set comm idle 2" seems to make the issue of a browser stay connected, go away!
    // This command means time out on a tcp connection after 2 seconds!
    // This command does not seem to be in wifly.cpp initalization code so it is good to have here!
    printf("Wifly set comm time 200 test %d\r\n",wifly.sendCommand("set comm time 200"));
    // Note this Wifly command "set comm time 200" sets the time after tcp incomming message recieved will wait before sending packet.
    // This command means wait 200 ms.  This means packets are less fragmented from Wifly to Mbed via serial uart.
    // It seems in wifly.cpp there is a "set c t 20" so that means that this command here would force the wifly to increase its time so all good!
    
    TestWiflyConnection(); // not this is the command for testing the wifly connection to router and web but will only work if TCPSocketServer and TCPSocketConnection are disabled 
    
    //setup tcp socket
    svr.set_blocking(false,1500);
    //client.set_blocking(false);
    if(svr.bind(PORT)< 0) {
        printf("tcp server bind failed.\n\r");
        return -1;
    } else {
        printf("tcp server bind successed.\n\r");
        serverIsListened = true;
    }

    if(svr.listen(1) < 0) {
        printf("tcp server listen failed.\n\r");
        return -1;
    } else {
        printf("tcp server is listening...\n\r");
    }

    //listening for http GET request
    while (serverIsListened) {
        //no blocking mode is set above for both TCPSocketConnection and TCPSocketServer (not sure if they both need non blocking or just one needs to be set?)
        printf("About to wait for connection!\n\r");
        if(svr.accept(client)<0) {
            printf("no connection time to test wifly connection to router!\n\r");
            //******************************************************
            // Thought this would be the place for TestWiflyConnection() but on some kind of intermittent time basis.
            // Also i figured that the TCPSocketServer and TCPSocketConnection would need to be closed then restarted before and after TestWiflyConnection()
            // or the wifly module will be confused.
            // but it seems that this place in the code never gets executed in blocking or nonblocking because the svr.accept(client) never returns -1 unless the wifly module has some issue!
            // So i am confused what blocking and non blocking are even for with the wifly module.  It seems that i might just need to scrap the complete new tcp stack stuff 
            // and control the wifly module myself and make my own tcp stack interface to the wifly module!
            //**************************************************
        } else {
            printf("connection success!\n\rIP: %s\n\r",client.get_address());
            clientIsConnected = true;
            led2 = true;
            char buffer[1024] = {};
            int checkRecieve = 0;
            Timer timeOut;
            timeOut.start();
            while(clientIsConnected) {
                char temp[256] = {};
                checkRecieve = client.receive(temp,255);
                //printf("Recieved: %d\r\n%s\r\n",strlen(temp),temp);
                strcat(buffer,temp);
                if(timeOut.read_ms()>2000) {
                    // i am goint to presume here that after 2 second i will not continue anyways!
                    printf("Message end not recieved in time out allowed! Connection presummed stalled!\r\n");
                    printf("Buffer currently: %d\r\n%s\r\n",strlen(buffer),buffer);
                    timeOut.stop();
                    clientIsConnected = false;
                    led2 = false;
                    checkRecieve = TIMEOUT;
                }
                if(checkRecieve == -1) {
                    printf("failed to read data from client.\r\n");
                    clientIsConnected = false;
                    led2 = false;
                }
                if(strlen(buffer)>1023) {
                    printf("Recieved message too large from client!\r\n");
                    clientIsConnected = false;
                    led2 = false;
                    checkRecieve = TOMUCH;
                }
                if(strstr(buffer, "\r\n\r\n")) {
                    printf("Recieved terminator in message!\r\n");
                    clientIsConnected = false;
                    led2 = false;
                    checkRecieve = ALLGOOD;
                }
            }
            if (checkRecieve == ALLGOOD) {
                if(buffer[0] == 'G' && buffer[1] == 'E' && buffer[2] == 'T') {
                    if(buffer[4] == '/' && buffer[5] == ' ') {
                        printf("GET / incomming.\n\r");
                        //setup http response header & data
                        char sendHeader[256] = {};
                        char sendMessage[256] = {};
                        sprintf(sendMessage,"<!DOCTYPE html><html><HEAD><TITLE>Temp Humd CO2</TITLE></HEAD><body>Temp: %2.1f<br>Humd: %2.1f<br>Age: %2ds<br></body></html>\r\n\r\n",temp,hum,readingAge);
                        sprintf(sendHeader,"HTTP/1.0 200 OK\r\nContent-Length: %d\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n",strlen(sendMessage));
                        client.send(sendHeader,strlen(sendHeader));
                        client.send(sendMessage,strlen(sendMessage));

                        clientIsConnected = false;
                        led2 = false;
                        printf("Header %s\r\n",sendHeader);
                        printf("Message %s\r\n",sendMessage);
                    }

                } else {
                    printf("Get not recieved!");
                    clientIsConnected = false;
                    led2 = false;
                }
            }
            printf("Recieved %d\r\n%s\r\n",strlen(buffer),buffer);
        }
        printf("close connection.\n\rtcp server is listening...\n\r");
        client.close();
        led2 = false;
    }
}