#include "Utilities.h"

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <boost/filesystem.hpp>
#include <iostream>

namespace fs = boost::filesystem;
using std::string;
using std::vector;

int ChildProcess(string program, vector<string> args, int timeout)
{
    std::vector<const char*> argv;
    argv.push_back(program.c_str());
    for(string& s : args)
        argv.push_back(s.c_str());
    argv.push_back(NULL);

    pid_t pid = fork();
    if(pid < 0)
    {
        perror("unable to fork");
        return 1;
    }
    else if(pid == 0)
    {
        pid_t worker_pid = timeout ? fork() : 0;
        if(worker_pid < 0)
        {
            perror("unable to fork");
            _exit(1);
        }
        if(worker_pid == 0)
        {
            execvp(argv[0], const_cast<char* const *> (argv.data()));
            perror("exec failed");
            std::cerr << "Tried to execute: " << program;
            for(auto a : args)
                std::cerr << " " << a;
            std::cerr << std::endl;
            _exit(1);
        }

        pid_t timeout_pid = fork();
        if(timeout_pid < 0)
        {
            perror("unable to fork");
            _exit(1);
        }
        if(timeout_pid == 0)
        {
            sleep(timeout);
            _exit(0);
        }
        int wstatus;
        pid_t exited_pid = wait(&wstatus);
        if(exited_pid == worker_pid)
        {
            kill(timeout_pid, SIGKILL);
            wait(NULL);
            if(!WIFEXITED(wstatus))
            {
                return 1;
            }
            else
            {
                int exitcode = WEXITSTATUS(wstatus);
                _exit(exitcode);
            }
        }
        else
        {
            kill(worker_pid, SIGKILL);
            wait(NULL);
            _exit(1);
        }
    }
    else
    {
        int wstatus;
        int result = 0;
        do
        {
            result = waitpid(pid, &wstatus, 0);
        } while(result == -1 && errno == EINTR);

        if(!WIFEXITED(wstatus))
        {
            return 1;
        }
        else
        {
            int exitcode = WEXITSTATUS(wstatus);
            return exitcode;
        }
    }

}



bool CheckExecutable(std::string program)
{
    if(access(program.c_str(), X_OK) == 0)
        return true;
    if(program.find("/") != std::string::npos)
        return false;
    const char *PATH = getenv("PATH");

    if(PATH)
    {
        bool endFound = false;
        do
        {
            const char *end = strchr(PATH, ':');
            if(!end)
            {
                end = strchr(PATH, '\0');
                endFound = true;
            }
            std::string pathElement(PATH, end);

            if(pathElement == "")
                pathElement = ".";

            fs::path f = fs::path(pathElement) / program;

            if(access(f.string().c_str(), X_OK) == 0)
                return true;

            PATH = end + 1;
        } while(!endFound);
    }

    return false;
}

vector<string> SplitArguments(std::string str)
{
    bool backslash = false;
    bool quote = false;
    bool begun = false;
    vector<string> args;

    for(char c : str)
    {
        if(!backslash && !quote && isspace(c))
        {
            begun = false;
        }
        else if(!backslash && c == '"')
        {
            quote = !quote;
            if(quote && !begun)
            {
                args.emplace_back();
                begun = true;
            }
        }
        else if(!backslash && c == '\\')
        {
            backslash = true;
        }
        else
        {
            backslash = false;

            if(!begun)
            {
                args.emplace_back();
                begun = true;
            }
            args.back() += c;
        }
    }

    return args;
}

vector<string> SplitArguments(vector<string> strs)
{
    vector<string> args;
    for(string str : strs)
    {
        vector<string> args1 = SplitArguments(str);
        args.insert(args.end(), args1.begin(), args1.end());
    }
    return args;
}