# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

"""Clustering v1 profile action implementations"""

import logging
import sys

from openstack import exceptions as sdk_exc
from osc_lib.command import command
from osc_lib import exceptions as exc
from osc_lib import utils

from senlinclient.common.i18n import _
from senlinclient.common import utils as senlin_utils


class ShowProfile(command.ShowOne):
    """Show profile details."""

    log = logging.getLogger(__name__ + ".ShowProfile")

    def get_parser(self, prog_name):
        parser = super(ShowProfile, self).get_parser(prog_name)
        parser.add_argument(
            'profile',
            metavar='<profile>',
            help='Name or ID of profile to show',
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)

        senlin_client = self.app.client_manager.clustering
        return _show_profile(senlin_client, profile_id=parsed_args.profile)


def _show_profile(senlin_client, profile_id):
    try:
        data = senlin_client.get_profile(profile_id)
    except sdk_exc.ResourceNotFound:
        raise exc.CommandError('Profile not found: %s' % profile_id)
    else:
        formatters = {}
        formatters['metadata'] = senlin_utils.json_formatter
        formatters['spec'] = senlin_utils.nested_dict_formatter(
            ['type', 'version', 'properties'],
            ['property', 'value'])

        data = data.to_dict()
        columns = sorted(data.keys())
        return columns, utils.get_dict_properties(data, columns,
                                                  formatters=formatters)


class ListProfile(command.Lister):
    """List profiles that meet the criteria."""

    log = logging.getLogger(__name__ + ".ListProfile")

    def get_parser(self, prog_name):
        parser = super(ListProfile, self).get_parser(prog_name)
        parser.add_argument(
            '--limit',
            metavar='<limit>',
            help=_('Limit the number of profiles returned')
        )
        parser.add_argument(
            '--marker',
            metavar='<id>',
            help=_('Only return profiles that appear after the given profile '
                   'ID')
        )
        parser.add_argument(
            '--sort',
            metavar='<key>[:<direction>]',
            help=_("Sorting option which is a string containing a list of keys"
                   " separated by commas. Each key can be optionally appended "
                   "by a sort direction (:asc or :desc). The valid sort_keys "
                   "are:['type', 'name', 'created_at', 'updated_at']")
        )
        parser.add_argument(
            '--filters',
            metavar='<"key1=value1;key2=value2...">',
            help=_("Filter parameters to apply on returned profiles. "
                   "This can be specified multiple times, or once with "
                   "parameters separated by a semicolon. The valid filter "
                   "keys are: ['type', 'name']"),
            action='append'
        )
        parser.add_argument(
            '--global-project',
            default=False,
            action="store_true",
            help=_('Indicate that the list should include profiles from'
                   ' all projects. This option is subject to access policy '
                   'checking. Default is False')
        )
        parser.add_argument(
            '--full-id',
            default=False,
            action="store_true",
            help=_('Print full IDs in list')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)

        senlin_client = self.app.client_manager.clustering

        columns = ['id', 'name', 'type', 'created_at']
        queries = {
            'limit': parsed_args.limit,
            'marker': parsed_args.marker,
            'sort': parsed_args.sort,
            'global_project': parsed_args.global_project,
        }
        if parsed_args.filters:
            queries.update(senlin_utils.format_parameters(parsed_args.filters))
        data = senlin_client.profiles(**queries)

        formatters = {}
        if parsed_args.global_project:
            columns.append('project_id')
        if not parsed_args.full_id:
            formatters = {
                'id': lambda x: x[:8],
            }
            if 'project_id' in columns:
                formatters['project_id'] = lambda x: x[:8]

        return (
            columns,
            (utils.get_item_properties(p, columns, formatters=formatters)
             for p in data)
        )


class DeleteProfile(command.Command):
    """Delete profile(s)."""

    log = logging.getLogger(__name__ + ".DeleteProfile")

    def get_parser(self, prog_name):
        parser = super(DeleteProfile, self).get_parser(prog_name)
        parser.add_argument(
            'profile',
            metavar='<profile>',
            nargs='+',
            help=_('Name or ID of profile(s) to delete')
        )
        parser.add_argument(
            '--force',
            action='store_true',
            help=_('Skip yes/no prompt (assume yes)')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering

        try:
            if not parsed_args.force and sys.stdin.isatty():
                sys.stdout.write(
                    _("Are you sure you want to delete this profile(s)"
                      " [y/N]?"))
                sys.stdout.flush()
                prompt_response = sys.stdin.readline().lower()
                if not prompt_response.startswith('y'):
                    return
        except KeyboardInterrupt:  # Ctrl-c
            self.log.info('Ctrl-c detected.')
            return
        except EOFError:  # Ctrl-d
            self.log.info('Ctrl-d detected')
            return

        failure_count = 0
        for pid in parsed_args.profile:
            try:
                senlin_client.delete_profile(pid, False)
            except Exception as ex:
                failure_count += 1
                print(ex)
        if failure_count:
            raise exc.CommandError(_('Failed to delete %(count)s of the '
                                     '%(total)s specified profile(s).') %
                                   {'count': failure_count,
                                   'total': len(parsed_args.profile)})
        print('Profile deleted: %s' % parsed_args.profile)


class CreateProfile(command.ShowOne):
    """Create a profile."""

    log = logging.getLogger(__name__ + ".CreateProfile")

    def get_parser(self, prog_name):
        parser = super(CreateProfile, self).get_parser(prog_name)
        parser.add_argument(
            '--metadata',
            metavar='<"key1=value1;key2=value2...">',
            help=_('Metadata values to be attached to the profile. '
                   'This can be specified multiple times, or once with '
                   'key-value pairs separated by a semicolon'),
            action='append'
        )
        parser.add_argument(
            '--spec-file',
            metavar='<spec-file>',
            required=True,
            help=_('The spec file used to create the profile')
        )
        parser.add_argument(
            'name',
            metavar='<profile-name>',
            help=_('Name of the profile to create')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering

        spec = senlin_utils.get_spec_content(parsed_args.spec_file)
        type_name = spec.get('type', None)
        type_version = spec.get('version', None)
        properties = spec.get('properties', None)
        if type_name is None:
            raise exc.CommandError(_("Missing 'type' key in spec file."))
        if type_version is None:
            raise exc.CommandError(_("Missing 'version' key in spec file."))
        if properties is None:
            raise exc.CommandError(_("Missing 'properties' key in spec file."))

        if type_name == 'os.heat.stack':
            stack_properties = senlin_utils.process_stack_spec(properties)
            spec['properties'] = stack_properties

        params = {
            'name': parsed_args.name,
            'spec': spec,
            'metadata': senlin_utils.format_parameters(parsed_args.metadata),
        }

        profile = senlin_client.create_profile(**params)
        return _show_profile(senlin_client, profile_id=profile.id)


class UpdateProfile(command.ShowOne):
    """Update a profile."""

    log = logging.getLogger(__name__ + ".UpdateProfile")

    def get_parser(self, prog_name):
        parser = super(UpdateProfile, self).get_parser(prog_name)
        parser.add_argument(
            '--name',
            metavar='<name>',
            help=_('The new name for the profile')
        )
        parser.add_argument(
            '--metadata',
            metavar='<"key1=value1;key2=value2...">',
            help=_("Metadata values to be attached to the profile. "
                   "This can be specified multiple times, or once with "
                   "key-value pairs separated by a semicolon. Use '{}' "
                   "can clean metadata "),
            action='append'
        )
        parser.add_argument(
            'profile',
            metavar='<profile>',
            help=_('Name or ID of the profile to update')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering

        params = {
            'name': parsed_args.name,
        }
        if parsed_args.metadata:
            params['metadata'] = senlin_utils.format_parameters(
                parsed_args.metadata)

        # Find the profile first, we need its id
        profile = senlin_client.find_profile(parsed_args.profile)
        if profile is None:
            raise exc.CommandError(_('Profile not found: %s') %
                                   parsed_args.profile)
        senlin_client.update_profile(profile.id, **params)
        return _show_profile(senlin_client, profile_id=profile.id)


class ValidateProfile(command.ShowOne):
    """Validate a profile."""

    log = logging.getLogger(__name__ + ".ValidateProfile")

    def get_parser(self, prog_name):
        parser = super(ValidateProfile, self).get_parser(prog_name)
        parser.add_argument(
            '--spec-file',
            metavar='<spec-file>',
            required=True,
            help=_('The spec file of the profile to be validated')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering

        spec = senlin_utils.get_spec_content(parsed_args.spec_file)
        type_name = spec.get('type', None)
        type_version = spec.get('version', None)
        properties = spec.get('properties', None)
        if type_name is None:
            raise exc.CommandError(_("Missing 'type' key in spec file."))
        if type_version is None:
            raise exc.CommandError(_("Missing 'version' key in spec file."))
        if properties is None:
            raise exc.CommandError(_("Missing 'properties' key in spec file."))

        if type_name == 'os.heat.stack':
            stack_properties = senlin_utils.process_stack_spec(properties)
            spec['properties'] = stack_properties

        params = {
            'spec': spec,
        }

        profile = senlin_client.validate_profile(**params)

        formatters = {}
        formatters['metadata'] = senlin_utils.json_formatter
        formatters['spec'] = senlin_utils.nested_dict_formatter(
            ['type', 'version', 'properties'],
            ['property', 'value'])

        columns = [
            'created_at',
            'domain',
            'id',
            'metadata',
            'name',
            'project_id',
            'spec',
            'type',
            'updated_at',
            'user_id'
        ]
        return columns, utils.get_dict_properties(profile.to_dict(), columns,
                                                  formatters=formatters)