"""Route handlers for Vendor Relationships endpoints."""


from account.api import app, authorization_backend
from account.constants import error
from account.constants.connectors import NEO4J_DATABASE_NAME
from account.constants.constants import (
    FEATURE_USE_NEO4J_MANAGED_TX,
)
from account.logic import (
    feature,
    supplier,
    vendor,
)
from account.logic.resource_getters.account import AccountByIdResourceGetter
from account.utils.api_utils import validate_request_data
from account.validation import validation
from account.validation.schemas.vendor_restricted_features import (
    BulkAddVendorRestrictedFeaturesSchema,
    BulkRemoveVendorRestrictedFeaturesSchema,
)
from connector_neo4j import Neo4jSession
from flask import g, request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify
from pythonfeatures import pythonfeatures
from pythonfeatures.constants import split as split_constants


@app.route('/vendor/brand/<vendor_id>', methods=['GET'])
@Neo4jSession(use_v2=True, database=NEO4J_DATABASE_NAME)
def get_company_brand(vendor_id):
    """Return company brand associated with given label.

    Args:
        vendor_id (int): unique identifier for a vendor.

    Returns:
        Flask.response.
    """
    use_managed_tx = (
        pythonfeatures.get_single_feature(FEATURE_USE_NEO4J_MANAGED_TX, g.request_context).message
        == split_constants.FEATURE_ENABLED
    )
    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=401
            )
        )
    if use_managed_tx:
        return flaskify(vendor.get_vendor_company_brand_tx(vendor_id))
    return flaskify(vendor.get_vendor_company_brand(vendor_id))


@app.route('/vendor/<vendor_id>/suppliers', methods=['GET'])
def get_phys_suppliers(vendor_id):
    """Return vendor suppliers default selection.

    Args:
        vendor_id (int): unique identifier for a vendor.

    Returns:
        Flask.response.
    """
    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=401
            )
        )
    return flaskify(supplier.get_suppliers(vendor_id))


@app.route('/vendor/<int:vendor_id>/suppliers', methods=['PUT'])
def set_phys_suppliers(vendor_id):
    """Set suppliers default selection.

    Args:
        vendor_id (int): unique identifier for a vendor.

    Returns:
        Flask.response.
    """
    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=401
            )
        )
    data = request.get_json(silent=True, force=True) or {}
    store_ids = data.get('store_ids')
    if store_ids is None:
        store_ids = []
    return flaskify(supplier.set_suppliers(vendor_id, store_ids))


@app.route('/vendor/<int:vendor_id>/features', methods=['GET'])
def get_enabled_features_for_vendor(vendor_id):
    """Get a list of enabled feature controls for a vendor.

    Args:
        vendor_id (int): unique identifier for a vendor.

    Returns:
        Flask.response: containing the list of enabled feature controls.
    """
    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=401
            )
        )
    validation = flask_request.verify_grass_access(request, vendor=vendor_id)
    if not validation:
        return flaskify(response=validation)
    return flaskify(feature.get_enabled_features_for_vendor(vendor_id))


@app.route('/vendor/<int:vendor_id>/restricted_features/add', methods=['POST'])
@validate_request_data(BulkAddVendorRestrictedFeaturesSchema())
def bulk_add_restricted_features_for_vendor(vendor_id):
    """Bulk add restricted features for a vendor.

    POST Body:
        feature_ids (list[int]): list of feature IDs.
    Returns:
        Flask.response.
    """
    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=401
            )
        )
    data = request.get_json()
    return flaskify(feature.bulk_add_restricted_features_for_vendor(vendor_id, data['feature_ids']))


@app.route('/vendor/<int:vendor_id>/restricted_features/remove', methods=['POST'])
@validate_request_data(BulkRemoveVendorRestrictedFeaturesSchema())
def bulk_remove_restricted_features_for_vendor(vendor_id):
    """Bulk remove restricted features for a vendor.

    POST Body:
        feature_ids (list[int]): list of feature IDs.
    Returns:
        Flask.response.
    """
    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=401
            )
        )
    data = request.get_json()
    return flaskify(
        feature.bulk_remove_restricted_features_for_vendor(vendor_id, data['feature_ids'])
    )


@app.route('/vendor/<int:vendor_id>/assigned-to', methods=['GET'])
def get_vendor_assigned_to(vendor_id):
    """Get a single vendor's assigned_to property."""
    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=401
            )
        )
    result = vendor.get_vendor_assigned_to(vendor_id)
    return flaskify(result)


@app.route('/vendor/<int:vendor_id>/secondary-internal-contact', methods=['GET'])
def get_vendor_secondary_internal_contact(vendor_id):
    """Get a single vendor's secondary internal contact."""
    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=401
            )
        )
    result = vendor.get_vendor_secondary_internal_contact(vendor_id)
    return flaskify(result)


@app.route('/vendor/<int:vendor_id>/document', methods=['GET'])
@validation.reject_grass_headers
def get_vendor_document(vendor_id):
    """Get single vendor document for cloudsearch corpus.

    Should have no grass headers since this is intended for internal use

    Args:
        vendor_id (int): vendor id

    Returns:
        Response: Flask response
    """
    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=401
            )
        )
    return flaskify(vendor.get_vendor_document(vendor_id))


@app.route('/vendor/<int:vendor_id>/assigned-reviewer', methods=['GET'])
def get_vendor_assigned_reviewer(vendor_id):
    """Get a single vendor's assigned_reviewer property."""
    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=401
            )
        )
    result = vendor.get_vendor_assigned_reviewer(vendor_id)
    return flaskify(result)


@app.route('/vendor/<int:vendor_id>/service-details', methods=['GET'])
@Neo4jSession(use_v2=True, database=NEO4J_DATABASE_NAME)
def get_vendor_service_details(vendor_id):
    """Get vendor service details."""
    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=401
            )
        )
    validation = flask_request.verify_grass_access(request, required=False, vendor=vendor_id)
    if not validation:
        return flaskify(validation)
    vendor_service_details = vendor.get_vendor_service_details(vendor_id)
    return flaskify(vendor_service_details)


@app.route('/vendor/<vendor_id>/master-contact', methods=['GET'])
@Neo4jSession(use_v2=True, database=NEO4J_DATABASE_NAME)
def get_master_contact(vendor_id):
    """Get master contact for vendor."""
    if not authorization_backend.is_authorized(
        action='view_account_info',
        resource_id=vendor_id,
        resource_type='account',
        resource_getter=AccountByIdResourceGetter(vendor_id),
    ):
        return flaskify(
            response.create_error_response(
                code=error.ERROR_CODE_AUTHORIZATION, message='Unauthorized', status=403
            )
        )
    return flaskify(vendor.get_master_contact(vendor_id))