import logging

from flask import jsonify, request
from flask_restx import Resource
from sqlalchemy import and_

from buyercall.blueprints.api.doc import serializers
from buyercall.blueprints.api.restplus import api
from buyercall.lib.util_rest import (rest_partnership_account, rest_partnership, requires_auth,
                                     rest_is_partnership_account, rest_is_partnership)
from buyercall.blueprints.user.models import User
from buyercall.extensions import db


log = logging.getLogger(__name__)
ns = api.namespace('users', description='Operations related to users.')


@ns.route('/')
@api.doc(responses={200: 'OK',
                    400: 'Error performing operation.',
                    401: 'Unauthorized request.'})
class ApiUserCollection(Resource):
    @requires_auth
    def get(self):
        """
        Retrieves partnership account users.

        Use this method to view the details of the partnership account users.

        """
        if rest_is_partnership_account and rest_partnership_account:
            linked_users = db.session.query(User).filter(
                and_(User.partnership_account_id == rest_partnership_account.id,
                     User.active == True)).all()
            user_list = list()

            if linked_users:
                for user in linked_users:
                    add_user = {
                        'id': user.id,
                        'firstname': user.firstname,
                        'lastname': user.lastname,
                        'email': user.email,
                        'phonenumber': user.phonenumber,
                        'company': user.company,
                        'title': user.title,
                        'role': user.role
                    }
                    user_list.append(add_user)

                return jsonify(
                    users=user_list
                )
            else:
                return jsonify(
                    users=user_list
                )
        elif rest_is_partnership and rest_partnership:
            partnership_accounts = rest_partnership.get_partnership_accounts()
            pa_list = list()

            if partnership_accounts:
                for pa in partnership_accounts:
                    linked_users = (db.session.query(User))\
                        .filter(User.partnership_account_id == pa.id)\
                        .all()
                    user_list = list()

                    if linked_users:
                        for user in linked_users:
                            add_user = {
                                'id': user.id,
                                'firstname': user.firstname,
                                'lastname': user.lastname,
                                'email': user.email,
                                'phonenumber': user.phonenumber,
                                'company': user.company,
                                'title': user.title,
                                'role': user.role
                            }
                            user_list.append(add_user)

                    add_pa = {
                        'name': pa.name,
                        'users': user_list
                    }
                    pa_list.append(add_pa)
                return jsonify(
                    accounts=pa_list
                )
            else:
                return jsonify(
                    accounts=pa_list
                )
        else:
            api.abort(401)

    @api.response(204, 'User successfully added.')
    @api.expect(serializers.user_row, validate=True)
    @requires_auth
    def post(self):
        """
        Adds a partnership account user.

        Use this method to add a partnership account.

        """
        if rest_is_partnership_account and rest_partnership_account:
            result = request.json

            if result:
                user = db.session.query(User) \
                    .filter(and_(User.email == result['email'],
                                 User.partnership_account_id == rest_partnership_account.id))\
                    .first()

                if user:
                    api.abort(code=400, message="User email already exists.")
                else:
                    final_result = User.create(result['title'],
                                               result['firstname'],
                                               result['lastname'],
                                               result['extension'],
                                               result['phonenumber'],
                                               result['email'],
                                               result['company'],
                                               result['department'],
                                               result['role'],
                                               result['username'],
                                               rest_partnership_account.id,
                                               result['password'])

                    if final_result:
                        return 204
                    else:
                        api.abort(400)
            else:
                api.abort(400)
        else:
            api.abort(401)


@ns.route('/<int:uid>')
@api.doc(responses={200: 'OK',
                    400: 'Error performing operation.',
                    401: 'Unauthorized request.'},
         params={'uid': 'The user ID.'})
class ApiUser(Resource):
    @api.response(204, 'User successfully updated.')
    @api.expect(serializers.user_row, validate=True)
    @requires_auth
    def put(self, uid):
        """
        Update a partnership account user.

        Use this method to update a partnership account's user.

        NB: Username and password will not be updated.

        """
        if rest_is_partnership_account and rest_partnership_account:
            result = request.json

            if result:
                final_result = User.update(uid,
                                           rest_partnership_account.id,
                                           result['title'],
                                           result['firstname'],
                                           result['lastname'],
                                           result['extension'],
                                           result['phonenumber'],
                                           result['email'],
                                           result['company'],
                                           result['department'],
                                           result['role'])

                if final_result:
                    return True, 204
                else:
                    api.abort(400)
            else:
                api.abort(400)
        else:
            api.abort(401)

    @api.response(204, 'User successfully deleted.')
    @requires_auth
    def delete(self, uid):
        """
        Delete a partnership account user.

        Use this method to delete a partnership account.

        """
        if rest_is_partnership_account and rest_partnership_account:
            final_result = User.deactivate(uid, rest_partnership_account.id)

            if final_result:
                return True, 204
            else:
                api.abort(400)
        else:
            api.abort(401)