import subprocess
import time
from ding.utils import K8sLauncher
from .default_helper import one_time_warning


class OrchestratorLauncher(object):
    """
    Overview:
        Object to manage di-orchestrator in existing k8s cluster
    Interfaces:
        ``__init__``, ``create_orchestrator``, ``delete_orchestrator``
    """

    def __init__(
            self,
            version: str,
            name: str = 'di-orchestrator',
            cluster: K8sLauncher = None,
            registry: str = 'diorchestrator',
            cert_manager_version: str = 'v1.3.1',
            cert_manager_registry: str = 'quay.io/jetstack'
    ) -> None:
        """
        Overview:
            Initialize the OrchestratorLauncher object.
        Arguments:
            - version (:obj:`str`): The version of di-orchestrator.
            - name (:obj:`str`): The name of di-orchestrator.
            - cluster (:obj:`K8sLauncher`): The k8s cluster to deploy di-orchestrator.
            - registry (:obj:`str`): The docker registry to pull images.
            - cert_manager_version (:obj:`str`): The version of cert-manager.
            - cert_manager_registry (:obj:`str`): The docker registry to pull cert-manager images.
        """

        self.name = name
        self.version = version
        self.cluster = cluster
        self.registry = registry
        self.cert_manager_version = cert_manager_version
        self.cert_manager_registry = cert_manager_registry

        self._namespace = 'di-system'
        self._webhook = 'di-webhook'
        self._cert_manager_namespace = 'cert-manager'
        self._cert_manager_webhook = 'cert-manager-webhook'

        self.installer = 'https://raw.githubusercontent.com/opendilab/' + \
        f'DI-orchestrator/{self.version}/config/di-manager.yaml'
        self.cert_manager = 'https://github.com/jetstack/' + \
        f'cert-manager/releases/download/{self.cert_manager_version}/cert-manager.yaml'

        self._images = [
            f'{self.registry}/di-operator:{self.version}',
            f'{self.registry}/di-webhook:{self.version}',
            f'{self.registry}/di-server:{self.version}',
            f'{self.cert_manager_registry}/cert-manager-cainjector:{self.cert_manager_version}',
            f'{self.cert_manager_registry}/cert-manager-controller:{self.cert_manager_version}',
            f'{self.cert_manager_registry}/cert-manager-webhook:{self.cert_manager_version}',
        ]

        self._check_kubectl_tools()

    def _check_kubectl_tools(self) -> None:
        """
        Overview:
            Check if kubectl tools is installed.
        """

        args = ['which', 'kubectl']
        proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out, _ = proc.communicate()
        if out.decode('utf-8') == '':
            raise FileNotFoundError(
                "No kubectl tools found, please install by executing ./ding/scripts/install-k8s-tools.sh"
            )

    def create_orchestrator(self) -> None:
        """
        Overview:
            Create di-orchestrator in k8s cluster.
        """

        print('Creating orchestrator...')
        if self.cluster is not None:
            self.cluster.preload_images(self._images)

        # create and wait for cert-manager to be available
        create_components_from_config(self.cert_manager)
        wait_to_be_ready(self._cert_manager_namespace, self._cert_manager_webhook)

        # create and wait for di-orchestrator to be available
        create_components_from_config(self.installer)
        wait_to_be_ready(self._namespace, self._webhook)

    def delete_orchestrator(self) -> None:
        """
        Overview:
            Delete di-orchestrator in k8s cluster.
        """

        print('Deleting orchestrator...')
        for item in [self.cert_manager, self.installer]:
            args = ['kubectl', 'delete', '-f', f'{item}']
            proc = subprocess.Popen(args, stderr=subprocess.PIPE)
            _, err = proc.communicate()
            err_str = err.decode('utf-8').strip()
            if err_str != '' and 'WARN' not in err_str and \
                    'NotFound' not in err_str:
                raise RuntimeError(f'Failed to delete di-orchestrator: {err_str}')


def create_components_from_config(config: str) -> None:
    """
    Overview:
        Create components from config file.
    Arguments:
        - config (:obj:`str`): The config file.
    """

    args = ['kubectl', 'create', '-f', f'{config}']
    proc = subprocess.Popen(args, stderr=subprocess.PIPE)
    _, err = proc.communicate()
    err_str = err.decode('utf-8').strip()
    if err_str != '' and 'WARN' not in err_str:
        if 'already exists' in err_str:
            print(f'Components already exists: {config}')
        else:
            raise RuntimeError(f'Failed to launch components: {err_str}')


def wait_to_be_ready(namespace: str, component: str, timeout: int = 120) -> None:
    """
    Overview:
        Wait for the component to be ready.
    Arguments:
        - namespace (:obj:`str`): The namespace of the component.
        - component (:obj:`str`): The name of the component.
        - timeout (:obj:`int`): The timeout of waiting.
    """

    try:
        from kubernetes import config, client, watch
    except ModuleNotFoundError:
        one_time_warning("You have not installed kubernetes package! Please try 'pip install DI-engine[k8s]'.")
        exit(-1)

    config.load_kube_config()
    appv1 = client.AppsV1Api()
    w = watch.Watch()
    for event in w.stream(appv1.list_namespaced_deployment, namespace, timeout_seconds=timeout):
        # print("Event: %s %s %s" % (event['type'], event['object'].kind, event['object'].metadata.name))
        if event['object'].metadata.name.startswith(component) and \
            event['object'].status.ready_replicas is not None and \
                event['object'].status.ready_replicas >= 1:
            print(f'component {component} is ready for serving')
            w.stop()