#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <bits/stdc++.h>
#include <arpa/inet.h>
#include <signal.h>
#include <pthread.h>
#include <unistd.h>
#include "Request.h"

//#define ROOT "/home/karfass/Networks/SimpleHTTPClient-Sever"

#define BUFFER_SIZE 1024
const std::string  OK_MSG = "HTTP/1.1 200 OK";
const std::string CONTENT_TYPE = "Content-Type:";
const std::string CONTENT_LEN = "Content-length:";
const std::string NOT_FOUND = "HTTP/1.1 404 Not Found";
const std::string CONNECTION = "Connection: Keep-Alive";
const std::string END = "\r\n";
std::string ROOT;

using namespace std;

void message(const char* msg, bool exi) {
    perror(msg);
    if (exi) exit(-1);
}

int openServer(const int portNumber) {

    struct sockaddr_in serverAddress;
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket < 0) {
        message("Error in creating socket", true);
    }
    bzero(&serverAddress, sizeof(serverAddress));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_addr.s_addr =  INADDR_ANY;
    serverAddress.sin_port = htons(portNumber);
    if (bind(serverSocket, (struct sockaddr *) &serverAddress, sizeof(serverAddress)) < 0) {
        message("Error in binding", true);
    }
    if (listen(serverSocket, 300) < 0) {
        message("Problem in listening in server socket", true);
    }
    return serverSocket;
}


void handleGetRequest(Request request, int client) {
    std::string fileName = request.getField(FILE_NAME);
    std::string extension = utility::getExtension(fileName);
    char buffer[BUFFER_SIZE];
    bzero(buffer, sizeof(buffer));
    if(!utility::isFileExists(ROOT + fileName)) {
        strcpy(buffer, (NOT_FOUND + END + CONTENT_LEN + " " + "0" + END + CONNECTION + END + END).c_str());
        send(client, buffer, sizeof(buffer), 0);
        return;
    }
    std::string fileContent = utility::readFile(ROOT + fileName);
    std::string response = OK_MSG + END + CONTENT_TYPE + " " + extension + END + CONTENT_LEN + " " +
            std::to_string(fileContent.size()) + END + CONNECTION + END + END + fileContent;
    int i = 0;
    while(i < response.size()) {
        if(i % BUFFER_SIZE == 0 && i != 0) {
            send(client, buffer, sizeof(buffer), 0);
            bzero(buffer, sizeof(buffer));
        }
        buffer[i % BUFFER_SIZE] = response[i];
        i++;
    }
    send(client, buffer, sizeof(buffer), 0);
}

void handlePostRequest(Request request, int client){
    std::string fileName = request.getField(FILE_NAME);
    std::ofstream outputFile(ROOT + fileName);
    char buffer[BUFFER_SIZE];
    strcpy(buffer, OK_MSG.c_str());
    send(client, buffer, sizeof(buffer), 0);
    int size = utility::extractNumber(utility::trim(request.getField(CONTENT_LEN)));
    while(size > 0) {
        int sizeRead = recv(client, buffer, sizeof(buffer), 0);
        size -= sizeRead;
        outputFile.write(buffer, size);
    }
}


void* serve(void* clientAddr) {
//    time_t lastTimeEvoked = time(0);
//    tm *ltm = localtime(&lastTimeEvoked);
//    time_t current = time(0);
//    tm *ctm = localtime(&current);
    int client = *((int *) clientAddr);
    fd_set readfds;
    struct timeval tv;
    FD_ZERO(&readfds);
    FD_SET(client, &readfds);
    tv.tv_sec = 20;
    tv.tv_usec = 500000;

    while (true) {

        int rv = select(client + 1, &readfds, NULL, NULL, &tv);
//        cout<<"still after select connected\n";
        char buffer[BUFFER_SIZE];
        bzero(buffer, sizeof(buffer));
        if (rv == -1) {
            cout<<"error\n";
            perror("select"); // error occurred in select()
        } else if (rv == 0) {
            printf("Timeout occurred!  No data after 20.5 seconds.\n");
            break;
        } else {
            // one or both of the descriptors have data
            if (FD_ISSET(client, &readfds)) {
                int bytes_read = recv(client, buffer, sizeof buffer, 0);
                cout<< bytes_read << endl;
                if (bytes_read > 0) {
                    std::string requestStr(buffer);
                    Request request(requestStr);
                    if (request.getRequestType() == "GET") {
                        handleGetRequest(request, client);
                    } else if (request.getRequestType() == "POST") {
                        handlePostRequest(request, client);
                    }
                } else if (bytes_read < 0) {
                    message("Problem with recv call", false);
                }
            }

        }
//        int bytes_read = recv(client, buffer, sizeof(buffer), MSG_DONTWAIT);
//       cout<<"still\n";
    }
    cout<<"finish"<<endl;
   int rc = close(client);
   pthread_exit(0);
}


int main(int arg, char** argv) {
    struct sockaddr_in clientAddress;
    socklen_t size = sizeof(clientAddress);
    int portNumber = 8000;
    if (arg < 2) {
        ROOT = "/home/karfass/Networks/SimpleHTTPClient-Sever";

    } else {
        ROOT = argv[1];
        portNumber = atoi(argv[2]);
    }
    int sock = openServer(portNumber);
    while (true) {
        int client = accept(sock, (struct sockaddr *) &clientAddress, &size);
        cout << "accept" << endl;
        if (client < 0) {
            message("Problem accepting client", true);
        }
        pthread_t tid;
        int flag = pthread_create(&tid, NULL, serve, &client);
        if (flag < 0) {
            message("Problem creating thread", false);
        }
    }
    return 0;
}