from flask import (
    Blueprint,
    jsonify,
    render_template, request)

from flask_login import login_required, current_user

from sqlalchemy.sql.elements import and_

from buyercall.blueprints.user.decorators import role_required

from buyercall.blueprints.partnership.models import (
    Partnership,
    PartnershipAccount,)
from buyercall.extensions import db
from datatables import DataTables, ColumnDT
from .models import ActivityLogs
import logging
from sqlalchemy import desc, asc
from buyercall.blueprints.user.models import User

activity = Blueprint('activity', __name__, template_folder='templates')
log = logging.getLogger(__name__)


@activity.before_request
@login_required
@role_required('sysadmin', 'limitsysadmin', 'partner')
def before_request():
    """ We are protecting all of our activity endpoints. """
    pass


@activity.route('/activity-log')
def activity_log():

    if current_user.role == 'partner':
        partner_ships = []
        partnership_accounts = PartnershipAccount.query.filter_by(
            partnership_id=current_user.partnership_id).all() if current_user.partnership_id else []

    else:
        partner_ships = Partnership.query.all()
        partnership_accounts = PartnershipAccount.query.all()

    # Get id and name for Partnership objects
    partnership_data = [{'id': partner_ship.id, 'name': partner_ship.name} for partner_ship in partner_ships]

    # Get id and name for PartnershipAccount objects
    partnership_account_data = [{'id': account.id, 'name': account.name} for account in partnership_accounts]

    return render_template('activity_log/index.jinja2', partner_ships=partnership_data,
                           partnership_accounts=partnership_account_data)


@login_required
@role_required('sysadmin', 'limitsysadmin', 'partner')
@activity.route('/activity-logs')
def activity_log_api():
    """Return server side data."""

    partner_account_ids = []

    if current_user.role == 'partner':
        partnership_id = current_user.partnership_id
        accounts = db.session.query(PartnershipAccount).filter_by(partnership_id=partnership_id)
        partner_account_ids = [account.id for account in accounts]

    partnership_id = request.args.get('partnerIdFilter') \
        if request.args.get('partnerIdFilter') != "all_partner_ships" else None
    partnership_account_id = request.args.get('accountIdFilter') \
        if request.args.get('accountIdFilter') != "all_partner_ship_accounts" else None

    columns = [
        ColumnDT(Partnership.name),
        ColumnDT(PartnershipAccount.name),
        ColumnDT(ActivityLogs.type),
        ColumnDT(ActivityLogs.name),
        ColumnDT(ActivityLogs.description),
        ColumnDT(ActivityLogs.ip_address),
        ColumnDT(ActivityLogs.device_browser),
        ColumnDT(ActivityLogs.device_os),
        ColumnDT(ActivityLogs.resource_address),
        ColumnDT(ActivityLogs.created_on),
        # user values
        ColumnDT(User.firstname),
        ColumnDT(User.lastname),
        ColumnDT(User.email),
        ColumnDT(User.role),
    ]

    query = db.session.query().select_from(ActivityLogs, Partnership, PartnershipAccount, User). \
        join(Partnership, ActivityLogs.partnership_id == Partnership.id, isouter=True). \
        join(PartnershipAccount, ActivityLogs.partnership_account_id == PartnershipAccount.id, isouter=True).\
        join(User, ActivityLogs.user_id == User.id, isouter=True)

    # start date filter
    start_date = request.args.get('start_date', None)
    end_date = request.args.get('end_date', None)

    # Filter partnership accounts based on multiple partnership_account_ids using the `in_` operator
    if partner_account_ids:
        query = query.filter(ActivityLogs.partnership_account_id.in_(partner_account_ids))

    if start_date and end_date:
        query = query.filter(ActivityLogs.created_on >= start_date,
                             ActivityLogs.created_on <= end_date)
    # end date filter
    if partnership_id and partnership_account_id:
        query = query.filter(and_(
            ActivityLogs.partnership_id == partnership_id,
            ActivityLogs.partnership_account_id == partnership_account_id
        ))

    elif partnership_id:
        query = query.filter(and_(
            ActivityLogs.partnership_id == partnership_id,
        ))

    elif partnership_account_id:
        query = query.filter(and_(
            ActivityLogs.partnership_account_id == partnership_account_id
        ))

    # sort query
    sort = request.args.get('sort', "DESC")
    sort_field = request.args.get('sort_field', "created_on")

    if sort_field:
        sort_order = desc if sort.upper() == 'DESC' else asc
        column = getattr(ActivityLogs, sort_field, None)
        if column is not None:
            query = query.order_by(sort_order(column))
    else:
        query = query.order_by(desc(ActivityLogs.created_on))

    row_table = DataTables(request.args, query, columns)

    result = row_table.output_result()

    field_mapping = {
        str(index): column for index, column in enumerate(['partnership_name',
                                                           'partnership_account_name', 'type',
                                                           "name", "description", "ip_address", "device_browser",
                                                           "device_os", "resource_address", "created_on",
                                                           "firstname", "lastname", "email", "role"
                                                           ])
    }
    # Update the data items with field names
    if not result.get('error'):
        result['data'] = [
            {field_mapping.get(key, key): value for key, value in item.items()}
            for item in result['data']
        ]
    return jsonify(result)


# @login_required
@role_required('sysadmin', 'limitsysadmin', 'partner')
@activity.route('/filter/activity-logs/<int:partnership_id>')
def activity_filter_api(partnership_id):
    """Return server side data."""

    accounts = db.session.query(PartnershipAccount).filter_by(partnership_id=partnership_id)
    result = [{"id": account.id, "partnership_account_name": account.name} for account in accounts]
    return jsonify({"result": result})