# Copyright (C) 2016 Catalyst IT Ltd
#
#    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.

import logging

import json
from stacktaskclient.common import utils
from stacktaskclient.common import http

from stacktaskclient.openstack.common._i18n import _

import stacktaskclient.exc as exc

logger = logging.getLogger(__name__)


def _authenticated_fetcher(sc):
    """
    A wrapper around the stacktask client object to fetch a template.
    """
    def _do(*args, **kwargs):
        if isinstance(sc.http_client, http.SessionClient):
            method, url = args
            return sc.http_client.request(url, method, **kwargs).content
        else:
            return sc.http_client.raw_request(*args, **kwargs).content

    return _do


# Tasks

@utils.arg('task_id', metavar='<taskid>',
           help=_('Task ID.'))
def do_task_show(sc, args):
    """
    Get individual task.
    """
    try:
        task = sc.tasks.get(task_id=args.task_id)

        formatters = {
            'actions': utils.json_formatter,
            'action_notes': utils.json_formatter,
            'keystone_user': utils.json_formatter,
            'approved_by': utils.json_formatter
        }
        utils.print_dict(task.to_dict(), formatters=formatters)
    except exc.HTTPNotFound:
        raise exc.CommandError(_('Task not found: %s') %
                               args.task_id)
    except exc.HTTPBadRequest as e:
        print e.message


@utils.arg('--filters', default={},
           help=_('Filters to use when getting the list.'))
def do_task_list(sc, args):
    """
    Show all tasks in the current project
    """
    fields = [
        'uuid', 'task_type', 'created_on',
        'approved_on', 'completed_on', 'cancelled']
    tasks_list = sc.tasks.list(args.filters)
    utils.print_list(tasks_list, fields)


@utils.arg('task_id', metavar='<taskid>',
           help=_('Task ID.'))
@utils.arg('--data', required=True,
           help=_('New data to update the Task with.'))
def do_task_update(sc, args):
    """
    Update a task with new data and rerun pre-approve validation.
    """
    try:
        resp = sc.tasks.update(args.task_id, args.data)
    except exc.HTTPNotFound as e:
        print e.message
    except exc.HTTPBadRequest as e:
        print e.message
    else:
        print 'Success:', ' '.join(resp.notes)
        do_task_show(sc, args)


@utils.arg('task_id', metavar='<taskid>',
           help=_('Task ID.'))
def do_task_approve(sc, args):
    """
    Approve a task.

    If already approved will rerun post-approve validation
    and reissue/resend token.
    """
    try:
        resp = sc.tasks.approve(args.task_id)
    except exc.HTTPNotFound as e:
        print e.message
    except exc.HTTPBadRequest as e:
        print e.message
    else:
        print 'Success:', ' '.join(resp.notes)
        do_task_show(sc, args)


@utils.arg('task_id', metavar='<taskid>',
           help=_('Task ID.'))
def do_task_reissue_token(sc, args):
    """
    Re-issues the token for the provided pending task.
    """
    try:
        resp = sc.tokens.reissue(task_id=args.task_id)
    except exc.HTTPNotFound as e:
        print e.message
    except exc.HTTPBadRequest as e:
        print e.message
    else:
        print 'Success:', ' '.join(resp.notes)
        do_task_show(sc, args)


@utils.arg('task_id', metavar='<taskid>',
           help=_('Task ID.'))
def do_task_cancel(sc, args):
    """
    Canel the task.
    """
    try:
        resp = sc.tasks.cancel(args.task_id)
    except exc.HTTPNotFound as e:
        print e.message
    except exc.HTTPBadRequest as e:
        print e.message
    else:
        print 'Success: %s' % resp.json()['notes']
        do_task_show(sc, args)


# Notifications

@utils.arg('note_id', metavar='<noteid>',
           help=_('Notification ID.'))
def do_notification_show(sc, args):
    """
    Get individual notification.
    """
    try:
        notification = sc.notifications.get(note_id=args.note_id)

        formatters = {
            'notes': utils.json_formatter
        }
        utils.print_dict(notification.to_dict(), formatters=formatters)
    except exc.HTTPNotFound:
        raise exc.CommandError(_('Notification not found: %s') %
                               args.note_id)
    except exc.HTTPBadRequest as e:
        print e.message


@utils.arg('--filters', default={},
           help=_('Filters to use when getting the list.'))
def do_notification_list(sc, args):
    """
    Show all notification.

    This is an admin only endpoint.
    """
    fields = ['uuid', 'task', 'acknowledged', 'created_on']
    notification_list = sc.notifications.list(args.filters)
    utils.print_list(notification_list, fields)


@utils.arg('note_ids', metavar='<noteids>', nargs='+',
           help=_('Notification IDs to acknowledge.'))
def do_notification_acknowledge(sc, args):
    """
    Acknowledge notification.
    """
    try:
        resp = sc.notifications.acknowledge(note_list=args.note_ids)

        print 'Success:', ' '.join(resp.notes)
    except exc.HTTPNotFound:
        raise exc.CommandError(_('Notification not found: %s') %
                               args.note_id)
    except exc.HTTPBadRequest as e:
        print e.message


# Tokens

@utils.arg('--filters', default={},
           help=_('Filters to use when getting the list.'))
def do_token_list(sc, args):
    """
    Show all tokens.

    This is an admin only endpoint.
    """
    fields = ['token', 'task', 'created_on', 'expires']
    token_list = sc.tokens.list(args.filters)
    utils.print_list(token_list, fields)


@utils.arg('token', metavar='<token>',
           help=_('Token id of the task'))
def do_token_show(sc, args):
    """
    Show details of this token
    including the arguments required for submit
    """
    try:
        token = sc.tokens.get(args.token)
    except exc.HTTPNotFound as e:
        print e.message
        print "Requested Token was not found."
    else:
        utils.print_dict(token.to_dict())


@utils.arg('token', metavar='<token>',
           help=_('Token id of the task'))
@utils.arg('--password', metavar='<password>', required=True,
           help=_('Password of the new user.'))
def do_token_submit_password(sc, args):
    """
    Submit this token to set or update your password.
    """
    json_data = {'password': args.password}
    _token_submit(sc, args, json_data)


@utils.arg('token', metavar='<token>',
           help=_('Token id of the task'))
@utils.arg('--data', metavar='<data>', required=True,
           help=_('Json with the data to submit.'))
def do_token_submit(sc, args):
    """
    Submit this token to finalise Task.
    """
    try:
        json_data = json.loads(args.data)
    except ValueError as e:
        print e.message
        print "Json data invalid."
        return
    _token_submit(sc, args, json_data)


def _token_submit(sc, args, json_data):
    try:
        sc.tokens.submit(args.token, json_data)
    except exc.HTTPNotFound as e:
        print e.message
        print "Requested token was not found."
    except exc.BadRequest as e:
        print e.message
        print "Bad request. Did you omit a required parameter?"
    else:
        print "Token submitted."


def do_token_clear_expired(sc, args):
    """
    Clear all expired tokens.

    This is an admin only endpoint.
    """
    try:
        resp = sc.tokens.clear_expired()
    except exc.HTTPNotFound as e:
        print e.message
    except exc.HTTPBadRequest as e:
        print e.message
    else:
        print 'Success: %s' % resp.json()['notes']
        fields = ['token', 'task', 'created_on', 'expires']
        token_list = sc.tokens.list({})
        utils.print_list(token_list, fields)


# User

@utils.arg('user_id', metavar='<userid>',
           help=_('User id.'))
def do_user_show(sc, args):
    """
    Show user details.
    """
    try:
        user = sc.users.get(args.user_id)
    except exc.HTTPNotFound as e:
        print e.message
        print "Requested User was not found."
    else:
        utils.print_dict(user.to_dict())


def do_user_list(sc, args):
    """List all users in project"""
    kwargs = {}
    fields = ['id', 'email', 'name', 'roles', 'cohort', 'status']

    project_users = sc.users.list(**kwargs)
    utils.print_list(project_users, fields, sortby_index=1)


@utils.arg('--roles', metavar='<roles>', nargs='+', required=True,
           help=_('Roles to grant to new user'))
@utils.arg('--username', metavar='<username>', default=None,
           help=_('username of user to invite'))
@utils.arg('--email', metavar='<email>', required=True,
           help=_('Email address of user to invite'))
def do_user_invite(sc, args):
    """
    Invites a user to become a member of a project.
    User does not need to have an existing openstack account.
    """
    roles = args.roles or ['Member']

    try:
        sc.users.invite(
            username=args.username, email=args.email, role_list=roles)
    except exc.HTTPNotFound as e:
        print e.message
        print e
    except exc.HTTPBadRequest as e:
        print "400 Bad Request: " + e.message
        print e
    else:
        print "Invitation sent."
        do_user_list(sc, args)


@utils.arg('user_id', metavar='<userid>',
           help=_('User id for unconfirmed user.'))
def do_user_invite_cancel(sc, args):
    """
    Cancel user details.
    """
    try:
        resp = sc.users.cancel(args.user_id)
        print 'Success: %s' % resp.json()
    except exc.HTTPNotFound as e:
        print e.message
        print "Requested User was not found."


@utils.arg('--user', '--user-id', metavar='<user>', required=True,
           help=_('Name or ID of user.'))
def do_user_role_list(sc, args):
    """ List the current roles of a user"""
    fields = ['id', 'name']
    user = utils.find_resource(sc.users, args.user)
    kwargs = {'user': user.id}
    roles = sc.user_roles.list(**kwargs)
    utils.print_list(roles, fields, sortby_index=0)


@utils.arg('--user', '--user-id', metavar='<user>', required=True,
           help=_('Name or ID of user.'))
@utils.arg('--role', '--role-id', metavar='<role>', required=True,
           help=_('Name or ID of role.'))
def do_user_role_add(sc, args):
    """Add a role to user"""
    role = utils.find_resource(sc.managed_roles, args.role)
    user = utils.find_resource(sc.users, args.user)
    if sc.user_roles.add(user.id, role=role.name):
        print "Task has been sucessfully completed.\n"
        do_user_list(sc, args)
    else:
        print "Your task was not sucessfully completed."


@utils.arg('--user', '--user-id', metavar='<user>',
           help=_('Name or ID of user.'))
@utils.arg('--role', '--role-id', metavar='<role>', required=True,
           help=_('Name or ID of role.'))
def do_user_role_remove(sc, args):
    """Remove a role from a user"""
    role = utils.find_resource(sc.managed_roles, args.role)
    user = utils.find_resource(sc.users, args.user)
    if sc.user_roles.remove(user.id, role=role.name):
        print "Task has been sucessfully completed.\n"
        do_user_list(sc, args)
    else:
        print "Your task was not sucessfully completed."


@utils.arg('email', metavar='<email>',
           help=_('email of the user account to reset'))
def do_user_password_forgot(sc, args):
    """Request a password reset email for a user."""
    sc.users.password_forgot(args.email)
    print "Task has been sucessfully submitted."
    print "If a user with that email exists, a reset token will be issued."


@utils.arg('email', metavar='<email>',
           help=_('email of the user account to reset'))
def do_user_password_reset(sc, args):
    """Force a password reset for a user. This is an admin only function."""
    sc.users.password_force_reset(args.email)
    print "Task has been sucessfully submitted."
    print "If a user with that email exists, a reset token will be issued."


def do_managed_role_list(sc, args):
    """List roles that may be managed in a given project"""
    fields = ['id', 'name']
    kwargs = {}
    roles = sc.managed_roles.list(**kwargs)
    utils.print_list(roles, fields, sortby_index=1)


# Status

def do_status(sc, args):
    """Requests server status endpoint and returns details of the api server"""
    status = sc.status.get()
    if status.status_code != 200:
        print "Failed: %s" % status.reason
        return
    print json.dumps(
        status.json(), sort_keys=True,
        indent=4, separators=(',', ': '))