#include "curlpp/Options.hpp"
#include "kubecontrol/PodController.hpp"
#include "kubecontrol/Utils.hpp"
#include "nlohmann/json_fwd.hpp"
#include "yaml-cpp/binary.h"
#include <cctype>
#include <exception>
#include <fstream>
#include <future>
#include <iterator>
#include <kubecontrol/KubePod.hpp>
#include <memory>
#include <sstream>
#include <string>
#include <thread>
#include <filesystem>
#include "loguru.hpp"
#include "yaml-cpp/node/node.h"



namespace kubecontrol 
{
    
    KubePod::KubePod(std::string Owner, std::string Uuid, std::string ContainerImage,std::string Namespace)
    :Owner_(Utils::to_lower(Owner)),
    Uuid_(Utils::to_lower(Uuid)),
    Namespace_(Namespace),
    EnvirmonentVars_()
    {

        ContainerRegistry_ = "kmaster.ti.unibw-hamburg.de:30808";
        EnvirmonentVars_ = std::map<std::string, std::string>();
        
        this->PathToYaml_ = "config/pods/" + this->Uuid_ + ".yaml";

        if( std::filesystem::directory_entry("config").exists() != true) 
        {
            std::filesystem::create_directory("config");
        }
        std::filesystem::directory_entry entry("config/pods");
        if(entry.exists() != true) 
        {
            std::filesystem::create_directory("config/pods");
        }

        addContainer(Uuid, ContainerImage);
    }


    KubePod::KubePod(std::string Owner, std::string Uuid, std::string Component, std::string ContainerImage,std::string Namespace):
    Owner_(Utils::to_lower(Owner)),
    Uuid_(Utils::to_lower(Uuid)),
    Component_(Utils::to_lower(Component)),
    Namespace_(Namespace),
    EnvirmonentVars_()
    {

        ContainerRegistry_ = "kmaster.ti.unibw-hamburg.de:30808";
        EnvirmonentVars_ = std::map<std::string, std::string>();
        
        this->PathToYaml_ = "config/pods/" + this->Uuid_ + ".yaml";

        if( std::filesystem::directory_entry("config").exists() != true) 
        {
            std::filesystem::create_directory("config");
        }
        std::filesystem::directory_entry entry("config/pods");
        if(entry.exists() != true) 
        {
            std::filesystem::create_directory("config/pods");
        }

        addContainer(Uuid, ContainerImage);

    }



     void KubePod::addContainer(std::string name,std::string image, std::shared_ptr<std::map<std::string, std::string>> envs, PullPolicy pullPolicy )
     {
        YAML::Node container;
        transform(image.begin(), image.end(), image.begin(), ::tolower); 
        transform(name.begin(), name.end(), name.begin(), ::tolower); 

        container["name"] = name+"-container";
        container["image"] = this->ContainerRegistry_ + "/" + image;
        container["imagePullPolicy"] = toString(pullPolicy);

        if (envs != nullptr) 
        {
            int i = 0;
            for(auto [key,value] : *envs)
            {
                container["env"][i]["name"] = key;
                container["env"][i]["value"] = value;
                i++;        
            }
        
        }    
          
        ContainerImages_.push_back(container);
     }




    std::string KubePod::getUUID()
    {
        return this->Uuid_;
    }

    std::string KubePod::getOwner()
    {
        return this->Owner_;
    }

    std::string KubePod::getIp()
    {
        return  this->Ip_;
    }
    std::string KubePod::getStatus()
    {
        return  this->Status_;
    }

    void  KubePod::setEnvironmentVar(std::string key, std::string val)
    {
        EnvirmonentVars_.emplace(key,val);
    }

    std::map<std::string, std::string> KubePod::GetEnvironmentVars()
    {
        return EnvirmonentVars_;
    }

    std::string KubePod::GetEnvironmentVar(std::string key)
    {
         if(EnvirmonentVars_.contains(key)) {
            return EnvirmonentVars_[key];
        } else {
            return nullptr;
        }
    }

    void KubePod::setArgs(std::string args)
    {
        Args_.emplace_back(Utils::to_lower(args));
    }

    std::vector<std::string> KubePod::GetArgs()
    {
        return Args_;
    }

    void KubePod::setCommand(std::string command)
    {
        PodCommand_ = Utils::to_lower(command);
    }

    std::string KubePod::getCommand()
    {
        return PodCommand_;
    }

    void KubePod::setComponent(std::string component)
    {
        this->Component_ = Utils::to_lower(component);
    }

    std::string KubePod::getComponent()
    {
        return this->Component_;
    }

    void KubePod::setName(std::string name)
    {
        this->Name_ = name;
    }



    std::string KubePod::getName()
    {
        return this->Name_;
    }


    std::string  KubePod::createYAML()
    {
        YAML::Node node;

        node["apiVersion"] = "v1";
        node["kind"] = "Pod";
        node["metadata"]["name"] = this->Uuid_;
        node["metadata"]["namespace"] = this->Namespace_;
        node["metadata"]["labels"]["app.kubernetes.io/name"] = this->Uuid_;

        node["metadata"]["labels"]["app.kubernetes.io/part-of"] =  this->Owner_;

        // if (!std::empty(this->Component_)) node["metadata"]["labels"]["app.kubernetes.io/component"] =  this->Component_;
        node["metadata"]["labels"]["app.kubernetes.io/component"] =  this->Component_;
       
     
            for (int i = 0; i< this->ContainerImages_.size(); i++) 
            {
                node["spec"]["containers"][i] = this->ContainerImages_[i];
                // node["spec"]["containers"][i]["name"] = this->Uuid_+"-container";
                // node["spec"]["containers"][i]["image"] = this->ContainerRegistry_ + "/" + this->ContainerImages_[i];
                // node["spec"]["containers"][i]["imagePullPolicy"] = imagePullPolicy;
                // node["spec"]["containers"][i]["ports"][0]["containerPort"] = 10000;
                // node["spec"]["containers"][i]["ports"][0]["protocol"] = "UDP";


            }    
        
        


        int i = 0;
        for (auto item :EnvirmonentVars_) {
            node["spec"]["containers"][0]["env"][i]["name"] = item.first;
            node["spec"]["containers"][0]["env"][i]["value"] = item.second;
            i++;
        }

        
        if (Args_.size() > 0) 
        {
            node["spec"]["containers"][0]["args"].SetStyle(YAML::EmitterStyle::Flow);
            for (auto item : Args_) {
                node["spec"]["containers"][0]["args"].push_back(item);
            }
        }

        if (!PodCommand_.empty()) 
        {
            
            node["spec"]["containers"][0]["command"].SetStyle(YAML::EmitterStyle::Flow);
            node["spec"]["containers"][0]["command"].push_back(PodCommand_);
        }

        node["spec"]["terminationGracePeriodSeconds"] = 5;
  
        node["spec"]["restartPolicy"] = "Never";

        YAMLNode_ = node;

        std::ofstream fout(this->PathToYaml_);
        fout << node;

        fout.close();
        
        return this->PathToYaml_;

    }

    

   int KubePod::start(KubernetesAPI APIInterface,bool WaitTillRunning)
    {
        std::string request = "/api/v1/namespaces/simulator/pods/";

        this->createYAML();
                
        std::stringstream stream;
        stream << YAMLNode_;
        std::string response = APIInterface.performRequest(request,"POST",stream.str());
        extractInformationFromResopnse(response);

        auto timeoutTime = std::chrono::system_clock::now() + std::chrono::seconds(10);


        if (WaitTillRunning == true ) {
            while ((this->Status_ != "Running" && this->Status_ != "Succeeded") || std::chrono::system_clock::now() >= timeoutTime) {
            // LOG_S(INFO)<<"wainting till running " << this->Status_;
        
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
                 this->updateInfoForThisPod(APIInterface);

            }
        }
        else {
            std::this_thread::sleep_for(std::chrono::milliseconds(200));

        }

        return 0;
    }

    

    int KubePod::stop(KubernetesAPI APIInterface)
    {
        std::string request = "/api/v1/namespaces/simulator/pods/"+Uuid_;
        std::string result = APIInterface.performRequest(request,"DELETE");

        LOG_S(INFO)<<"stopping: " <<Uuid_;    
       
        return 0;

    }


   int KubePod::stopChilds(KubernetesAPI APIInterface)
    {
        auto uuids = this->getPodsChilds(APIInterface);
        if (uuids.size() == 0)
        {
            return 1;
        }
        for(auto i: uuids)
        {
            std::string request = "/api/v1/namespaces/simulator/pods/"+i.UUID;
            std::string result = APIInterface.performRequest(request,"DELETE");

        }

        return 0;
        

    }


    int KubePod::updateInfoForThisPod(KubernetesAPI APIInterface)
    {
        std::string request = "/api/v1/namespaces/simulator/pods/"+Uuid_+"/status";
        std::string result = APIInterface.performRequest(request,"GET");
        if (result == "")
        {
            return 1;
        }
        
        if (extractInformationFromResopnse(result)!= 0) 
        {
            return 1;
        } 
        return 0;
    }


    std::vector<PodChild> KubePod::getPodsChilds( KubernetesAPI APIInterface)
    {
        std::string request = "/api/v1/namespaces/simulator/pods?labelSelector=app.kubernetes.io/part-of="+Uuid_;
        std::string result = APIInterface.performRequest(request,"GET");

        if (result == "")
        {
            return  std::vector<PodChild>();
        }

        extractInformationFromResopnse(result);       
        return this->ChildPods;
    }



    int  KubePod::extractInformationFromResopnse(std::string response)
    {
        if (response == "") 
        {
            return 1 ;
        }
        // LOG_S(INFO)<< response;
         nlohmann::json j;
         try {
            j = nlohmann::json::parse(response);
            if(j.contains("kind") && j["kind"] == "Pod")
            {       
                    if( j["status"].contains("podIP")) this->Ip_ =  j["status"]["podIP"].get<std::string>();
                    this->Status_ = j["status"]["phase"].get<std::string>();
                    this->PartOf_ = j["metadata"]["labels"]["app.kubernetes.io/part-of"];

                    
            }else if(j.contains("items") && j["items"].is_array())
            {              

                    for (auto i  : j["items"]) 
                    {
                        // LOG_S(INFO)<<i;
                        PodChild child;
                        child.UUID =i["metadata"]["name"].get<std::string>();
                        child.IP = i["status"]["podIP"].get<std::string>();
                        child.Status = i["status"]["phase"].get<std::string>();
                        child.Component = i["metadata"]["labels"]["app.kubernetes.io/component"].get<std::string>();
                        this->ChildPods.push_back(child);
                    }

            }else{
                return 1;
            }
        } catch (const std::exception e) {
            LOG_S(ERROR)<< "Exeption in extractInformationFromResopnse() :" << e.what();
              std::exception_ptr p = std::current_exception();
            LOG_S(ERROR)<< "Exeption :" << p.__cxa_exception_type()->name();
            LOG_S(INFO)<<j;
            return 1;

        }
        return 0;
  
    }




    





}