import six
import uuid
from cliff import show, lister
from osc_lib import utils as osc_utils
from osc_lib.cli import format_columns

from workloadmgrclient import utils
from workloadmgrclient.v1 import WorkloadmgrCommand


class BackupTargetCommand(WorkloadmgrCommand):
    resource = "backup_targets"


class ListBackupTarget(BackupTargetCommand, lister.Lister):
    """List all the backup targets."""

    def take_action(self, parsed_args):
        client = self.get_client()
        backup_targets = client.list(detailed=False) or []
        return (
            ["ID", "Type", "Backend Endpoint", "Backend Mountpath", "Is_Default", "Status", "Version", "Capacity", "Used", "Created At"],
            (
                osc_utils.get_item_properties(
                    obj, ["id", "type", "filesystem_export", "filesystem_export_mount_path", "is_default", "status", "version", "capacity", "used", "created_at"]
                )
                for obj in backup_targets
            ),
        )


class ShowBackupTarget(BackupTargetCommand, show.ShowOne):
    """Show details about backup targets"""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "backup_target_id", metavar="<backup_target_id>", help="ID of the backup target."
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        bt_obj = utils.find_resource(client, parsed_args.backup_target_id)
        btt_id_list = []
        if bt_obj.backup_target_types:
            for btt in bt_obj.backup_target_types:
                btt_id_list.append(btt['name'])
        info = {}
        info.update(bt_obj._info)
        info['backup_target_types'] = btt_id_list
        columns = list(info.keys())
        data = osc_utils.get_dict_properties(info, columns)
        return columns, data


class CreateBackupTarget(BackupTargetCommand, show.ShowOne):
    """Create backup target"""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "--s3-endpoint-url",
            metavar="<s3_endpoint_url>",
            help="S3 endpoint URL.",
            default=None
        )

        parser.add_argument(
            "--s3-bucket",
            metavar="<s3_bucket>",
            help="S3 bucket. Required for s3 backup target type ",
            default=None
        )

        parser.add_argument(
            "--filesystem-export",
            metavar="<filesystem_export>",
            help="BT filesystem export path. Required for nfs backup target only. For s3 it's handled internally",
            default=None
        )

        parser.add_argument(
            "--type",
            metavar="<type>",
            help="Required BT type. Eg. nfs, s3"
        )

        parser.add_argument(
            "--btt-name",
            metavar="<btt_name>",
            help="optional Backup Target Type name. If not provided, then we use BTT id as BTT name"
        )

        parser.add_argument(
            "--default", help="denotes whether Backup Target is default", action='store_true'
        )

        parser.add_argument(
            "--immutable", help="denotes whether Backup Target is immutable", action='store_true'
        )

        parser.add_argument(
            "--metadata",
            metavar="metadata",
            nargs="+",
            default={},
            help="Specify a key value pairs to include in the BT metadata "
            "Eg. --metadata key1=value1 key2=value2 keyN=valueN",
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        metadata = {}
        for metadata_str in parsed_args.metadata:
            try:
                k, v = metadata_str.split("=", 1)
            except ValueError:
                err_msg = (
                "Invalid metadata argument '%s'. metadata arguments must be of the "
                "form --metadata <key1=value1> <key2=value2> <keyN=valueN>" % metadata_str
                )
                raise exceptions.CommandError(err_msg)

            if k in metadata:
                metadata[k] = v
            else:
                metadata.setdefault(k, v)
        bt_obj = client.create(
            parsed_args.s3_endpoint_url,
            parsed_args.s3_bucket,
            parsed_args.filesystem_export,
            parsed_args.type,
            parsed_args.btt_name,
            parsed_args.default,
            parsed_args.immutable,
            metadata
        )

        info = {}
        info.update(bt_obj._info)
        columns = list(info.keys())
        data = osc_utils.get_dict_properties(info, columns)
        return columns, data


class DeleteBackupTarget(BackupTargetCommand):
    """Delete existing backup target"""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "backup_target_id", metavar="<backup_target_id>", help="ID of the backup target to delete."
        )
    def take_action(self, parsed_args):
        client = self.get_client()
        client.delete(parsed_args.backup_target_id)
        return True


class BackupTargetSetDefault(BackupTargetCommand, show.ShowOne):
    """Set existing backup target as default, it's respective one of BTT will be set as default, If BTT doesn't exists then it will be created and set as default BTT"""

    @staticmethod
    def _add_arguments(parser):
        parser.add_argument(
            "backup_target_id",
            metavar="<backup_target_id>",
            help="ID of the backup target which needs to be set as default"
        )

    def take_action(self, parsed_args):
        client = self.get_client()
        try:
            uuid.UUID(parsed_args.backup_target_id)
        except ValueError:
            raise exceptions.CommandError("Invalid backup_target_id: {}".format(parsed_args.backup_target_id))

        bt_obj = client.set_default(
            parsed_args.backup_target_id,
        )
        info = {}
        info.update(bt_obj._info)
        columns = list(info.keys())
        data = osc_utils.get_dict_properties(info, columns)
        return columns, data