// This file is part of Timmi.
//
// Timmi is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <cstdlib>
#include <timmiprotocol.hh>
#include <readlineclient.hh>
#include <utils.hh>
#include <locale.h>
#include <unistd.h>
#include <timmiai.hh>

struct Settings {
    std::string server;
    int port;
    std::string name;
    bool verbose;
    bool ai;
};

void show_usage(std::string progname) {
    std::cerr << "Usage: ";
    std::cerr << progname << " [options] host port" << std::endl;
    std::cerr << std::endl << "Options:" << std::endl;
    std::cerr << "-ai       Start an AI instead of the client" << std::endl;
    std::cerr << "-n name   Set name" << std::endl;
    std::cerr << "-v        Show verbose debug messages" << std::endl;
}

bool parse_settings(int argc, char *argv[], Settings &result) {
    bool unknown_option = false;
    bool missing_argument = false;
    int i;
    std::string opt("");
    for (i = 1; i < argc; i++) {
        opt = std::string(argv[i]);
        std::string arg("");
        bool has_arg = (i + 1 < argc);
        if (has_arg) {
            arg = std::string(argv[i + 1]);
        }
        
        if (opt == "-v") {
            result.verbose = true;
        } else if (opt == "-ai") {
            result.ai = true;
        } else if (opt == "-n") {
            if (!has_arg) {
                missing_argument = true;
                break;
            } else {
                result.name = arg;
                i++;
            }
        } else {
            if (result.server == "") {
                result.server = opt;
            } else if (result.port == 0) {
                result.port = strtoi(opt);
                if (result.port == 0) {
                    unknown_option = true;
                    break;
                }
            } else {
                unknown_option = true;
                break;
            }
        }
    }
    
    if (missing_argument) {
        std::cerr << "Missing argument for " << opt << std::endl;
    } else if (unknown_option) {
        std::cerr << "Unknown option " << opt << std::endl;
    } else if (result.server == "" || result.port == 0) {
        std::cerr << "Host or port missing" << std::endl;
    } else {
        return true;
    }
    
    show_usage(argv[0]);
    return false;
}

int main(int argc, char *argv[]) {
    setlocale(LC_CTYPE, "");
    
    Settings settings = {"", 0, getlogin(), false};
    if (!parse_settings(argc, argv, settings)) {
        return EXIT_FAILURE;
    }

    std::cout << "This is readline-based Timmiclient, part of Timmi ";
    std::cout << TIMMI_VERSION << std::endl;
    std::cout << "Licensed under GNU General Public License v3 or later" << std::endl;
    
    simple_iconv(settings.name, "", settings.name, "UTF-8", true);
    
    if (!settings.ai) {
        ERRORLEVEL = settings.verbose ? VERBOSE : WARNING;
    
        ReadlineClient client(settings.name);
        
        client.connect_socket(settings.server, settings.port);
        if (client.good()) {
            client.mainloop();
        }
    } else {
        ERRORLEVEL = settings.verbose ? VERBOSE : INFO;
    
        TimmiAI client(settings.name);
        
        client.connect_socket(settings.server, settings.port);
        if (client.good()) {
            client.mainloop();
        }
    }
    
    return EXIT_SUCCESS;
}