#include "image.hpp"
#include "state.hpp"

#include <chrono>
#include <cstdlib>
#include <iostream>
#include <string>
#include <arpa/inet.h>
#include <unistd.h>
#include <mutex>
#include <thread>
#include <condition_variable>

using namespace std;

uint16_t PORT = 8081;
int BUFFER_SIZE = 1024;

Image img;
State state;

bool receivedMessage = false;
bool sendMessage = false;
string incomingMessage;
string outgoingMessage;

mutex receivedMutex;
condition_variable receivedCondVar;

mutex sendMutex;
condition_variable sendCondVar;

void performAction () {
    if (receivedMessage) {
    	cout << "RECEIVED" << endl;
    	state.receiveMessage(incomingMessage);
    	receivedMessage = false;
    	if (state.isError()) {
			outgoingMessage = state.createMessage(false);
		} else {
			outgoingMessage = state.createMessage(true);
		}
		sendMessage = true;
    }
}

void handleTCPConnection(int clientSocket) {
    char buffer[BUFFER_SIZE];
    memset(buffer, 0, BUFFER_SIZE);

    while (true) {
        int bytesRead = recv(clientSocket, buffer, BUFFER_SIZE - 1, 0);
        if (bytesRead <= 0) {
            // Client disconnected or error occurred
            break;
        }

        std::string iMessage(buffer, bytesRead);

        {
            lock_guard<mutex> lock(receivedMutex);
            receivedMessage = true;
            incomingMessage = iMessage;
            receivedCondVar.notify_all();
        }

        performAction();

        bool localSendMessage;
        string localOutgoingMessage;

    	{
        	unique_lock<mutex> lock(sendMutex);
        	sendCondVar.wait(lock, [&] { return sendMessage; });
        	localSendMessage = sendMessage;
        	localOutgoingMessage = outgoingMessage;
    	}

        if (localSendMessage) {
        	const char* msg = localOutgoingMessage.c_str();
	        int bytesSent = send(clientSocket, msg, strlen(msg), 0);
	        if (bytesSent < 0) {
	            std::cerr << "Error sending ACK to client" << std::endl;
	            break;
	        }
	    }

        memset(buffer, 0, BUFFER_SIZE);
    }
}

void runTCPServer (int serverSocket) {
	while (true) {
        struct sockaddr_in clientAddr;
        socklen_t clientAddrLen = sizeof(clientAddr);

        int clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrLen);
        if (clientSocket < 0) {
            std::cerr << "Error accepting client connection" << std::endl;
            continue;
        }

        cout << "New client connected" << endl;

        handleTCPConnection(clientSocket);
    }
}

int main (int argc, char** argv) {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket < 0) {
        cerr << "Error creating socket" << endl;
        return 1;
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(PORT);

    int bindResult = ::bind(serverSocket, reinterpret_cast<struct sockaddr*>(&serverAddr), sizeof(serverAddr));
    if (bindResult < 0) {
        std::cerr << "Error binding socket" << std::endl;
        close(serverSocket);
        return 1;
    }

    if (listen(serverSocket, 5) < 0) {
        cerr << "Error listening on socket" << endl;
        return 1;
    }

    cout << "TCP server listening on port " << PORT << endl;

    thread serverThread(runTCPServer, serverSocket);

    serverThread.join();
    close(serverSocket);

	return 0;
}