#ifndef SETTINGS_CPP
#define SETTINGS_CPP

#include "settings.h"
#include "well_known.h"
#include "log.h"
#include <mutex> // Include the mutex header

// Define mutexes for thread synchronization
std::mutex settingsMutex;
std::mutex logMutex;

int setting_virus_ctrl_virus_found_action = 0;
std::string setting_server_server_url = "nan";
std::string excluded_folders[1000];
int excluded_folders_size = 0;
std::string included_folders[1000];
int included_folders_size = 0;
bool setting_rtp_folder_scan_status = true; // 0=off, 1=on
bool setting_rtp_process_scan_status = true; // 0=off, 1=on
bool setting_virus_ctrl_virus_process_found_kill = true; // 0=do not kill, 1=kill
bool setting_communication_unsafe_tls = false; // 0=do not allow communication via unsafe, self-signed certs, 1=allow communication via unsafe, self-signed certs
int srv_log_timeout = 0;
int log_timeout_reset = 0;

void load_included_folders();
void load_excluded_folders();

int load_settings() {
    //std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings file operations

    std::ifstream file(SETTINGS_DB);

    if (!file.is_open()) {
        log(LOGLEVEL::ERR, "[load_settings()]: Could not open settings file. ", SETTINGS_DB);
        setting_server_server_url = "nan";
        return 1;
    }

    std::string settings_cmd, settings_arg;
    file>>settings_cmd;//the firs tline is our cert
    while (file >> settings_cmd) {
        file >> settings_arg;

        // Process settings
        //printf("aaaaaaaa,%s::,%s\n",settings_cmd.c_str(), settings_arg.c_str());
        if (settings_cmd == "virus_ctrl:virus_found:action") {
            if (settings_arg == "remove") {
                setting_virus_ctrl_virus_found_action = 1;
            }
            else if (settings_arg == "quarantine") {
                setting_virus_ctrl_virus_found_action = 2;
            }
            else if (settings_arg == "ignore") {
                setting_virus_ctrl_virus_found_action = 3;
            }
            else if (settings_arg == "call_srv") {
                setting_virus_ctrl_virus_found_action = 4;
            }
        }
        else if (settings_cmd == "server:server_url") {
            setting_server_server_url = settings_arg;
        }
        else if (settings_cmd == "rtp_folder_scan:status") {
            setting_rtp_folder_scan_status = (settings_arg == "true");
        }
        else if (settings_cmd == "rtp_process_scan:status") {
            setting_rtp_process_scan_status = (settings_arg == "true");
        }
        else if (settings_cmd == "communication:unsafe_tls") {
            setting_communication_unsafe_tls = (settings_arg == "allow");
        }
        else if (settings_cmd == "virus_ctrl:virus_process_found:kill") {
            setting_virus_ctrl_virus_process_found_kill = (settings_arg == "true");
        }
    }

    file.close();

    load_included_folders();
    load_excluded_folders();

    return 0;
}

// We have two different get_setting functions. One for int and one for std::string return values
int get_setting(const std::string& setting_name) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    if (setting_name == "virus_ctrl:virus_found:action") {
        return setting_virus_ctrl_virus_found_action;
    }
    if (setting_name == "virus_ctrl:virus_process_found:kill") {
        return setting_virus_ctrl_virus_process_found_kill;
    }
    else if (setting_name == "rtp_folder_scan:status") {
        return setting_rtp_folder_scan_status;
    }
    else if (setting_name == "rtp_process_scan:status") {
        return setting_rtp_process_scan_status;
    }
    else if (setting_name == "communication:unsafe_tls") {
        return setting_communication_unsafe_tls;
    }

    return -1;
}

std::string get_setting_string(const std::string& setting_name) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    if (setting_name == "server:server_url") {
        return setting_server_server_url;
    }

    return "nan";
}

void load_included_folders() {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    std::ifstream file(INCLUDED_FOLDERS);

    if (!file.is_open()) {
        log(LOGLEVEL::ERR, "[load_included_files()]: Could not open included folders file. ", INCLUDED_FOLDERS);
        return;
    }

    std::string line;
    std::getline(file, line); // Skip the first line
    while (std::getline(file, line)) {
        size_t start_pos = line.find('"'); // Find the position of the first double quote
        if (start_pos != std::string::npos) {
            size_t end_pos = line.find('"', start_pos + 1); // Find the position of the second double quote
            if (end_pos != std::string::npos) {
                std::string path = line.substr(start_pos + 1, end_pos - start_pos - 1); // Extract the path between double quotes
                included_folders[included_folders_size++] = path;
            }
        }
    }

    file.close();
}

void load_excluded_folders() {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    std::ifstream file(EXCLUDED_FOLDERS);

    if (!file.is_open()) {
        log(LOGLEVEL::ERR, "[load_included_files()]: Could not open excluded folders file. ", INCLUDED_FOLDERS);
        return;
    }

    std::string line;
    std::getline(file, line); // Skip the first line
    while (std::getline(file, line)) {
        size_t start_pos = line.find('"'); // Find the position of the first double quote
        if (start_pos != std::string::npos) {
            size_t end_pos = line.find('"', start_pos + 1); // Find the position of the second double quote
            if (end_pos != std::string::npos) {
                std::string path = line.substr(start_pos + 1, end_pos - start_pos - 1); // Extract the path between double quotes
                excluded_folders[excluded_folders_size++] = path;
            }
        }
    }

    file.close();
}

bool is_folder_included(const std::string& path) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    for (int i = 0; i < included_folders_size; i++) {
        if (path.find(included_folders[i]) != std::string::npos) {
            return true;
        }
    }
    return false;
}

bool is_folder_excluded(const std::string& path) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    for (int i = 0; i < excluded_folders_size; i++) {
        if (path.find(excluded_folders[i]) != std::string::npos) {
            return true;
        }
    }
    return false;
}

void print_inclusions() {
    std::lock_guard<std::mutex> lock(logMutex); // Lock access to log printing

    for (int i = 0; i < excluded_folders_size; i++) {
        log(LOGLEVEL::INFO, "[print_exclusions()]: Excluded folder: ", excluded_folders[i]);
    }
}

int log_timeout_get() {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    return srv_log_timeout;
}

void log_timeout_set(int timeout) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    srv_log_timeout = timeout;
}

void log_timeout_reset_set(int timeout) {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    log_timeout_reset = timeout;
}

int log_timeout_reset_get() {
    std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables

    return log_timeout_reset;
}

#endif // SETTINGS_CPP