# Copyright (c) 2023 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#

import base64
from osc_lib.command import command

from dcmanagerclient.commands.v1 import base
from dcmanagerclient import exceptions
from dcmanagerclient import utils


def peer_format(system_peer=None):
    columns = (
        'id',
        'peer uuid',
        'peer name',
        'manager endpoint',
        'controller gateway address'
    )

    if system_peer:
        data = (
            system_peer.peer_id,
            system_peer.peer_uuid,
            system_peer.peer_name,
            system_peer.manager_endpoint,
            system_peer.gateway_address
        )

    else:
        data = (tuple('<none>' for _ in range(len(columns))),)

    return columns, data


def detail_peer_format(system_peer=None):
    # Include all the fields in peer_format
    # plus some additional fields
    columns = (
        'id',
        'peer uuid',
        'peer name',
        'manager endpoint',
        'manager username',
        'controller gateway address',
        'administrative state',
        'heartbeat interval',
        'heartbeat failure threshold',
        'heartbeat failure policy',
        'heartbeat maintenance timeout',
        'heartbeat status',
        'created_at',
        'updated_at',
    )

    if system_peer:
        data = (
            system_peer.peer_id,
            system_peer.peer_uuid,
            system_peer.peer_name,
            system_peer.manager_endpoint,
            system_peer.manager_username,
            system_peer.gateway_address,
            system_peer.administrative_state,
            system_peer.heartbeat_interval,
            system_peer.heartbeat_failure_threshold,
            system_peer.heartbeat_failure_policy,
            system_peer.heartbeat_maintenance_timeout,
            system_peer.heartbeat_status,
            system_peer.created_at,
            system_peer.updated_at,
        )
    else:
        data = (tuple('<none>' for _ in range(len(columns))),)

    return columns, data


class AddSystemPeer(base.DCManagerShowOne):
    """Add a new system peer."""

    def _get_format_function(self):
        return detail_peer_format

    def get_parser(self, prog_name):
        parser = super(AddSystemPeer, self).get_parser(prog_name)

        parser.add_argument(
            '--peer-uuid',
            required=True,
            help='UUID of the new system peer.'
        )

        parser.add_argument(
            '--peer-name',
            required=True,
            help='Name for the new system peer.'
        )

        parser.add_argument(
            '--manager-endpoint',
            required=True,
            help='URI of DC manager of peer System Controller.'
        )

        parser.add_argument(
            '--peer-controller-gateway-address',
            required=True,
            help='Gateway address of peer site controller node.'
        )

        parser.add_argument(
            '--manager-username',
            required=False,
            default='admin',
            help='Administrative username (default admin).'
        )

        parser.add_argument(
            '--manager-password',
            required=False,
            help='Admin user password for authenticating into the DC manager.'
        )

        parser.add_argument(
            '--administrative-state',
            required=False,
            choices=['enabled', 'disabled'],
            default='enabled',
            help='Administrative control of peer state (default enabled).'
        )

        parser.add_argument(
            '--heartbeat-interval',
            required=False,
            default=60,
            help='Interval between heartbeat messages (in seconds) (default \
                  60).'
        )

        parser.add_argument(
            '--heartbeat-failure-threshold',
            required=False,
            default=3,
            help='Consecutive heartbeat failures before failure declared \
                  (default 3).'
        )

        parser.add_argument(
            '--heartbeat-failure-policy',
            required=False,
            choices=['alarm', 'rehome', 'delegate'],
            default='alarm',
            help='Action to take with failure detection (default alarm).'
        )

        parser.add_argument(
            '--heartbeat-maintenance-timeout',
            required=False,
            default=600,
            help='Overall failure timeout during maintenance state (in \
                  seconds) (default 600).'
        )
        return parser

    def _get_resources(self, parsed_args):
        dcmanager_client = self.app.client_manager.system_peer_manager
        kwargs = dict()

        if parsed_args.peer_uuid is not None:
            kwargs['peer_uuid'] = parsed_args.peer_uuid

        if parsed_args.peer_name is not None:
            kwargs['peer_name'] = parsed_args.peer_name

        if parsed_args.manager_endpoint is not None:
            kwargs['manager_endpoint'] = parsed_args.manager_endpoint

        if parsed_args.manager_username is not None:
            kwargs['manager_username'] = parsed_args.manager_username

        # Prompt the user for the peer's password if it isn't provided
        if parsed_args.manager_password is not None:
            kwargs['manager_password'] = base64.b64encode(
                parsed_args.manager_password.encode("utf-8")).decode("utf-8")
        else:
            password = utils.prompt_for_password(
                password_type=parsed_args.manager_username,
                item_type='system peer')
            kwargs["manager_password"] = base64.b64encode(
                password.encode("utf-8")).decode("utf-8")

        if parsed_args.peer_controller_gateway_address is not None:
            kwargs['peer_controller_gateway_address'] = \
                parsed_args.peer_controller_gateway_address

        if parsed_args.administrative_state is not None:
            kwargs['administrative_state'] = parsed_args.administrative_state

        if parsed_args.heartbeat_interval is not None:
            kwargs['heartbeat_interval'] = parsed_args.heartbeat_interval

        if parsed_args.heartbeat_failure_threshold is not None:
            kwargs['heartbeat_failure_threshold'] = \
                parsed_args.heartbeat_failure_threshold

        if parsed_args.heartbeat_failure_policy is not None:
            kwargs['heartbeat_failure_policy'] = \
                parsed_args.heartbeat_failure_policy

        if parsed_args.heartbeat_maintenance_timeout is not None:
            kwargs['heartbeat_maintenance_timeout'] = \
                parsed_args.heartbeat_maintenance_timeout
        return dcmanager_client.system_peer_manager.add_system_peer(
            **kwargs)


class ListSystemPeer(base.DCManagerLister):
    """List system peers."""

    def _get_format_function(self):
        return peer_format

    def get_parser(self, prog_name):
        parser = super(ListSystemPeer, self).get_parser(prog_name)
        return parser

    def _get_resources(self, parsed_args):
        dcmanager_client = self.app.client_manager.system_peer_manager
        return dcmanager_client.system_peer_manager.list_system_peers()


class ShowSystemPeer(base.DCManagerShowOne):
    """Show the details of a system peer."""

    def _get_format_function(self):
        return detail_peer_format

    def get_parser(self, prog_name):
        parser = super(ShowSystemPeer, self).get_parser(prog_name)

        parser.add_argument(
            'peer',
            help='UUID or ID of system peer to view the details.'
        )

        return parser

    def _get_resources(self, parsed_args):
        system_peer_ref = parsed_args.peer
        dcmanager_client = self.app.client_manager.system_peer_manager
        return dcmanager_client.system_peer_manager.\
            system_peer_detail(system_peer_ref)


class DeleteSystemPeer(command.Command):
    """Delete system peer details from the database."""

    def get_parser(self, prog_name):
        parser = super(DeleteSystemPeer, self).get_parser(prog_name)

        parser.add_argument(
            'peer',
            help='UUID or ID of the system peer to delete.'
        )
        return parser

    def take_action(self, parsed_args):
        system_peer_ref = parsed_args.peer
        dcmanager_client = self.app.client_manager.system_peer_manager
        try:
            dcmanager_client.system_peer_manager.\
                delete_system_peer(system_peer_ref)
        except Exception as e:
            print(e)
            msg = "Unable to delete system peer %s" % (system_peer_ref)
            raise exceptions.DCManagerClientException(msg)


class UpdateSystemPeer(base.DCManagerShowOne):
    """Update attributes of a system peer."""

    def _get_format_function(self):
        return detail_peer_format

    def get_parser(self, prog_name):
        parser = super(UpdateSystemPeer, self).get_parser(prog_name)

        parser.add_argument(
            'peer',
            help='UUID or ID of the system peer to update.'
        )

        parser.add_argument(
            '--peer-uuid',
            required=False,
            help='UUID of the new system peer.'
        )

        parser.add_argument(
            '--peer-name',
            required=False,
            help='Name for the new system peer.'
        )

        parser.add_argument(
            '--manager-endpoint',
            required=False,
            help='URI of DC manager of peer System Controller.'
        )

        parser.add_argument(
            '--manager-username',
            required=False,
            help='Administrative username (default admin).'
        )

        parser.add_argument(
            '--manager-password',
            required=False,
            nargs='?',
            const=True,
            help='Admin user password for authenticating into the DC manager'
        )

        parser.add_argument(
            '--peer-controller-gateway-address',
            required=False,
            help='Gateway address of peer site controller node.'
        )

        parser.add_argument(
            '--administrative-state',
            required=False,
            choices=['enabled', 'disabled'],
            help='Administrative control of peer state (default enabled).'
        )

        parser.add_argument(
            '--heartbeat-interval',
            required=False,
            help='Interval between heartbeat messages (in seconds) (default \
                  60).'
        )

        parser.add_argument(
            '--heartbeat-failure-threshold',
            required=False,
            help='Consecutive heartbeat failures before failure declared \
                  (default 3).'
        )

        parser.add_argument(
            '--heartbeat-failure-policy',
            required=False,
            choices=['alarm', 'rehome', 'delegate'],
            help='Action to take with failure detection (default alarm).'
        )

        parser.add_argument(
            '--heartbeat-maintenance-timeout',
            required=False,
            help='Overall failure timeout during maintenance state (in \
                  seconds) (default 600).'
        )

        return parser

    def _get_resources(self, parsed_args):
        system_peer_ref = parsed_args.peer
        dcmanager_client = self.app.client_manager.system_peer_manager
        kwargs = dict()
        if parsed_args.peer_uuid:
            kwargs['peer_uuid'] = parsed_args.peer_uuid
        if parsed_args.peer_name:
            kwargs['peer_name'] = parsed_args.peer_name
        if parsed_args.manager_endpoint:
            kwargs['manager_endpoint'] = parsed_args.manager_endpoint
        if parsed_args.manager_username:
            kwargs['manager_username'] = parsed_args.manager_username
        if parsed_args.manager_password:
            if parsed_args.manager_password is True:
                password = utils.prompt_for_password(
                    password_type='update',
                    item_type='system peer')
                kwargs["manager_password"] = base64.b64encode(
                    password.encode("utf-8")).decode("utf-8")
            else:
                kwargs['manager_password'] = base64.b64encode(
                    parsed_args.manager_password.encode(
                        "utf-8")).decode("utf-8")
        if parsed_args.peer_controller_gateway_address:
            kwargs['peer_controller_gateway_address'] = \
                parsed_args.peer_controller_gateway_address
        if parsed_args.administrative_state:
            kwargs['administrative_state'] = parsed_args.administrative_state
        if parsed_args.heartbeat_interval:
            kwargs['heartbeat_interval'] = parsed_args.heartbeat_interval
        if parsed_args.heartbeat_failure_threshold:
            kwargs['heartbeat_failure_threshold'] = \
                parsed_args.heartbeat_failure_threshold
        if parsed_args.heartbeat_failure_policy:
            kwargs['heartbeat_failure_policy'] = \
                parsed_args.heartbeat_failure_policy
        if parsed_args.heartbeat_maintenance_timeout:
            kwargs['heartbeat_maintenance_timeout'] = \
                parsed_args.heartbeat_maintenance_timeout
        if len(kwargs) == 0:
            error_msg = "Nothing to update"
            raise exceptions.DCManagerClientException(error_msg)

        try:
            return dcmanager_client. \
                system_peer_manager.update_system_peer(
                    system_peer_ref, **kwargs)
        except Exception as e:
            print(e)
            msg = "Unable to update system peer %s" % (system_peer_ref)
            raise exceptions.DCManagerClientException(msg)