from datetime import datetime
import logging

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

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


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


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

        Use this method to view the details of the partnership accounts.
        """
        if rest_is_partnership_account and rest_partnership_account:
            users = (db.session.query(User)).filter(User.partnership_account_id == rest_partnership_account.id).all()
            user_list = list()

            if users:
                for user in users:
                    add_user = {
                        '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(
                name=rest_partnership_account.name,
                is_active=rest_partnership_account.active,
                billing_type=rest_partnership_account.billing_type,
                users=user_list
            )
        elif rest_is_partnership and rest_partnership:
            partnership_accounts = rest_partnership.get_partnership_accounts()
            pa_list = list()
            users = (db.session.query(User)).filter(User.partnership_id == rest_partnership.id).all()
            user_list = list()

            if partnership_accounts:
                for pa in partnership_accounts:
                    pa_users = (db.session.query(User))\
                        .filter(and_(User.partnership_account_id == pa.id,
                                     User.active == True)).all()
                    pa_user_list = list()

                    if pa_users:
                        for pa_user in pa_users:
                            add_pa_user = {
                                'firstname': pa_user.firstname,
                                'lastname': pa_user.lastname,
                                'email': pa_user.email,
                                'phonenumber': pa_user.phonenumber,
                                'company': pa_user.company,
                                'title': pa_user.title,
                                'role': pa_user.role
                            }
                            pa_user_list.append(add_pa_user)

                    add_pa = {
                        'name': rest_partnership_account.name,
                        'billing_type': rest_partnership_account.billing_type,
                        'users': pa_user_list
                    }
                    pa_list.append(add_pa)

            if users:
                for user in users:
                    add_user = {
                        '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(
                name=rest_partnership.name,
                billing_type=rest_partnership.billing_type,
                users=user_list,
                accounts=pa_list
            )
        else:
            return api.abort(401)

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

        Use this method to add a partnership account.

        NB: Only can be used by a partnership.

        """
        if rest_is_partnership and rest_partnership:
            result = request.json

            if result:
                params = {
                    'name': result['name'],
                    'partnership_account_id': rest_partnership.id,
                    'active': True,
                    'billing_type': result['billing_type']
                }

                if PartnershipAccount.create(params):
                    return True, 204
                else:
                    api.abort(code=400, message="Error creating partnership account.")
            else:
                return api.abort(400)
        else:
            return api.abort(401)

    @api.response(204, 'Partnership account successfully updated.')
    @api.expect(serializers.account_row, validate=True)
    @requires_auth
    def put(self):
        """
        Update a partnership account.

        Use this method to update a partnership account.

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

            if result:
                if PartnershipAccount.update(rest_partnership_account.id,
                                             result['name'],
                                             result['billing_type']):
                    return True, 204
                else:
                    api.abort(code=400, message="Error updating partnership account.")
            else:
                return api.abort(400)
        else:
            return api.abort(401)


@ns.route('/usage/')
@api.doc(responses={200: 'OK',
                    400: 'Error performing operation.',
                    401: 'Unauthorized request.',
                    404: 'Partnership account not found.'})
class Usage(Resource):
    @requires_auth
    def get(self):
        """
        Retrieves partnership usage measurements.

        Use this method to retrieve the total minutes used and minutes used this month.

        """

        if rest_is_partnership_account and rest_partnership_account:
            now = datetime.now()
            year = now.year
            month = now.month
            total_minutes_result = 0
            month_minutes_result = 0
            total_minutes = (db.session.query(func.sum(Lead.duration))
                             .filter(Lead.partnership_account_id == rest_partnership_account.id).scalar())

            if total_minutes:
                total_minutes_result = total_minutes / 60

            month_minutes = (db.session.query(func.sum(Lead.duration))
                             .filter(Lead.partnership_account_id == rest_partnership_account.id)
                             .filter(extract('year', Lead.created_on) == year)
                             .filter(extract('month', Lead.created_on) == month).scalar())

            if month_minutes:
                month_minutes_result = month_minutes / 60

            return jsonify(
                total_minutes=total_minutes_result,
                total_minutes_month=month_minutes_result
            )
        elif rest_is_partnership and rest_partnership:
            partnership_accounts = rest_partnership.get_partnership_accounts()
            pa_list = list()
            now = datetime.now()
            year = now.year
            month = now.month

            if partnership_accounts:
                for pa in partnership_accounts:
                    total_minutes_result = 0
                    month_minutes_result = 0
                    total_minutes = (db.session.query(func.sum(Lead.duration))
                                     .filter(Lead.partnership_account_id == pa.id)
                                     .scalar())

                    if total_minutes:
                        total_minutes_result = total_minutes / 60

                    month_minutes = (db.session.query(func.sum(Lead.duration))
                                     .filter(Lead.partnership_account_id == pa.id)
                                     .filter(extract('year', Lead.created_on) == year)
                                     .filter(extract('month', Lead.created_on) == month)
                                     .scalar())

                    if month_minutes:
                        month_minutes_result = month_minutes / 60

                    add_pa = {
                        'name': pa.name,
                        'total_minutes': total_minutes_result,
                        'total_minutes_month': month_minutes_result
                    }
                    pa_list.append(add_pa)

            return jsonify(
                accounts=pa_list
            )
        else:
            return api.abort(401)