"""Logic for Payoneer Programs."""

from owsresponse import response

from abacus_account import models
from abacus_account.constants import error
from abacus_account.constants.constants import PAYONEER_PROGRAM_MOVE_TYPE_MAP
from abacus_account.schemas.reference_payoneer_program import \
    ReferencePayoneerProgramSchema
from abacus_account.utils.format_error import validation_error

reference_payoneer_program_schema = ReferencePayoneerProgramSchema()


def get_payoneer_programs():
    """Get full list of reference_payoneer_program records."""
    query = models.ReferencePayoneerProgram.query
    payoneer_programs = query.all()
    count = query.count()
    payoneer_program_list = reference_payoneer_program_schema.dump(
        payoneer_programs, many=True)
    return response.Response({'items': payoneer_program_list, 'total_count': count})


def get_payoneer_program(
    currency_code: str,
    agreement_type_id: int,
    payment_entity_id: int,
    reference_payment_type_id: int | None = None
):
    """
    Get reference_payoneer_program.

    Params:
     - currency_code,
     - agreement_type_id
     - payment_entity_id
     - reference_payment_type_id (optional)
    """
    try:
        payoneer_program = \
            models.ReferencePayoneerProgram.get_payoneer_program_by_params(
                currency_code=currency_code,
                agreement_type_id=agreement_type_id,
                payment_entity_id=payment_entity_id,
                reference_payment_type_id=reference_payment_type_id
            )

        if not payoneer_program:
            return response.create_not_found_response(
                message=error.ERROR_CODE_NOT_FOUND
            )

        message = reference_payoneer_program_schema.dump(payoneer_program)

    except Exception as e:
        return validation_error(str(e))

    return response.Response(message=message, status=200)


def get_payoneer_program_move_type(from_program_id: int, to_program_id: int):
    """Resolve move type for a payoneer program transition."""
    if from_program_id == to_program_id:
        return validation_error(
            error.ERROR_SAME_PROGRAM_MOVE_TRANSITION.format(
                program_id=from_program_id
            )
        )

    from_program = models.ReferencePayoneerProgram.query.get(from_program_id)
    if not from_program:
        return response.create_not_found_response(
            message=f'Payoneer program {from_program_id} not found'
        )

    to_program = models.ReferencePayoneerProgram.query.get(to_program_id)
    if not to_program:
        return response.create_not_found_response(
            message=f'Payoneer program {to_program_id} not found'
        )

    from_type = from_program.reference_payment_type_id
    to_type = to_program.reference_payment_type_id

    move_type = PAYONEER_PROGRAM_MOVE_TYPE_MAP.get((from_type, to_type))
    if not move_type:
        return validation_error(
            error.ERROR_UNSUPPORTED_PROGRAM_MOVE_TRANSITION.format(
                from_type=from_type, to_type=to_type
            )
        )

    return response.Response(message={'move_type': move_type}, status=200)