"""Handlers for terms and conditions."""

from flask import jsonify
from flask.typing import ResponseReturnValue
from flask_pydantic import validate

from collaborator.api import app
from collaborator.constants import error
from collaborator.logic import terms_and_conditions
from collaborator.models.ows import ows_account, ows_users
from collaborator.schemas import BaseSchema
from collaborator.utils import handlers as utils
from collaborator.utils.error import OwsError
from collaborator.utils.helpers import check_vendors_authorization
from collaborator.utils.typing import ACCOUNT_TYPE_VENDOR, Account


class GetTermsAndConditionsQuery(BaseSchema):
    """Query parameters for GET /terms-and-conditions."""

    vendor_id: int


@app.route("/terms-and-conditions", methods=["GET"])
@validate()
@utils.fetch_authorized_resources
def get_terms_and_conditions(
    authorized_resources, user, query: GetTermsAndConditionsQuery
) -> ResponseReturnValue:
    """Fetch terms and conditions info.

    Args:
        params (dict): dictionary with the body params of the request
    Returns: response with terms and conditions info
    """
    if not ows_account.has_direct_payments(str(query.vendor_id)):
        return jsonify(None)

    check_vendors_authorization(authorized_resources, [query.vendor_id])

    account = Account(type=ACCOUNT_TYPE_VENDOR, id=str(query.vendor_id))
    return terms_and_conditions.get_terms_and_conditions(account)


class AgreeTermsAndConditionsBody(BaseSchema):
    """Request body for POST /terms-and-conditions/agreement."""

    vendor_id: int
    terms_and_conditions_id: int


@app.route("/terms-and-conditions/agreement", methods=["POST"])
@validate()
@utils.fetch_authorized_resources
def agree_terms_and_conditions(
    authorized_resources, user, body: AgreeTermsAndConditionsBody
) -> ResponseReturnValue:
    """Agree terms and conditions.

    Args:
        params (dict): dictionary with the body params of the request
    Returns: response with terms and conditions agreement info
    """
    vendor_id = body.vendor_id
    check_vendors_authorization(authorized_resources, [vendor_id])

    identity_metadata = ows_users.get_identity_metadata(user)
    has_direct_payments = ows_account.has_direct_payments(str(vendor_id))

    if not has_direct_payments:
        raise OwsError.forbidden(
            code=error.ERROR_CODE_AUTHORIZATION,
            message=error.ERROR_MESSAGE_FORBIDDEN_USER,
        )

    return terms_and_conditions.agree_terms_and_conditions(
        identity_metadata, vendor_id, body.terms_and_conditions_id
    )