import os
import yaml
import argparse
from cliff import show, lister
from osc_lib import exceptions
from osc_lib import utils as osc_utils

from workloadmgrclient import timezone
from workloadmgrclient import utils
from workloadmgrclient.openstack.common import strutils
from workloadmgrclient.v1 import WorkloadmgrCommand

class MigrationPlanCommand(WorkloadmgrCommand):
    resource = "migration_plans"

class ListMigrationPlans(MigrationPlanCommand, lister.Lister):
    """List all the migration_plans of current project."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "--all",
            type=strutils.bool_from_string,
            metavar="{True,False}",
            help="List all migration plans of all the projects (valid for admin user only)",
            default=False,
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        search_opts = {
            "all_migration_plans": parsed_args.all,
        }
        migration_plan_objs = client.list(search_opts=search_opts) or []
        return (
            ["ID", "Name", "Project ID", "Status", "Created At"],
            (
                osc_utils.get_item_properties(
                    obj,
                    [
                        "id",
                        "name",
                        "project_id",
                        "status",
                        "created_at",
                    ],
                )
                for obj in migration_plan_objs
            ),
        )


class ShowMigrationPlan(MigrationPlanCommand, show.ShowOne):
    """Show details about a migration plan."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "migration_plan_id",
            metavar="<migration_plan_id>",
            help="ID of the migration plan."
        )

        parser.add_argument(
            "--scheduler_trust",
            type=bool,
            metavar="<scheduler_trust {true}>",
            help="scheduler_trust."
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        scheduler_trust = False
        # checks for scheduler_trust key and pass it to find_resource if present.
        if parsed_args.scheduler_trust:
            scheduler_trust = {'scheduler_trust': parsed_args.scheduler_trust}
            migration_plan = utils.find_resource(client, parsed_args.migration_plan_id, scheduler_trust)
        else:
            migration_plan = utils.find_resource(client, parsed_args.migration_plan_id)
        info = {}
        info.update(migration_plan._info)
        info.pop("links", None)
        metadata = info.pop("metadata", {})

        for i, val in enumerate(info["vms"]):
            info["vms"][i].pop("metadata", None)

        # TODO: check for better approach here
        if getattr(
            self.app.options,
            "verbose",
            getattr(self.app.options, "verbose_level", None),
        ):
            self._produce_verbose_output(metadata)

        columns = list(info.keys())
        data = osc_utils.get_dict_properties(info, columns)
        return columns, data


class CreateMigrationPlan(MigrationPlanCommand, lister.Lister):
    """Creates a migration plan."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "--vmid",
            metavar="<vm-id=vm-uuid>",
            action="append",
            dest="vmids",
            required=True,
            help="Required to set atleast one VMware VM,"
            " Specify a vm id to include in the migration plan."
            " Specify option multiple times to include multiple VMs."
            " vmid: include the vCenter vm with its UUID ",
        )
        parser.add_argument(
            "--display-name",
            metavar="<display-name>",
            help="Optional migration plan name. (Default=None)",
            default=None,
        )
        parser.add_argument(
            "--display-description",
            metavar="<display-description>",
            help="Optional migration plan description. (Default=None)",
            default=None,
        )
        parser.add_argument(
            "--source-platform",
            metavar="<source-platform>",
            help="Optional migration plan source platform (Default=vmware)",
            default="vmware",
        )
        parser.add_argument(
            "--metadata",
            metavar="<key=key-name>",
            action="append",
            dest="metadata",
            default=[],
            help="Specify a key value pairs to include in the migration plan metadata. "
                 "Specify option multiple times to include multiple keys. "
                 "key=value",
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        vms = []
        for vm in parsed_args.vmids:
            err_msg = (
                "Invalid vm argument '%s'. vmid arguments must be of the "
                "form --vmid <vmid=vm-uuid>" % vm
            )
            vm_info = {"vm-id": ""}

            for kv_str in vm.split(","):
                try:
                    k, v = kv_str.split("=", 1)
                except ValueError:
                    raise exceptions.CommandError(err_msg)

                if k in vm_info:
                    vm_info[k] = v
                else:
                    raise exceptions.CommandError(err_msg)

            if not vm_info["vm-id"]:
                raise exceptions.CommandError(err_msg)

            vms.append(vm_info)

        metadata = {}
        for metadata_str in parsed_args.metadata:
            err_msg = (
                "Invalid metadata argument '%s'. metadata arguments must be of the "
                "form --metadata <key=value>" % metadata_str
            )

            for kv_str in metadata_str.split(","):
                try:
                    k, v = kv_str.split("=", 1)
                except ValueError:
                    raise exceptions.CommandError(err_msg)

                if k in metadata:
                    metadata[k] = v
                else:
                    metadata.setdefault(k, v)

        migration_plan_obj = client.create(
            parsed_args.display_name,
            parsed_args.display_description,
            vms,
            metadata,
            parsed_args.source_platform
        )

        if migration_plan_obj:
            return (
                ["ID", "Name", "Status"],
                (
                    osc_utils.get_item_properties(obj, ["id", "name", "status"])
                    for obj in [migration_plan_obj]
                ),
            )
        return


class ModifyMigrationPlan(MigrationPlanCommand):
    """Modify a migration plan."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "migration_plan_id", metavar="<migration_plan_id>", help="ID of the migration_plan."
        )
        parser.add_argument(
            "--display-name",
            metavar="<display-name>",
            help="Optional migration_plan name. (Default=None)",
            default=None,
        )
        parser.add_argument(
            "--display-description",
            metavar="<display-description>",
            help="Optional migration_plan description. (Default=None)",
            default=None,
        )
        parser.add_argument(
            "--vmid",
            metavar="<vm-id=vi-uuid>",
            action="append",
            dest="vms",
            default=[],
            help="Specify a vm to include in the migration plan. "
            "Specify option multiple times to include multiple vms. "
            "vm-id: include the vm with this UUID ",
        )
        parser.add_argument(
            "--metadata",
            metavar="<key=key-name>",
            action="append",
            dest="metadata",
            default=[],
            help="Specify a key value pairs to include in the workload_type metadata "
            "Specify option multiple times to include multiple keys. "
            "key=value",
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        workload_obj = utils.find_resource(client, parsed_args.migration_plan_id)
        vms = []
        for vm_str in parsed_args.vms:
            err_msg = (
                "Invalid vmid argument '%s'. VM arguments must be of the "
                "form --vmid <vm-id=vm-uuid>" % vm_str
            )
            vm = {"vm-id": ""}

            for kv_str in vm_str.split(","):
                try:
                    k, v = kv_str.split("=", 1)
                except ValueError:
                    raise exceptions.CommandError(err_msg)

                if k in vm_info:
                    vm_info[k] = v
                else:
                    raise exceptions.CommandError(err_msg)

            if not vm_info["vm-id"]:
                raise exceptions.CommandError(err_msg)

            instances.append(vm_info)

        metadata = {}
        for metadata_str in parsed_args.metadata:
            err_msg = (
                "Invalid metadata argument '%s'. metadata arguments must be of the "
                "form --metadata <key=value>" % metadata_str
            )

            for kv_str in metadata_str.split(","):
                try:
                    k, v = kv_str.split("=", 1)
                except ValueError:
                    raise exceptions.CommandError(err_msg)

                if k in metadata:
                    metadata[k] = v
                else:
                    metadata.setdefault(k, v)

        migration_plan_obj.update(
            migration_plan_obj.id,
            parsed_args.display_name,
            parsed_args.display_description,
            vms,
            metadata,
        )
        return


class DeleteMigrationPlan(MigrationPlanCommand):
    """Remove a migration plan."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "migration_plan_id", metavar="<migration_plan_id>", help="ID of the migration plan to delete."
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        migration_plan = utils.find_resource(client, parsed_args.migration_plan_id)
        migration_plan.delete()
        return


class ListvCenterVMs(MigrationPlanCommand, lister.Lister):
    """List all the VMs of the vCenter."""

    def take_action(self, parsed_args):
        client = self.get_client()
        vcenter_vms = client.get_vcenter_vms()['vcenter_vms'] or []
        return (
            ["ID", "Name", "Status", "VMware Tools"],
            (
                osc_utils.get_dict_properties(
                    vm,
                    [
                        "vm_id",
                        "vm_name",
                        "power_state",
                        "tools_running",
                    ],
                )
                for vm in vcenter_vms
            ),
        )
class GetvCenterVMs(MigrationPlanCommand):
    """Get vCenter VMs."""

    def take_action(self, parsed_args):
        client = self.get_client()
        migration_plan = utils.find_resource(client, parsed_args.migration_plan_id)
        migration_plan.delete()
        return


class UnlockMigrationPlan(MigrationPlanCommand):
    """unlock a workload."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "migration_plan_id", metavar="<migration_plan_id>", help="ID of the migration plan to reset."
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        migration_plan_obj = utils.find_resource(client, parsed_args.migration_plan_id)
        migration_plan_obj.unlock()


class ImportMigrationPlanList(MigrationPlanCommand, lister.Lister):
    """Get list of migration_plans to be imported."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "--project_id",
            metavar="<project_id>",
            default=None,
            help="List migration_plans belongs to given project only.",
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        migration_plan_objs = client.get_import_migration_plans_list(
            project_id=parsed_args.project_id
        )
        return (
            ["ID", "Name", "Project_ID"],
            (
                osc_utils.get_dict_properties(
                    obj, ["id", "name", "project_id"]
                )
                for obj in migration_plan_objs
            ),
        )


class ImportMigrationPlans(MigrationPlanCommand, lister.Lister):
    """Import all migration plan records from backup store."""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "--migration_plan_ids",
            metavar="<migration_plan_id>",
            action="append",
            dest="migration_plan_ids",
            default=[],
            help="Specify migration_plan ids to import only specified migration_plans"
            " --migration-plan-ids <migration_plan_id> --migration-plan-ids <migration_plan_id>",
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        result = client.import_migration_plans(parsed_args.migration_plan_ids)
        if len(result["failed_migration_plans"]):
            message = (
                "\nPlease verify failed migration_plan id's are valid.\n"
            )
            utils.print_data_vertically([result["failed_migration_plans"]], ["Failed_MigrationPlans"])
            print(message)
            if result['imported_migration_plans']:
                print("Following migration_plans are imported successfully")
        return (
            ["Name", "ID", "ProjectID", "UserID"],
            (
                osc_utils.get_dict_properties(obj, ["name", "id", "project_id", "user_id"])
                for obj in result['imported_migration_plans']
            ),
        )