#include "../include/PkgConfig.hpp"
#if OS_FAMILY == OS_FAMILY_POSIX
#include "../include/Exec.hpp"

using namespace std;

// TODO: Do not use pkg-config program. The same functionality can easily be achieved
// by reading files in /usr/bin/pkgconfig
// Or is there no downside to calling pkg-config program?
namespace sibs
{
    string trimRight(const string &input)
    {
        for(int i = input.size() - 1; i >= 0; --i)
        {
            if(!isspace(input[i]))
                return input.substr(0, i + 1);
        }
        return "";
    }
    
#if OS_FAMILY == OS_FAMILY_POSIX
    Result<bool> PkgConfig::validatePkgConfigPackageVersionExists(const Dependency &dependency)
    {
        Result<bool> dependencyValidationResult = PkgConfig::validatePackageExists(dependency.name);
        if(dependencyValidationResult.isErr())
            return Result<bool>::Err(dependencyValidationResult.getErrMsg());

        Result<bool> dependencyVersionValidationResult = PkgConfig::validatePackageVersionAtLeast(dependency.name, dependency.version);
        if(dependencyVersionValidationResult.isErr())
            return Result<bool>::Err(dependencyVersionValidationResult.getErrMsg());

        return Result<bool>::Ok(true);
    }
#endif

    Result<bool> PkgConfig::validatePackageExists(const string &name)
    {
        string command = "pkg-config --exists '";
        command += name;
        command += "'";
        Result<ExecResult> execResult = exec(command.c_str());
        if(execResult.isErr())
            return Result<bool>::Err(execResult.getErrMsg());

        if(execResult.unwrap().exitCode == 1)
        {
            string errMsg = "pkg-config dependency not found: ";
            errMsg += name;
            return Result<bool>::Err(errMsg);
        }
        else if(execResult.unwrap().exitCode == 127)
        {
            return Result<bool>::Err("pkg-config is not installed");
        }
        else if(execResult.unwrap().exitCode != 0)
        {
            string errMsg = "Failed to check if dependency exists, Unknown error, exit code: ";
            errMsg += to_string(execResult.unwrap().exitCode);
            return Result<bool>::Err(errMsg);
        }

        return Result<bool>::Ok(true);
    }

    Result<bool> PkgConfig::validatePackageVersionAtLeast(const string &name, const string &version)
    {
        // TODO: Instead of checking if package version is same or newer, check if package is same major version
        // and same or newer minor version

        // Use --modversion instead and check if the version returned is newer or equal to dependency version.
        // This way we can output installed version vs expected dependency version
        string command = "pkg-config '--atleast-version=";
        command += version;
        command += "' '";
        command += name;
        command += "'";
        Result<ExecResult> execResult = exec(command.c_str());
        if(execResult.isErr())
            return Result<bool>::Err(execResult.getErrMsg());

        if(execResult.unwrap().exitCode == 1)
        {
            string errMsg = "Dependency ";
            errMsg += name;
            errMsg += " is installed but the version older than ";
            errMsg += version;
            return Result<bool>::Err(errMsg);
        }
        else if(execResult.unwrap().exitCode == 127)
        {
            return Result<bool>::Err("pkg-config is not installed");
        }
        else if(execResult.unwrap().exitCode != 0)
        {
            string errMsg = "Failed to check dependency version, Unknown error, exit code: ";
            errMsg += to_string(execResult.unwrap().exitCode);
            return Result<bool>::Err(errMsg);
        }

        return Result<bool>::Ok(true);
    }

    Result<string> PkgConfig::getDynamicLibsLinkerFlags(const vector<Dependency> &libs)
    {
        if(libs.empty()) return Result<string>::Ok("");

        string args;
        for(const Dependency &lib : libs)
        {
            args += " '";
            args += lib.name;
            args += "'";
        }

        string command = "pkg-config --libs";
        command += args;
        Result<ExecResult> execResult = exec(command.c_str());
        if(execResult.isErr())
            return Result<string>::Err(execResult.getErrMsg());

        if(execResult.unwrap().exitCode == 0)
        {
            execResult.unwrap().execStdout = trimRight(execResult.unwrap().execStdout);
            return Result<string>::Ok(execResult.unwrap().execStdout);
        }
        else if(execResult.unwrap().exitCode == 1)
        {
            // TODO: This shouldn't happen because we check if each dependency is installed before this,
            // but maybe the package is uninstalled somewhere between here...
            // Would be better to recheck if each package is installed here again
            // to know which package was uninstalled
            return Result<string>::Err("Packages not found");
        }
        else if(execResult.unwrap().exitCode == 127)
        {
            return Result<string>::Err("pkg-config is not installed");
        }
        else
        {
            string errMsg = "Failed to get package dynamic lib linking flags, Unknown error, exit code: ";
            errMsg += to_string(execResult.unwrap().exitCode);
            return Result<string>::Err(errMsg);
        }
    }
    
    Result<string> PkgConfig::getDynamicLibsCflags(const vector<Dependency> &libs)
    {
        if(libs.empty()) return Result<string>::Ok("");

        string args;
        for(const Dependency &lib : libs)
        {
            args += " '";
            args += lib.name;
            args += "'";
        }

        string command = "pkg-config --cflags";
        command += args;
        Result<ExecResult> execResult = exec(command.c_str());
        if(execResult.isErr())
            return Result<string>::Err(execResult.getErrMsg());

        if(execResult.unwrap().exitCode == 0)
        {
            execResult.unwrap().execStdout = trimRight(execResult.unwrap().execStdout);
            return Result<string>::Ok(execResult.unwrap().execStdout);
        }
        else if(execResult.unwrap().exitCode == 1)
        {
            // TODO: This shouldn't happen because we check if each dependency is installed before this,
            // but maybe the package is uninstalled somewhere between here...
            // Would be better to recheck if each package is installed here again
            // to know which package was uninstalled
            return Result<string>::Err("Packages not found");
        }
        else if(execResult.unwrap().exitCode == 127)
        {
            return Result<string>::Err("pkg-config is not installed");
        }
        else
        {
            string errMsg = "Failed to get package dynamic lib cflags, Unknown error, exit code: ";
            errMsg += to_string(execResult.unwrap().exitCode);
            return Result<string>::Err(errMsg);
        }
    }
    
    Result<PkgConfigFlags> PkgConfig::getDynamicLibsFlags(const vector<Dependency> &libs)
    {
        PkgConfigFlags flags;
        
        Result<string> linkerFlagsResult = getDynamicLibsLinkerFlags(libs);
        if(!linkerFlagsResult)
            return Result<PkgConfigFlags>::Err(linkerFlagsResult);
        
        Result<string> cflagsResult = getDynamicLibsCflags(libs);
        if(!cflagsResult)
            return Result<PkgConfigFlags>::Err(cflagsResult);
        
        flags.linkerFlags = move(linkerFlagsResult.unwrap());
        flags.cflags = move(cflagsResult.unwrap());
        return Result<PkgConfigFlags>::Ok(flags);
    }
}
#endif // OS_FAMILY_POSIX