#include <engine_engine_number_9/baza_throw.h>
#include <engine_engine_number_9/running_mainloop.h>
#include <engine_engine_number_9/http_structures/response_gen.h>
#include <signal.h>
#include <engine_engine_number_9/connecting_assets/static_asset_manager.h>
#include <assert.h>
#include <sqlite3.h>
#include <jsonincpp/string_representation.h>
#include <libregexis024vm/vm_opcodes.h>
#include <engine_engine_number_9/form_data_structure/urlencoded_query.h>
#include <new_york_transit_line/templater.h>

bool termination = false;

void sigterm_action(int) {
    termination = true;
}

void usage(char** argv) {
    printf("Usage: %s <file with settings>\n", argv[0]);
    exit(1);
}

std::string unsafe_client_request_stringification(const een9::ClientRequest& req) {
    std::string text = "\n\nGot some cool stuff\n";
    text += (req.method + " " + req.uri_path + " " + req.http_version + "\n");
    for (auto& p: req.headers) {
        text += p.first; text += ": "; text += p.second; text += "\n";
    }
    text += "Body\n"; text += req.body; text += "\n";
    return text;
}

int main(int argc, char** argv){
    try {
        een9_ASSERT_pl(argc > 0);
        if (argc < 1 + 1)
            usage(argv);
        if (!een9::isRegularFile(argv[1]) || !een9::endsIn(argv[1], ".json")) {
            printf("\"%s\" is not a json file\n", argv[1]);
            usage(argv);
        }
        std::string config_file = argv[1];

        std::string config_text;
        een9::readFile(config_file, config_text);
        json::JSON config = json::parse_str_flawless(config_text);
        een9_ASSERT(config.isDictionary(), "config root is not dictionary");
        een9_ASSERT(config["assets"].g().isString(), "config[\"\assets\"] is not string");
        std::string assets_dir = config["assets"].g().asString();
        een9_ASSERT(een9::isDirectory(assets_dir), "\"" + assets_dir + "\" is not a directory");

        een9::StaticAssetManagerSlaveModule samI;
        samI.update({
            een9::StaticAssetManagerRule{assets_dir + "/css", "/assets/css", {{".css", "text/css"}} },
            een9::StaticAssetManagerRule{assets_dir + "/js", "/assets/js", {{".js", "text/js"}} },
            een9::StaticAssetManagerRule{assets_dir + "/img", "/assets/img", {
                {".jpg", "image/jpg"}, {".png", "image/png"}, {".svg", "image/svg+xml"}
            } },
        });

        json::JSON& config_presentation = config["presentation"].g();

        /* Because templaters use libjsonincpp, they can't be READ by two thread simultaneously */
        std::vector<std::unique_ptr<nytl::Templater>> templaters_copies(8);
        for (int i = 0; i < 8; i++) {
            templaters_copies[i] = std::make_unique<nytl::Templater>(
                nytl::TemplaterSettings{nytl::TemplaterDetourRules{assets_dir + "/HypertextPages"}});
            templaters_copies[i]->update();
        }

        // printf("%s\n", templaters_copies[0]->render("list-rooms", {&config_presentation}).c_str());
        // return 0;

        een9::MainloopParameters params;
        params.guest_core = [&samI, &templaters_copies, config_presentation]
        (const een9::SlaveTask& task, const een9::ClientRequest& req, een9::worker_id_t worker_id) -> std::string {
            een9_ASSERT_pl(0 <= worker_id && worker_id < templaters_copies.size());
            nytl::Templater& templater = *templaters_copies[worker_id];
            een9::StaticAsset sa;
            int ret;
            // printf("%s", unsafe_client_request_stringification(req).c_str());
            // if (req.uri_path == "/output") {
            //     std::string text = unsafe_client_request_stringification(req);
            //     return een9::form_http_server_response_200("text/plain", text);
            // }
            auto rteee = [&](const std::string& el_name, bool pass_phr) -> std::string {
                std::string page = templater.render(el_name,
                    pass_phr ? std::vector<const json::JSON*>{&config_presentation} : std::vector<const json::JSON*>{});
                return een9::form_http_server_response_200("text/html", page);
            };
            if (req.uri_path == "/" || req.uri_path == "/list-rooms") {
                return rteee("list-rooms", true);
            }
            if (req.uri_path == "/chat") {
                return rteee("chat", false);
            }
            if (req.uri_path == "/profile") {
                return rteee("profile", false);
            }
            if (req.uri_path == "/registration") {
                return rteee("registration", false);
            }
            /* Trying to interpret request as asset lookup */
            ret = samI.get_asset(req.uri_path, sa);
            if (ret >= 0) {
                return een9::form_http_server_response_200(sa.type, sa.content);
            }
            return een9::form_http_server_response_404("text/html", "<h1> Not found! </h1>");
        };

        params.ports_to_listen = {1025};
        params.slave_number = 8;
        params.open_admin_listener = false;

        signal(SIGINT, sigterm_action);
        signal(SIGTERM, sigterm_action);

        een9::electric_boogaloo(params, termination);
    } catch (std::exception& e) {
        printf("System failure\n%s\n", e.what());
    }
    return 0;
}