//Copyright 2022, FOSS-VG Developers and Contributers
//
// Author(s):
//   BodgeMaster, Shwoomple
//
//This program is free software: you can redistribute it and/or modify it
//under the terms of the GNU Affero General Public License as published
//by the Free Software Foundation, version 3.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied
//warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//See the GNU Affero General Public License for more details.
//
//You should have received a copy of the GNU Affero General Public License
//version 3 along with this program.
//If not, see https://www.gnu.org/licenses/agpl-3.0.en.html

#include <csignal>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <string>
#include <sockpp/tcp_acceptor.h>
#include <sockpp/tcp_connector.h>
#include <thread>
#include <vector>

#include "../lib/cli.hpp"
#include "../lib/error.hpp"

#define EXIT_SUCCESS 0
#define EXIT_RUNTIME 1
#define EXIT_USAGE 2
#define EXIT_UNIMPLEMENTED 3

// TCP v4 server
sockpp::tcp_socket tcpSocket;
sockpp::tcp_acceptor tcpAcceptor;
// TCP v4 client
sockpp::tcp_connector tcpConnector;

bool exitProgram = false;

bool ipv4 = false;
bool ipv6 = false;
bool tcp = false;
bool udp = false;
bool outgoing = false;
std::string host;
in_port_t port;

void signalHandler(int signal) {
    // shut down gracefully
    exitProgram = true;

    // tell sockpp to close TCP socket if open because it blocks when trying
    // to read and there is no data
    tcpAcceptor.shutdown();
    if (tcpSocket) {
        tcpSocket.shutdown(SHUT_RD);
    }

    std::cerr << "Received signal " << signal << ", bye!" << std::endl;
    std::exit(signal);
}

void readFromTCPSocket() {
    ssize_t byteCount;
    uint8_t buffer[1536];
    while (!exitProgram && (outgoing? (byteCount = tcpConnector.read(buffer, sizeof(buffer))) > 0 : (byteCount = tcpSocket.read(buffer, sizeof(buffer))) > 0)) {
        for (ssize_t i=0; i<byteCount; i++) {
            std::cout << std::hex << std::setfill('0') << std::setw(2) << (short) buffer[i] << " ";
        }
        std::cout.flush();
    }
}

int main(int argc, char* argv[]) {
    std::signal(SIGINT, signalHandler);
    std::signal(SIGTERM, signalHandler);

    std::vector<CLI::Flag> flags;
    flags.push_back(CLI::Flag('4', "ipv4", "use IPv4, either this or IPv6 has to be specified"));
    flags.push_back(CLI::Flag('6', "ipv6", "use IPv6, either this or IPv4 has to be specified"));
    flags.push_back(CLI::Flag('t', "tcp", "use TCP, either this or UDP has to be specified"));
    flags.push_back(CLI::Flag('u', "udp", "use UDP, either this or TCP has to be specified"));
    flags.push_back(CLI::Flag('h', "help", "print this information and exit"));
    flags.push_back(CLI::Flag('l', "license", "print license information and exit"));

    std::vector<CLI::Option> options;
    options.push_back(CLI::Option('c', "connect", "HOST", "make an outgoing connection to HOST instead of listening for an incoming connection"));

    std::vector<CLI::Argument> arguments;
    arguments.push_back(CLI::Argument("PORT", "the port to lsiten on (or connect to)"));

    CLI::ArgumentsParser cliParser = CLI::ArgumentsParser(argc, argv, flags, options, arguments, "Arbitrary TCP/UDP connections in hex format", "Note: Make sure your terminal is set up so it doesn't buffer input and, if desired, disable input echoing.\n\tSomething like `stty -echo cbreak` should do but it will also disable some key combinations.");

    if (cliParser.getFlag("help").value) {
        std::cout << cliParser.getUsage() << std::endl;
        return EXIT_SUCCESS;
    }
    if (cliParser.getFlag("license").value) {
        std::cout
            << "Copyright 2022, FOSS-VG Developers and Contributers\n"
            << "\n"
            << "Hexnet is part of the FOSS-VG development tool suite.\n"
            << "\n"
            << "This program is free software: you can redistribute it and/or modify it\n"
            << "under the terms of the GNU Affero General Public License as published\n"
            << "by the Free Software Foundation, version 3.\n"
            << "\n"
            << "This program is distributed in the hope that it will be useful,\n"
            << "but WITHOUT ANY WARRANTY; without even the implied\n"
            << "warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
            << "See the GNU Affero General Public License for more details.\n"
            << "\n"
            << "You should have received a copy of the GNU Affero General Public License\n"
            << "version 3 along with this program.\n"
            << "If not, see https://www.gnu.org/licenses/agpl-3.0.en.html"
            << std::endl;
        return EXIT_SUCCESS;
    }
    if (cliParser.wrongUsage) {
        std::cout << cliParser.getUsage() << std::endl;
        return EXIT_USAGE;
    }

    ipv4 = cliParser.getFlag("ipv4").value;
    ipv6 = cliParser.getFlag("ipv6").value;
    tcp = cliParser.getFlag("tcp").value;
    udp = cliParser.getFlag("udp").value;

    if (cliParser.getOption("connect").errorCode != ErrorCodes::NOT_PRESENT) {
        outgoing = true;
        host = cliParser.getOption("connect").value;
    }

    if (!(ipv4 || ipv6) || (ipv4 && ipv6) || !(tcp || udp) || (tcp && udp)) {
        std::cout << cliParser.getUsage() << std::endl;
        return EXIT_USAGE;
    }

    port = (in_port_t) std::stoi(cliParser.getArgument(0).value);

    if (outgoing) {
        if (tcp) {
            std::cerr << "Connecting to " << host << " on port " << (int) port << " (TCP)..." << std::endl;
            if (ipv4) {
                // TCP v4 out
                tcpConnector = sockpp::tcp_connector({host, port});
                if (!tcpConnector) {
                    std::cerr << "Error connecting to " << host << " on port " << port << std::endl;
                    std::cerr << tcpConnector.last_error_str() << std::endl;
                    return EXIT_RUNTIME;
                }

                std::thread threadReadFromTCP = std::thread(readFromTCPSocket);
                //std::thread threadWriteToTCP = std::thread(writeToTCPSocket);

                threadReadFromTCP.join();
                //threadWriteToTCP.join();

                std::cout << std::endl;
                return EXIT_SUCCESS;
            } else {
                // TCP v6 out
                return EXIT_UNIMPLEMENTED;
            }
        } else {
            std::cerr << "Connecting to " << host << " on port " << (int) port << " (UDP)..." << std::endl;
            if (ipv4) {
                // UDP v4 out
                return EXIT_UNIMPLEMENTED;
            } else {
                // UDP v6 out
                return EXIT_UNIMPLEMENTED;
            }
        }
    } else {
        if (tcp) {
            std::cerr << "Listening on port " << (int) port << " (TCP)..." << std::endl;
            if (ipv4) {
                // TCP v4 in
                tcpAcceptor = sockpp::tcp_acceptor(port);
                if (!tcpAcceptor) {
                    std::cerr << "Error while creating TCP acceptor: " << tcpAcceptor.last_error_str() << std::endl;
                    return EXIT_RUNTIME;
                }

                sockpp::inet_address peer;
                tcpSocket = tcpAcceptor.accept(&peer);
                std::cerr << "Incoming connection from " << peer << std::endl;
                if (!tcpSocket) {
                    std::cerr << "Error on incoming connection: " << tcpAcceptor.last_error_str() << std::endl;
                    return EXIT_RUNTIME;
                }

                std::thread threadReadFromTCP = std::thread(readFromTCPSocket);
                //std::thread threadWriteToTCP = std::thread(writeToTCPSocket);

                threadReadFromTCP.join();
                //threadWriteToTCP.join();

                std::cout << std::endl;
                return EXIT_SUCCESS;
            } else {
                // TCP v6 in
                return EXIT_UNIMPLEMENTED;
            }
        } else {
            std::cerr << "Listening on port " << (int) port << " (UDP)..." << std::endl;
            if (ipv4) {
                // UDP v4 in
                return EXIT_UNIMPLEMENTED;
            } else {
                // UDP v6 in
                return EXIT_UNIMPLEMENTED;
            }
        }
    }
}