#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

// open ssl
#include <openssl/conf.h>
#include <openssl/evp.h>
#include <openssl/err.h>

#include <errno.h> // for perror()
#include <unistd.h> // for close()

// load environment variables from .env file
#include <fstream>
#include <cstdlib>

void load_env(const std::string& path) {
    std::ifstream f(path);
    std::string line;
    while (std::getline(f, line)) {
        if (line.empty() || line[0] == '#') continue;
        auto pos = line.find('=');
        if (pos == std::string::npos) continue;

        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 1);

        #ifdef _WIN32
                _putenv_s(key.c_str(), val.c_str());
        #else
                setenv(key.c_str(), val.c_str(), 1);
        #endif
    }
}

// hex to byte helper function
int hex_to_bytes_upper(const char* hex, unsigned char* out, size_t out_size)
{
    size_t i = 0;
    while (hex[0] && hex[1]) {
        if (i >= out_size) return -1;
        unsigned char h = hex[0];
        unsigned char l = hex[1];
        int hi = (h <= '9') ? (h - '0') : (h - 'A' + 10);
        int lo = (l <= '9') ? (l - '0') : (l - 'A' + 10);
        // minimal sanity check
        if (hi < 0 || hi > 15 || lo < 0 || lo > 15)
            return -1;
        out[i++] = (unsigned char)((hi << 4) | lo);
        hex += 2;
    }
    return (int)i;
}

// Define the decryption function
int block_decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext) {
    /* Declare cipher context */
    EVP_CIPHER_CTX *ctx;
    int len, plaintext_len;

    /* Create and initialise the context */
    ctx = EVP_CIPHER_CTX_new();
    if (!ctx) {
        ERR_print_errors_fp(stderr);
    }

    /* Initialise the decryption operation. */
    if (EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv) != 1){
        ERR_print_errors_fp(stderr);
    }

    /* Provide the message to be decrypted, and obtain the plaintext output. EVP_DecryptUpdate can be called multiple times if necessary */
    if (EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len) != 1) {
        ERR_print_errors_fp(stderr);
    }

    /* Finalize the decryption. Further plaintext bytes may be written at this stage. */
    if (EVP_DecryptFinal_ex(ctx, plaintext + len, &plaintext_len) != 1) {
        ERR_print_errors_fp(stderr);
    }

    /* Clean up */
    EVP_CIPHER_CTX_free(ctx);

    return plaintext_len;
}

int main(void){
    printf("Server starting...\n");
    load_env(".env");

    // Declare variables
    const char *server_ip = std::getenv("SERVER_IP");
    const int server_port = std::atoi(std::getenv("SERVER_PORT"));
    char client_message[2048];
    char server_message[2048];
    const char * custom_message="Server: Hello from server, message recieved!\n";

    // decryption parameters
    const char *inital_vector = std::getenv("INITIAL_VECTOR");
    const char *secret_key = std::getenv("SECRET_KEY");
    unsigned char key_bytes[32], iv_bytes[16];
    
    int key_len = hex_to_bytes_upper(secret_key, key_bytes, sizeof(key_bytes));
    int iv_len  = hex_to_bytes_upper(inital_vector, iv_bytes, sizeof(iv_bytes));

    if (key_len != 32 || iv_len != 16) {
        fprintf(stderr, "Invalid key/IV size for AES-256\n");
        return 1;
    }

    // debug
    printf("Server starting at IP: %s, Port: %d\n", server_ip, server_port);

    // Create socket
    const int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Failed to create socket");
        return 1;
    }

    // Bind to the set port and IP
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    inet_pton(AF_INET, server_ip, &server_addr.sin_addr);

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("Failed to bind socket");
        close(server_socket);
        return 1;
    }
    printf("Done with binding with IP: %s, Port: %d\n", server_ip, server_port);

    // Listen for clients:
    const char *client_ip = std::getenv("CLIENT_IP");
    if (listen(server_socket, 1) == -1) {
        perror("Failed to listen on socket");
        close(server_socket);
        return 1;
    }
    printf("Listening for incoming connections...\n");

    // Accept an incoming connection
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addr_len);
    if (client_socket == -1) {
        perror("Failed to accept connection");
        close(server_socket);
        return 1;
    }
    printf("Client connected at IP: %s \n", client_ip);

    // clean exising buffer
    memset(client_message, 0, sizeof(client_message));

    // Receive client's message
    while (1) {
        // clean exising buffer
        memset(client_message, 0, sizeof(client_message));

        ssize_t n = recv(client_socket, client_message, sizeof(client_message), 0);
        if (n == 0) break;
        if (n < 0) { perror("recv"); break; }

        // decrypt client message
        unsigned char plaintext[2048];
        int plaintext_len = block_decrypt((unsigned char*)client_message, (int)n, key_bytes, iv_bytes, plaintext);
        if (plaintext_len < 0) {
            fprintf(stderr, "decrypt failed\n");
            break;
        }

        if (plaintext_len >= (int)sizeof(plaintext)) plaintext_len = (int)sizeof(plaintext) - 1;
        plaintext[plaintext_len] = '\0';

        if (strcmp((char*)plaintext, "\\exit\n") == 0) break;

        printf("Msg from client: %s", plaintext);

        // Respond to client
        // prepare server message
        memcpy(server_message, custom_message, strlen(custom_message));

        size_t reply_len = strlen(server_message);
        if (send(client_socket, server_message, reply_len, 0) == -1) {
            perror("Send failed");
            break;
        }

        printf("Response sent to client: %s\n", server_message);
    }
    // Close the socket
    close(client_socket);
    close(server_socket);

    return 0;
}