"""Performer handlers."""
from flask import g
from flask import request
from oto.adaptors.flask import flaskify
from owsrequest import flask_request

from owsresponse import response

from backend.api import app
from backend.constants import error
from backend.logic import performer as performer_logic
from backend.schemas.performer import TrackPeformersUpdateSchema
from backend.schemas.performer import TuidListSchema
from backend.utils import handlers as handlers_util


@app.route('/performer/roles', methods=['GET'])
def get_performer_roles():
    """Get performer roles.

    Returns:
        flask.Response: list of performer roles
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        jwt_identity_id = g.request_context.jwt_identity_id
        if not jwt_identity_id:
            return flaskify(response.create_error_response(
                code=error.ERROR_CODE_NOT_FOUND,
                message='No valid identity found in request context.',
                status=401,
            ))
        if not handlers_util.is_jwt_identity_authorized(jwt_identity_id):
            return flaskify(response.create_error_response(
                code=error.ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=403,
            ))
    result = performer_logic.get_performer_roles()
    return flaskify(result)


@app.route('/public/performer/roles', methods=['GET'])
def get_public_performer_roles():
    """Get performer roles.

    Returns:
        flask.Response: list of performer roles
    """
    headers = {'Cache-Control': 'max-age=3600'}
    result = performer_logic.get_performer_roles()
    return flaskify(result, headers)


@app.route('/track/<int:tuid>/performers', methods=['GET'])
@handlers_util.get_account_from_grass
def get_performers_for_track(tuid, account):
    """Get performers data for track with tuid.

    Args:
        tuid (int): The track primary key.
        account (namedtuple): Account data from GRASS headers.

    Returns:
        flask.Response: dict with tuid and performer data
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(response.create_error_response(
            code=error.ERROR_CODE_AUTHORIZATION,
            message='Unauthorized',
            status=403,
        ))
    result = performer_logic.get_for_track(
        tuid=tuid, account_type=account.type, account_id=account.id)
    return flaskify(result)


@app.route('/tracks/performers', methods=['POST'])
def get_performers_for_tracks():
    """Get performers data for track ids passed in request body.

    Returns:
        flask.Response: dict with tuid and performer data.
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(response.create_error_response(
            code=error.ERROR_CODE_AUTHORIZATION,
            message='Unauthorized',
            status=403,
        ))
    json_data = handlers_util.parse_request_json(
        schema=TuidListSchema)
    tuids = list(map(int, json_data['tuids'].split(',')))
    return flaskify(performer_logic.get_for_tracks(tuids))


@app.route('/product/<int:product_id>/tracks/performers', methods=['GET'])
@handlers_util.get_account_from_grass
def get_performers_for_tracks_in_product(product_id, account):
    """Get performers data for all tracks in given product.

    Args:
        product_id (int): The product primary key.
        account (namedtuple): Account data from GRASS headers.

    Returns:
        flask.Response: dict with tuids and performer data
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        jwt_identity_id = g.request_context.jwt_identity_id
        if not jwt_identity_id:
            return flaskify(response.create_error_response(
                code=error.ERROR_CODE_NOT_FOUND,
                message='No valid identity found in request context.',
                status=401,
            ))
        if jwt_identity_id and not handlers_util.is_jwt_identity_authorized(jwt_identity_id):
            return flaskify(response.create_error_response(
                code=error.ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=403,
            ))
    result = performer_logic.get_all_for_product(
        product_id=product_id,
        account_type=account.type, account_id=account.id)
    return flaskify(result)


@app.route(
    '/product/<int:product_id>/tracks/performers/<performer_type>',
    methods=['PATCH'])
@handlers_util.get_account_from_grass
def update_by_performer_type_for_product(product_id, performer_type, account):
    """Update performers for given tuid.

    Args:
        product_id (int): The product primary key.
        performer_type (str): Performer type to update
        account (namedtuple): Account data from GRASS headers.

    Returns:
        flask.Response: dict with tuid and created performer roles
    """
    performers = request.get_json()['performers']
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(response.create_error_response(
            code=error.ERROR_CODE_AUTHORIZATION,
            message='Unauthorized',
            status=403,
        ))
    result = performer_logic.update_by_performer_type_for_product(
        product_id=product_id,
        performer_type=performer_type, performers=performers,
        account_type=account.type, account_id=account.id)

    return flaskify(result)


@app.route('/track/<int:tuid>/performers', methods=['PUT'])
@handlers_util.get_account_from_grass
def update_performers(tuid, account):
    """Update performers for given tuid.

    Args:
        tuid (int): The track primary key.
        account (namedtuple): Account data from GRASS headers.

    Returns:
        flask.Response: dict with tuid and created performer roles
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(response.create_error_response(
            code=error.ERROR_CODE_AUTHORIZATION,
            message='Unauthorized',
            status=403,
        ))
    json_data = handlers_util.parse_request_json(
        schema=TrackPeformersUpdateSchema)
    result = performer_logic.update_for_track(
        tuid=tuid, performers=json_data['performers'],
        account_type=account.type, account_id=account.id)

    return flaskify(result)


@app.route(
    '/product/<int:product_id>/tracks/validate/performers', methods=['GET'])
@handlers_util.get_account_from_grass
def validate_tracks_performers_for_product(product_id, account):
    """Validate the performers for all tracks of a product.

    Returns the total number of tracks and the number of valid ones.
    The account info can be passed via the headers or the query parameters.

    Args:
        product_id (int): The product primary key.
        account (namedtuple): Account data from GRASS headers.

    Returns:
        flask.response: on successful, 200 status with JSON body

    Example:
        {
            "total_tracks": 10,
            "valid_tracks": 8,
            "errors": {...}
        }
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(response.create_error_response(
            code=error.ERROR_CODE_AUTHORIZATION,
            message='Unauthorized',
            status=403,
        ))
    result = performer_logic.validate_for_product(
        product_id=product_id,
        account_type=account.type, account_id=account.id)

    return flaskify(result)