# 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 node 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 oslo_utils import strutils

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


class ListNode(command.Lister):
    """List nodes."""

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

    def get_parser(self, prog_name):
        parser = super(ListNode, self).get_parser(prog_name)
        parser.add_argument(
            '--cluster',
            metavar='<cluster>',
            help=_('ID or name of cluster from which nodes are to be listed')
        )
        parser.add_argument(
            '--filters',
            metavar='<"key1=value1;key2=value2...">',
            help=_("Filter parameters to apply on returned nodes. "
                   "This can be specified multiple times, or once with "
                   "parameters separated by a semicolon. The valid filter"
                   " keys are: ['status','name']"),
            action='append'
        )
        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:['index', 'name', 'status', 'init_at', "
                   "'created_at', 'updated_at']")
        )
        parser.add_argument(
            '--limit',
            metavar='<limit>',
            help=_('Limit the number of nodes returned')
        )
        parser.add_argument(
            '--marker',
            metavar='<id>',
            help=_('Only return nodes that appear after the given node ID')
        )
        parser.add_argument(
            '--global-project',
            default=False, action="store_true",
            help=_('Indicate that this node list should include nodes 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', 'index', 'status', 'cluster_id',
                   'physical_id', 'profile_name', 'created_at', 'updated_at',
                   'tainted']
        queries = {
            'cluster_id': parsed_args.cluster,
            'sort': parsed_args.sort,
            'limit': parsed_args.limit,
            'marker': parsed_args.marker,
            'global_project': parsed_args.global_project,
        }

        if parsed_args.filters:
            queries.update(senlin_utils.format_parameters(parsed_args.filters))

        nodes = senlin_client.nodes(**queries)
        if parsed_args.global_project:
            columns.append('project_id')
        if not parsed_args.full_id:
            formatters = {
                'id': lambda x: x[:8],
                'cluster_id': lambda x: x[:8] if x else '',
                'physical_id': lambda x: x[:8] if x else ''
            }
            if 'project_id' in columns:
                formatters['project_id'] = lambda x: x[:8]
        else:
            formatters = {}

        return (
            columns,
            (utils.get_item_properties(n, columns, formatters=formatters)
             for n in nodes)
        )


class ShowNode(command.ShowOne):
    """Show detailed info about the specified node."""

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

    def get_parser(self, prog_name):
        parser = super(ShowNode, self).get_parser(prog_name)
        parser.add_argument(
            '--details',
            default=False,
            action="store_true",
            help=_('Include physical object details')
        )
        parser.add_argument(
            'node',
            metavar='<node>',
            help=_('Name or ID of the node to show the details for')
        )
        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_node(senlin_client, parsed_args.node, parsed_args.details)


def _show_node(senlin_client, node_id, show_details=False):
    """Show detailed info about the specified node."""

    try:
        node = senlin_client.get_node(node_id, details=show_details)
    except sdk_exc.ResourceNotFound:
        raise exc.CommandError(_('Node not found: %s') % node_id)

    formatters = {
        'metadata': senlin_utils.json_formatter,
        'data': senlin_utils.json_formatter,
        'dependents': senlin_utils.json_formatter,
    }
    data = node.to_dict()
    if show_details and data['details']:
        formatters['details'] = senlin_utils.nested_dict_formatter(
            list(data['details'].keys()), ['property', 'value'])

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


class CreateNode(command.ShowOne):
    """Create the node."""

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

    def get_parser(self, prog_name):
        parser = super(CreateNode, self).get_parser(prog_name)
        parser.add_argument(
            '--cluster',
            metavar='<cluster>',
            help=_('Cluster Id or Name for this node')
        )
        parser.add_argument(
            '--role',
            metavar='<role>',
            help=_('Role for this node in the specific cluster')
        )
        parser.add_argument(
            '--metadata',
            metavar='<"key1=value1;key2=value2...">',
            help=_('Metadata values to be attached to the node. '
                   'This can be specified multiple times, or once with '
                   'key-value pairs separated by a semicolon'),
            action='append'
        )
        parser.add_argument(
            '--profile',
            metavar='<profile>',
            required=True,
            help=_('Profile Id or Name used for this node')
        )
        parser.add_argument(
            'name',
            metavar='<node-name>',
            help=_('Name of the node 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
        attrs = {
            'name': parsed_args.name,
            'cluster_id': parsed_args.cluster,
            'profile_id': parsed_args.profile,
            'role': parsed_args.role,
            'metadata': senlin_utils.format_parameters(parsed_args.metadata),
        }

        node = senlin_client.create_node(**attrs)
        return _show_node(senlin_client, node.id)


class UpdateNode(command.ShowOne):
    """Update the node."""

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

    def get_parser(self, prog_name):
        parser = super(UpdateNode, self).get_parser(prog_name)
        parser.add_argument(
            '--name',
            metavar='<name>',
            help=_('New name for the node')
        )
        parser.add_argument(
            '--profile',
            metavar='<profile>',
            help=_('ID or name of new profile to use')
        )
        parser.add_argument(
            '--role',
            metavar='<role>',
            help=_('Role for this node in the specific cluster')
        )
        parser.add_argument(
            '--metadata',
            metavar='<"key1=value1;key2=value2...">',
            help=_("Metadata values to be attached to the node. "
                   "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(
            '--tainted',
            metavar='<boolean>',
            help=_("Whether the node should be marked as tainted. "
                   "If true, this node will be selected first for the next"
                   "cluster scale-in operation.")

        )
        parser.add_argument(
            'node',
            metavar='<node>',
            help=_('Name or ID of node 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

        # Find the node first, we need its UUID
        node = senlin_client.find_node(parsed_args.node)
        if node is None:
            raise exc.CommandError(_('Node not found: %s') % parsed_args.node)

        attrs = {
            'name': parsed_args.name,
            'role': parsed_args.role,
            'profile_id': parsed_args.profile,
            'metadata': senlin_utils.format_parameters(parsed_args.metadata),
        }

        if parsed_args.tainted is not None:
            attrs['tainted'] = strutils.bool_from_string(
                parsed_args.tainted,
                strict=True,
            )

        senlin_client.update_node(node.id, **attrs)
        return _show_node(senlin_client, node.id)


class DeleteNode(command.Command):
    """Delete the node(s)."""

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

    def get_parser(self, prog_name):
        parser = super(DeleteNode, self).get_parser(prog_name)
        parser.add_argument(
            'node',
            metavar='<node>',
            nargs='+',
            help=_('Name or ID of node(s) to delete.')
        )
        parser.add_argument(
            '--force-delete',
            action='store_true',
            help=_('Force to delete node(s).')
        )
        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 node(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

        result = {}
        for nid in parsed_args.node:
            try:
                node_delete_action = senlin_client.delete_node(
                    nid, False, parsed_args.force_delete)
                result[nid] = ('OK', node_delete_action['id'])
            except Exception as ex:
                result[nid] = ('ERROR', str(ex))

        for rid, res in result.items():
            senlin_utils.print_action_result(rid, res)


class CheckNode(command.Command):
    """Check the node(s)."""
    log = logging.getLogger(__name__ + ".CheckNode")

    def get_parser(self, prog_name):
        parser = super(CheckNode, self).get_parser(prog_name)
        parser.add_argument(
            'node',
            metavar='<node>',
            nargs='+',
            help=_('ID or name of node(s) to check.')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering
        for nid in parsed_args.node:
            try:
                resp = senlin_client.check_node(nid)
            except sdk_exc.ResourceNotFound:
                raise exc.CommandError(_('Node not found: %s') % nid)
            if 'action' in resp:
                print('Node check request on node %(nid)s is accepted by '
                      'action %(action)s.'
                      % {'nid': nid, 'action': resp['action']})
            else:
                print('Request error: %s' % resp)


class RecoverNode(command.Command):
    """Recover the node(s)."""
    log = logging.getLogger(__name__ + ".RecoverNode")

    def get_parser(self, prog_name):
        parser = super(RecoverNode, self).get_parser(prog_name)
        parser.add_argument(
            '--check',
            metavar='<boolean>',
            default=False,
            help=_('Whether the node(s) should check physical resource status '
                   'before doing node recover. Default is false')
        )
        parser.add_argument(
            'node',
            metavar='<node>',
            nargs='+',
            help=_('ID or name of node(s) to recover.')
        )
        return parser

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

        params = {
            'check': strutils.bool_from_string(parsed_args.check, strict=True)
        }

        for nid in parsed_args.node:
            try:
                resp = senlin_client.recover_node(nid, **params)
            except sdk_exc.ResourceNotFound:
                raise exc.CommandError(_('Node not found: %s') % nid)
            if 'action' in resp:
                print('Node recover request on node %(nid)s is accepted by '
                      'action %(action)s.'
                      % {'nid': nid, 'action': resp['action']})
            else:
                print('Request error: %s' % resp)


class AdoptNode(command.ShowOne):
    """Adopt (or preview) the node."""

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

    def get_parser(self, prog_name):
        parser = super(AdoptNode, self).get_parser(prog_name)
        parser.add_argument(
            '--identity',
            metavar='<identity>',
            required=True,
            help=_('Physical resource id.'))
        parser.add_argument(
            '--type',
            metavar='<type>',
            required=True,
            help=_('The name of the profile type.')
        )
        parser.add_argument(
            '--role',
            metavar='<role>',
            help=_('Role for this node in the specific cluster.')
        )
        parser.add_argument(
            '--metadata',
            metavar='<"key1=value1;key2=value2...">',
            help=_('Metadata values to be attached to the node. '
                   'This can be specified multiple times, or once with '
                   'key-value pairs separated by a semicolon.'),
            action='append'
        )
        parser.add_argument(
            '--name',
            metavar='<node-name>',
            help=_('Name of the node to adopt.')
        )
        parser.add_argument(
            '--overrides',
            metavar='<json>',
            help=_('JSON formatted specification for overriding this node '
                   'properties.')
        )
        parser.add_argument(
            '--preview',
            default=False,
            help=_('Whether preview the node adopt request. If set, '
                   'only previewing this node and do not adopt.'),
            action='store_true',
        )
        parser.add_argument(
            '--snapshot',
            default=False,
            help=_('Whether a shapshot of the existing physical object '
                   'should be created before the object is adopted as '
                   'a node.'),
            action='store_true'
        )
        return parser

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

        senlin_client = self.app.client_manager.clustering

        preview = True if parsed_args.preview else False
        attrs = {
            'identity': parsed_args.identity,
            'overrides': senlin_utils.format_json_parameter(
                parsed_args.overrides),
            'snapshot': parsed_args.snapshot,
            'type': parsed_args.type
        }

        if not preview:
            attrs.update({
                'name': parsed_args.name,
                'role': parsed_args.role,
                'metadata': senlin_utils.format_parameters(
                    parsed_args.metadata),
            })

        node = senlin_client.adopt_node(preview, **attrs)

        if not preview:
            return _show_node(senlin_client, node.id)
        else:
            formatters = {}
            formatters['node_preview'] = senlin_utils.nested_dict_formatter(
                ['type', 'version', 'properties'],
                ['property', 'value'])
            data = node['node_profile']
            columns = sorted(data.keys())
            return columns, utils.get_dict_properties(data, columns,
                                                      formatters=formatters)


class NodeOp(command.Lister):
    """Perform an operation on a node."""
    log = logging.getLogger(__name__ + ".NodeOp")

    def get_parser(self, prog_name):
        parser = super(NodeOp, self).get_parser(prog_name)
        parser.add_argument(
            '--operation',
            metavar='<operation>',
            required=True,
            help=_('Operation to be performed on the node.')
        )
        parser.add_argument(
            '--params',
            metavar='<key1=value1;key2=value2...>',
            help=_("Parameters to for the specified operation. "
                   "This can be specified multiple times, or once with "
                   "parameters separated by a semicolon."),
            action="append"
        )
        parser.add_argument(
            'node',
            metavar='<node>',
            help=_('ID or name the node operate on.')
        )
        return parser

    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)", parsed_args)
        senlin_client = self.app.client_manager.clustering
        nid = parsed_args.node
        if parsed_args.params:
            params = senlin_utils.format_parameters(parsed_args.params)
        else:
            params = {}

        try:
            resp = senlin_client.perform_operation_on_node(
                nid, parsed_args.operation, **params)
        except sdk_exc.ResourceNotFound:
            raise exc.CommandError(_('Node not found: %s') % nid)
        if 'action' in resp:
            print('Request accepted by action: %s' % resp['action'])
        else:
            print('Request error: %s' % resp)