// Copyright (c) 2018 The Swedish Internet Foundation
// Written by Göran Andersson <initgoran@gmail.com>

#ifdef _WIN32
#include <windows.h>
#include <direct.h>
#define mkdir(x) _mkdir(x)
#else
#include <csignal>
#include <unistd.h>
#include <sys/stat.h>
#endif
#include <cstdlib>
#include <cerrno>
#include <iostream>
#include <fstream>
#include "utils.h"
#include "../framework/taskconfig.h"
#include "../measurement/defs.h"
#include "../http/sha1.h"
#include "../framework/logger.h"
#include <vector>

namespace {
#ifdef _WIN32
    std::string pathSep = "\\";
#else
    std::string pathSep = "/";
#endif
}

std::string createAndGetAppDir(std::string dir) {
    std::string home;
#ifdef _WIN32
    if (dir.empty()) {
        if (!std::getenv("HOMEDRIVE") || !std::getenv("HOMEPATH"))
            return "";
        home = std::string(std::getenv("HOMEDRIVE")) + std::getenv("HOMEPATH");
        dir = home + "\\.bredbandskollen";
    }
    _mkdir(dir.c_str());
#else
    if (dir.empty()) {
        if (!std::getenv("HOME"))
            return "";
        home = std::getenv("HOME");
        dir = home + "/.bredbandskollen";
    }
    int status = mkdir(dir.c_str(), 0755);
    if (status && errno != EEXIST) {
        return "";
    }
#endif

#ifdef IS_SANDBOXED
    if (!home.empty())
        chdir(home.c_str());
#endif

    return dir + pathSep;
}

enum class CliMode { NONE, LIVE, TEST, LOCAL,
#if defined(RUN_SERVER)
                     SERVER,
#endif
                     IN_ERROR } ;

bool parseArgs(int argc, char *argv[],
               TaskConfig &client_cfg, TaskConfig &agent_cfg) {

    CliMode mode = CliMode::NONE;

    client_cfg.set("port", "80");
    client_cfg.set("mtype", "ipv4");
    client_cfg.set("listen_addr", "127.0.0.1");

    agent_cfg.add("Measure.Webserver", "frontend.bredbandskollen.se");
    agent_cfg.add("Measure.SettingsUrl", "/api/servers");
    agent_cfg.add("Measure.ContentsUrl", "/api/content");
    agent_cfg.add("Measure.MeasurementsUrl", "/api/measurements");

    for (int i=1; i<argc; ++i) {
        std::string arg(argv[i]);
        if (arg == "--v6") {
            client_cfg.set("mtype", "ipv6");
            client_cfg.set("Measure.IpType", "override");
        } else if (arg == "--v4") {
            client_cfg.set("mtype", "ipv4");
            client_cfg.set("Measure.IpType", "override");
        } else if (arg == "--test") {
            mode = (mode == CliMode::NONE) ? CliMode::TEST : CliMode::IN_ERROR;
        } else if (arg == "--live") {
            mode = (mode == CliMode::NONE) ? CliMode::LIVE : CliMode::IN_ERROR;
        } else if (arg == "--version") {
            std::cout << measurement::appName << ' '
                      << measurement::appVersion << '\n';
            return false;
        } else if (arg == "--quiet") {
            client_cfg.set("quiet", "1");
        } else if (arg == "--csv") {
            client_cfg.set("quiet", "1");
            client_cfg.set("limiter", ",");
        } else if (arg == "--local") {
            mode = (mode == CliMode::NONE) ? CliMode::LOCAL : CliMode::IN_ERROR;
#if defined(RUN_SERVER)
        } else if (arg == "--run-server") {
            mode = (mode == CliMode::NONE) ? CliMode::SERVER : CliMode::IN_ERROR;
#endif
        } else if (arg.substr(0, 11) == "--duration=") {
            agent_cfg.set("Measure.LoadDuration",  argv[i]+11);
            client_cfg.set("Measure.LoadDuration", "override");
        } else if (arg.substr(0, 13) == "--speedlimit=") {
            agent_cfg.set("Measure.SpeedLimit", argv[i]+13);
            client_cfg.set("Measure.SpeedLimit", "override");
        } else if (arg.substr(0, 6) == "--out=")
            client_cfg.set("out", argv[i]+6);
        else if (arg.substr(0, 6) == "--dir=")
            client_cfg.set("app_dir", (argv[i]+6) + pathSep);
        else if (arg.substr(0, 6) == "--log=")
            client_cfg.set("logfile", argv[i]+6);
        else if (arg.substr(0, 11) == "--local-ip=")
            agent_cfg.set("Measure.LocalAddress", argv[i]+11);
        else if (arg.substr(0, 9) == "--server=")
            client_cfg.set("server", argv[i]+9);
        else if (arg.substr(0, 7) == "--port=")
            client_cfg.set("port", argv[i]+7);
        else if (arg.substr(0, 12) == "--configure=")
            client_cfg.add("configure", argv[i]+12);
        else if (arg.substr(0, 9) == "--listen=")
            client_cfg.set("listen", argv[i]+9);
        else if (arg.substr(0, 14) == "--listen-addr=")
            client_cfg.set("listen_addr", argv[i]+14);
        else if (arg.substr(0, 12) == "--listen-pw=") {
            client_cfg.set("listen_pw", argv[i]+12);
#ifdef USE_GNUTLS
        } else if (arg == "--ssl") {
            agent_cfg.set("Measure.TLS", "1");
            client_cfg.set("ssl", "1");
            if (client_cfg.value("port") == "80")
                client_cfg.set("port", "443");
#endif
        } else if (arg.substr(0, 9) == "--fakeip=")
            agent_cfg.set("Client.fakeip", argv[i]+9);
        else if (arg == "--check-servers")
            client_cfg.set("pingsweep", "1");
        else if (arg.substr(0, 14) == "--measurements")
            client_cfg.set("list_measurements",
                (arg.size() > 15 && arg[14] == '=') ? argv[i]+15 : "10");
        else if (arg.substr(0, 10) == "--from-id=") {
            client_cfg.set("list_from", argv[i]+10);
            if (client_cfg.value("list_measurements").empty())
                client_cfg.set("list_measurements", "10");
        } else if (arg == "--browser") {
            client_cfg.set("browser", "1");
            if (client_cfg.value("listen").empty())
                client_cfg.set("listen", "0"); // Use any avaliable port
        } else if (arg.substr(0, 13) == "--proxy-host=")
            agent_cfg.set("Measure.ProxyServerUrl", argv[i]+13);
        else if (arg.substr(0, 13) == "--proxy-port=")
            agent_cfg.set("Measure.ProxyServerPort", argv[i]+13);
        else {
            int status = 0;
            if (arg != "--help") {
                status = 1;
                std::cerr << argv[0] << ": invalid argument -- " << arg << std::endl;
            }
            std::ostream &fh = status ? std::cerr : std::cout;
            fh << "Usage: " << argv[0] << " [OPTION]...\n\nOptions:\n\n"
                  "  --help              Show this help text\n"
                  "  --version           Print version number and exit\n"
               << "\nNetwork related options:\n"
#ifndef BBK_WEBVIEW
               << "  --v6                Prefer IPv6 (default is IPv4)\n"
#endif
#ifdef __linux__
#else
               << "  --local-ip=IP       Measure using existing local ip address IP\n"
               << "                      Note: this will not work on all platforms\n"
#endif
               << "  --proxy-host=HOST   Use HTTP proxy server HOST\n"
               << "  --proxy-port=PORT   Use port PORT on proxy server (default 80)\n"
               << "\nMeasurement configuration:\n"
#ifndef BBK_WEBVIEW
               << "  --server=HOST       Use HOST as measurement server\n"
               << "  --port=N            Port number for measurement server, default 80\n"
#endif
#ifdef USE_GNUTLS
               << "  --ssl               Measure using transport layer security (default port 443)\n"
#endif
               << "  --duration=N        Measure upload/download for N seconds (2-10, default 10)\n"
               << "  --speedlimit=N      Keep upload/download speed below N mbps on average\n"
               << "\nMeasurement type:\n"
               << "  --live              Measure using Bredbandskollen's live servers (default)\n"
               << "  --test              Measure using Bredbandskollen's development servers\n"
#ifndef BBK_WEBVIEW
               << "  --local             Don't fetch configuration (server list) from bredbandskollen.se,\n"
               << "                      communicate only with server given by the --server option.\n"
#endif
#if defined(RUN_SERVER)
               << "  --run-server        Run as a measurement server (requires option --listen=PORT)\n"
#endif
               << "\nLogging:\n"
               << "  --log=FILENAME      Write debug log to FILENAME\n"
               << "                      (log to stderr if FILENAME is -)\n"
#ifndef BBK_WEBVIEW
               << "\nFinding measurement servers:\n"
               << "  --check-servers     Find closest measurement server\n"
               << "\nList previous measurements:\n"
               << "  --measurements      List 10 last measurements\n"
               << "  --measurements=N    List N last measurements\n"
               << "                      If --quiet, output will be JSON. Otherwise\n"
               << "                      output will be lines with tab separated fields.\n"
               << "  --from-id=N         List only measurements before ID N\n"
               << "\nBrowser interface:\n"
               << "  --browser           Use a web browser as interface\n"
               << "  --listen=PORT       Use web browser as interface;\n"
               << "                      the browser must connect to the given PORT\n"
               << "  --listen-addr=IP    When listening, bind socket to ip address IP\n"
               << "                      (default is 127.0.0.1) to use a web browser on\n"
               << "                      a remote host as interface\n"
               << "                      Note: this may not work due to e.g. firewalls.\n"
               << "                      Don't use it unless you know what you are doing.\n"
               << "  --listen-pw=PW      Use PW as a one-time password when connecting from browser\n"
               << "                      Note: DO NOT reuse a sensitive password here!\n"
               << "                      It is better to omit this option because by default\n"
               << "                      a secure one-time password will be generated.\n"
               << "\nCommand line interface:\n"
               << "  --quiet             Write a single line of output\n"
               << "  --csv               Write a single line of output, comma separated\n"
               << "  --out=FILENAME      Append output to FILENAME instead of stdout\n"
#endif
               << std::endl;
            return false;
        }
    }

    client_cfg.set("app_dir", createAndGetAppDir(client_cfg.value("app_dir")));

    if (client_cfg.value("local") == "1" && client_cfg.value("server").empty()) {
        std::cerr << "missing --server option" << std::endl;
        return false;
    }

    std::vector<std::string> pdir = { "listen", "port" };
    for (auto &str : pdir)
        if (!client_cfg.value(str).empty()) {
            auto port = client_cfg.value(str);
            if (port.find_first_not_of("0123456789") != std::string::npos ||
                port.size() > 5 || std::stod(port) > 65535) {
                std::cerr << "invalid port number" << std::endl;
                return false;
            }
        }

    switch (mode) {
    case CliMode::NONE:
    case CliMode::LIVE:
        agent_cfg.set("Measure.Webserver", "frontend.bredbandskollen.se");
        break;
    case CliMode::TEST:
        agent_cfg.set("Measure.Webserver", "frontend-beta.bredbandskollen.se");
        break;
    case CliMode::LOCAL:
        client_cfg.set("local", "1");
        agent_cfg.set("Measure.Webserver", "none");
        break;
#if defined(RUN_SERVER)
    case CliMode::SERVER:
        client_cfg.set("local", "1");
        client_cfg.set("run_server", "1");
        if (client_cfg.value("listen").empty()) {
            std::cerr << "option --listen is required with --run-server"
                      << std::endl;
            return false;
        }
        break;
#endif
    case CliMode::IN_ERROR:
        std::cerr << "can have only one of options --live, --test,";
#if defined(RUN_SERVER)
        std::cerr << " --run-server,";
#endif
        std::cerr << " and --local";
        return false;
    }

    if (!client_cfg.value("listen").empty() &&
        client_cfg.value("listen_pw").empty()) {
        client_cfg.add("listen_pw", Logger::createHashKey(12));
    }
    client_cfg.add("url", "http://" + agent_cfg.value("Measure.Webserver") +
                   "/standalone/dev/index.php");

    if (client_cfg.value("logfile").empty()) {
#if defined(RUN_SERVER)
        if (mode == CliMode::SERVER)
            client_cfg.add("logfile", client_cfg.value("app_dir") + "server_log");
        else
#endif
            client_cfg.add("logfile", client_cfg.value("app_dir") + "last_log");
    }
    client_cfg.set("config_file", client_cfg.value("app_dir") + "config");
    agent_cfg.set("options_file", client_cfg.value("app_dir") + "ConfigOptions.txt");

    // Default to ipv6 if user wants to use a local ipv6 address
    if (agent_cfg.value("Measure.LocalAddress").find(':') !=
        std::string::npos) {
        client_cfg.set("mtype", "ipv6");
        client_cfg.set("Measure.IpType", "override");
    }

    agent_cfg.add("Measure.AutoSaveReport",
                  client_cfg.value("listen").empty() ? "false" : "true");

    agent_cfg.add("Measure.IpType", client_cfg.value("mtype"));

    agent_cfg.add("Client.appname", measurement::appName);
    agent_cfg.add("Client.appver", measurement::appVersion);
    agent_cfg.add("Client.machine", measurement::hw_info);
    agent_cfg.add("Client.system", measurement::os_version);
    agent_cfg.add("Client.language", "en");

    return true;
}