# Copyright (c) 2014 TrilioData, Inc.
# All Rights Reserved.

"""
Workloads Interface (1.1 extension).
"""
import json
from datetime import datetime
from workloadmgrclient import base
import six
try:
    from urllib import urlencode
except ImportError:
    from urllib.parse import urlencode


class Workload(base.Resource):
    """A workload describes a grouping of one or more VMs"""

    def __repr__(self):
        return "<Workload: %s>" % self.id

    def delete(self, database_only=False):
        """Delete this workload."""
        return self.manager.delete(self, database_only)

    def snapshot(self, full, name=None, description=None):
        """Snapshot the workload full or incremental """
        return self.manager.snapshot(self, full, name, description)

    def pause(self):
        """Pause the workload"""
        return self.manager.pause(self)

    def resume(self):
        """Resume the workload"""
        return self.manager.resume(self)

    def unlock(self):
        """Unlock the workload"""
        return self.manager.unlock(self)

    def reset(self):
        """Reset the workload"""
        return self.manager.reset(self)

    def update(self, workload_id, name, description, instances, jobschedule, metadata):
        """Update the workload"""
        return self.manager.update(workload_id, name, description, instances, jobschedule, metadata)


class WorkloadsManager(base.ManagerWithFind):
    """Manage :class:`Workload` resources."""
    resource_class = Workload

    def create(self, name, description, workload_type_id, source_platform, instances, jobschedule, metadata):
        """Create a workload.

        :param instances: List of instances to be included in the workload.
        :param workload_type_id: Type of the workload
        :param name: The name of the workload.
        :param description: The description of the workload.
        :rtype: :class:`Workload`
        """
        body = {'workload': {'name': name,
                             'description': description,
                             'workload_type_id': workload_type_id,
                             'source_platform': source_platform,
                             'instances': instances,
                             'jobschedule': jobschedule,
                             'metadata': metadata}}
        return self._create('/workloads', body, 'workload')

    def get(self, workload_id):
        """Show details of a workload.

        :param workload_id: The ID of the workload to display.
        :rtype: :class:`Workload`
        """
        return self._get("/workloads/%s" % workload_id, "workload")

    def list(self, detailed=False, search_opts=None):
        """Get a list of all workloads.

        :rtype: list of :class:`Workload`
        """

        if search_opts is None:
            search_opts = {}

        qparams = {}

        for opt, val in six.iteritems(search_opts):
            if val:
                qparams[opt] = val

        query_string = "?%s" % urlencode(qparams) if qparams else ""

        detail = ""
        if detailed:
            detail = "/detail"
        return self._list("/workloads%s%s" % (detail, query_string),
                          "workloads")

    def list_by_page(self, page):
        """Get a list of all workloads by page.

        :rtype: list of :class:`Workload`

        """
        return self._list("/workloads?page_number=%s" % page, "workloads")

    def delete(self, workload_id, database_only=False):
        """Delete a workload.

        :param workload_id: The :class:`Workload` to delete.
        """
        self._delete("/workloads/%s?database_only=%s" %
                     (base.getid(workload_id), database_only))

    def snapshot(self, workload_id, full=False, name=None, description=None):
        """Snapshots a workload.
        :param workload_id: The :class:`Workload` to snapshot.
        :param name: The name of the snapshot.
        :param description: The description of the snapshot.        
        """
        body = {'snapshot': {'name': name, 'description': description}}
        if full == True:
            self._post("/workloads/%s?full=1" % base.getid(workload_id), body)
        else:
            self._post("/workloads/%s" % base.getid(workload_id), body)

    def get_workflow(self, workload_id):
        """Get workflow details of a workload.

        :param workload_id: The ID of the workload
        :rtype: workflow
        """
        return self._get_without_id("/workloads/%s/workflow" % workload_id, "workflow")

    def get_topology(self, workload_id):
        """Get topology details of a workload.

        :param workload_id: The ID of the workload
        :rtype: workflow
        """
        return self._get_without_id("/workloads/%s/topology" % workload_id, "topology")

    def discover_instances(self, workload_id):
        """Discover instances of a workload_type.

        :param metadata: metadata of workload_type.
        :rtype: instances
        """
        instances = self._discover_instances(
            "/workloads/%s/discover_instances" % workload_id)
        return instances

    def pause(self, workload_id):
        """
        pause a workload.
        """
        return self._pause("/workloads/%s/pause" % base.getid(workload_id))

    def resume(self, workload_id):
        """
        resume a workload.
        """
        return self._resume("/workloads/%s/resume" % base.getid(workload_id))

    def unlock(self, workload_id):
        """
        unlock a workload.
        """
        return self._unlock("/workloads/%s/unlock" % base.getid(workload_id))

    def reset(self, workload_id):
        """
        reset a workload.
        """
        return self._reset("/workloads/%s/reset" % base.getid(workload_id))

    def get_importworkloads_list(self, project_id=None):
        """
        Get import workloads list from backup media
        """
        if project_id is not None:
            query_string = "?project_id=%s" %(project_id)
            url = "/workloads/get_list/import_workloads%s" %(query_string)
        else:
            url = "/workloads/get_list/import_workloads"

        return self._import(url, "workloads", method='list')

    def importworkloads(self, workloadids=[], upgrade=True):
        """
        import workload records from backup media
        """
        return self._import("/workloads/import_workloads", "workloads", workloadids=workloadids, upgrade=upgrade)

    def get_nodes(self):
        """
        get workload manager nodes
        """
        return self._get_nodes("/workloads/metrics/nodes")

    def get_contego_status(self, host, ip):
        """
        get the running status of contego service
        """
        return self._get_contego_status("/workloads/metrics/contego_status?host={0}&ip={1}".format(host, ip))

    def remove_node(self, ip):
        """
        remove workload manager node
        """
        return self._remove_node("/workloads/remove_node/%s" % str(ip))

    def add_node(self, ip):
        """
        add workload manager node
        """
        return self._add_node("/workloads/add_node", ip)

    def get_storage_usage(self):
        """
        get workload manager total storage usage
        """
        return self._get_storage_usage("/workloads/metrics/storage_usage")

    def get_recentactivities(self, time_in_minutes):
        """
        get recentactivities
        """
        return self._get_recentactivities("/workloads/metrics/recentactivities?time_in_minutes=%s" % time_in_minutes)

    def get_auditlog(self, time_in_minutes, time_from, time_to):
        """
        get auditlog
        """
        if time_from is None:
            return self._get_auditlog("/workloads/audit/auditlog?time_in_minutes=%s" % time_in_minutes)
        else:
            if time_to is None:
                time_to = datetime.now().strftime("%m-%d-%Y")
            time_range = 'start_range=' + time_from + '&end_range=' + time_to
            return self._get_auditlog("/workloads/audit/auditlog?%s" % time_range)

    def get_tasks(self, time_in_minutes, status, page, size):
        """
        get tasks
        """
        url = ''
        if time_in_minutes is not None:
            url += 'time_in_minutes=' + time_in_minutes + '&'

        if status is not None:
            url += 'status=' + status + '&'

        if page is not None:
            url += 'page=' + page + '&'

        if size is not None:
            url += 'size=' + size + '&'

        return self._get_tasks("/tasks?%s" % url[:-1])

    def update(self, workload_id, name, description, instances, jobschedule, metadata):
        workload = {}
        if name:
            workload['name'] = name
        if description:
            workload['description'] = description
        if instances and len(instances) > 0:
            workload['instances'] = instances
        if metadata and len(metadata) > 0:
            workload['metadata'] = metadata
        if jobschedule and len(jobschedule) > 0:
            workload['jobschedule'] = jobschedule

        body = {'workload': workload}
        return self._update('/workloads/%s' % base.getid(workload_id), body)

    def settings(self, settings):
        """settings.

        :param settings: golbal settings.
        """
        body = {'settings': settings}
        return self._settings('/workloads/settings', body)

    def license_create(self, license_text):
        """license_text.

        :param license_text: golbal settings.
        """
        body = {'license': license_text}
        result = self._post('/workloads/license', body)
        return result['license']

    def license_list(self):
        return self._license_list('/workloads/metrics/license')

    def license_check(self):
        return self._license_check('/workloads/metrics/license_check')

    def get_orphaned_workloads_list(self, args):
        """
        Get orphaned workloads list from backup media
        """
        return self._reassign("/workloads/orphan_workloads/?migrate_cloud=%s" % args.migrate_cloud, "workloads", args, method='list')

    def reassign_workloads(self, args):
        """
        Reassign new tenant id/user id to orphan workloads.
        """
        return self._reassign("/workloads/reasign_workloads", "workloads", args)

    def get_tenants_usage(self):
        """
        Get storage usage and vms protected by tenants.
        """
        return self._get_tenants_usage("/workloads/metrics/tenants_usage")

    def get_protected_vms(self):
        """
        Get vms protected by tenant.
        """
        return self._get_protected_vms("/workloads/metrics/vms_protected")

    def get_tenants_chargeback(self):
        """
        Get tenants chargeback.
        """
        return self._get_tenants_chargeback("/workloads/metrics/tenants_chargeback")