"""Schema for payee parameters."""

from abacus_common_logic.marshalling.base import PaginationSchema
from abacus_common_logic.marshalling.custom_fields import ma
from marshmallow import validates_schema, ValidationError
from marshmallow.validate import OneOf

from payee.constants import error
from payee.constants.constants import ACTION_STATUSES, PAYEE_TYPES
from payee.schemas.dataloader import DataloaderOutputSchema


class AbacusStateFilterSchema(ma.Schema):
    """Filter schema for a single abacus_state condition."""

    action_name = ma.String(load_default=None, required=False)
    action_status = ma.String(
        load_default=None, required=False, validate=OneOf(ACTION_STATUSES)
    )
    message = ma.String(load_default=None, required=False)

    @validates_schema
    def validate_at_least_one(self, data, **kwargs):
        if not any(
            data.get(f) is not None for f in ('action_name', 'action_status', 'message')
        ):
            raise ValidationError(
                'At least one of action_name, action_status, message must be provided'
            )


class PayeeSchema(ma.Schema):
    """Payee schema."""

    payee_id = ma.IntegerId(required=True)
    reference_payment_type_id = ma.IntegerId(required=True)
    payoneer_client_reference_id = ma.String(required=True)
    payoneer_program_id = ma.IntegerId(required=True)
    payoneer_assigned_id = ma.IntegerId()
    payee_name = ma.String()
    payee_type = ma.String(required=True, validate=OneOf(PAYEE_TYPES))
    created_by = ma.String()
    created_at = ma.DateTime()
    last_modified_by = ma.String()
    last_modified = ma.DateTime()


class PayeeCollaboratorSchema(ma.Schema):
    """Payee Collaborator schema."""

    payee_id = ma.IntegerId(required=True)
    payee_collaborator_id = ma.IntegerId(required=True)
    collaborator_id = ma.IntegerId(required=True)
    account_id = ma.IntegerId(required=True)
    created_by = ma.String()
    created_at = ma.DateTime()
    last_modified_by = ma.String()
    last_modified = ma.DateTime()


class PayeeCreateSchema(ma.Schema):
    """Payee create schema."""

    reference_payment_type_id = ma.IntegerId(required=True)
    collaborator_id = ma.IntegerId(required=True)


class PayeeDataloaderSchema(ma.Schema):
    """Payee dataloader schema."""

    collaborator_ids = ma.List(ma.IntegerId(), required=False)
    payoneer_client_reference_ids = ma.List(ma.String(), required=False)

    @validates_schema
    def validate_at_least_one(self, data, **kwargs):
        if not data.get('collaborator_ids') and not data.get(
            'payoneer_client_reference_ids'
        ):
            raise ValidationError(error.ERROR_PAYEE_DATALOADER_SCHEMA_AT_LEAST_ONE)

    @validates_schema
    def validate_exclusive(self, data, **kwargs):
        if data.get('collaborator_ids') and data.get('payoneer_client_reference_ids'):
            raise ValidationError(error.ERROR_PAYEE_DATALOADER_SCHEMA_EXCLUSIVE)


class DataloaderEntrySchema(DataloaderOutputSchema):
    data = ma.Nested(PayeeSchema, required=False)
    error = ma.String(required=False)


class PayeeDataloaderOutputSchema(ma.Schema):
    """Payee dataloader schema."""

    payees = ma.List(ma.Nested(DataloaderEntrySchema), required=True)


class PayeePaginatedFilterSchema(PaginationSchema):
    """Payee Pagination schema."""

    requires_review = ma.Boolean(allow_none=True, required=False)
    abacus_states = ma.List(
        ma.Nested(AbacusStateFilterSchema), load_default=None, required=False
    )
    account_ids = ma.List(ma.IntegerId(), load_default=None, required=False)
    payoneer_program_ids = ma.List(ma.IntegerId(), load_default=None, required=False)
    # search_term applies to payee_name and payee_id (as string)
    search_term = ma.String(load_default=None, allow_none=True, required=False)


class PayeePaginatedSchema(ma.Schema):
    """Payee Pagination schema."""

    items = ma.List(ma.Nested(PayeeSchema), required=True)
    total_count = ma.NonNegativeInteger(required=True)


class PayeeCollaboratorPaginatedSchema(ma.Schema):
    """Payee Pagination schema."""

    items = ma.List(ma.Nested(PayeeCollaboratorSchema), required=True)
    total_count = ma.NonNegativeInteger(required=True)


class PayeeCollaboratorFilterSchema(PaginationSchema):
    """payee collaborator filter schema"""

    payee_ids = ma.List(ma.IntegerId())