"""Pydantic Model For Account Statement Period."""

import datetime

from pydantic import BaseModel
from pydantic import ConfigDict
from pydantic import field_validator

from moneyhub.constants.constants import StatementPeriodStatus
from moneyhub.schemas.pagination import PaginationSchema
from moneyhub.utils.schema import convert_to_date


class AccountStatementPeriodDetailSchema(BaseModel):
    """Account statement period detail response."""

    account_id: int
    contract_id: int | None = None
    statement_period_id: int
    currency_code: str
    total_gross_revenue_amount: float | None = None
    total_net_revenue_amount: float | None = None
    distribution_fee: float | None = None
    mechanical_deduction_total: float | None = None
    mechanical_deduction_admin_fee_total: float | None = None

    model_config = ConfigDict(from_attributes=True)


class PaginatedAccountStatementPeriodDetailSchema(BaseModel):
    """Account statement period detail paginated response."""

    items: list[AccountStatementPeriodDetailSchema | None]
    pagination: PaginationSchema


class AccountStatementPeriodPaymentDetailSchema(BaseModel):
    """Account statement period payments detail response."""

    ledger_account_id: int | str
    statement_period_id: int
    account_id: int
    action_status: str | None = None
    contract_id: int
    currency_code: str
    currency_amount: float
    created_at: datetime.date | None = None
    event_name: str
    withholding_tax_ledger_account_id: int | None = None
    withholding_tax_currency_code: str | None = None
    withholding_tax_currency_amount: float | None = None
    withholding_tax_created_at: datetime.date | None = None

    model_config = ConfigDict(from_attributes=True)

    @field_validator('created_at', 'withholding_tax_created_at', mode='before')
    @classmethod
    def validate_date(cls, value: datetime.datetime | datetime.date | None) -> datetime.date | None:
        """Ensure that the value is a date, converting if need be.

        Args:
            value (datetime | date | None): Value to validate
        Returns:
            date | None: Validated date
        """
        return convert_to_date(value)


class AccountPaymentDetailStatusSchema(BaseModel):
    """Account statement period payment detail response."""

    worksheet_account_contract_closing_balance_id: int
    contract_id: int | None = None
    closing_balance_statement_period: int
    closing_balance_amount: float
    payable_amount_pre_tax: float
    tax_withholding_amount: float | None = None
    vat_amount: float | None = None
    payable_amount_post_tax: float
    currency_code: str
    batch_status: str
    individual_payment_status: str
    payment_statement_period_id: int
    created_at: datetime.date
    last_modified: datetime.date

    model_config = ConfigDict(from_attributes=True)

    @field_validator('created_at', 'last_modified', mode='before')
    @classmethod
    def validate_date(cls, value: datetime.datetime | datetime.date | None) -> datetime.date | None:
        """Ensure that the value is a date, converting if need be.

        Args:
            value (datetime | date | None): Value to validate
        Returns:
            date | None: Validated date
        """
        return convert_to_date(value)


class AccountStatementPeriodVatDetailSchema(BaseModel):
    """Account statement period vat detail response."""

    statement_period_id: int
    account_id: int
    payee_currency_code: str
    base_amount_payee_currency: float | None = None
    vat_amount_payee_currency: float | None = None
    net_amount_payee_currency: float | None = None
    # Deprecated fields
    currency_code: str
    gross_revenue: float | None = None
    net_revenue: float | None = None
    distribution_fee: float | None = None
    gross_vat_rate: float | None = None
    distribution_vat_rate: float | None = None
    gross_vat: float | None = None
    distribution_vat: float | None = None
    adjusted_net_revenue: float | None = None

    model_config = ConfigDict(from_attributes=True)


class AccountStatementPeriodBalanceSchema(BaseModel):
    """Account statement period balance detail response."""

    closing_balance: float
    currency_code: str | None = None
    opening_balance: float
    ledger_amount: float | None = None
    payable_balance: float | None = None
    statement_period_id: int

    model_config = ConfigDict(from_attributes=True)


class AccountStatementPeriodSchema(BaseModel):
    """Account statement period response."""

    statement_period_id: int
    statement_period_name: str
    statement_period_status: StatementPeriodStatus
    currency_code: str | None = None
    statement_year: int | None = None
    statement_month: int | None = None

    model_config = ConfigDict(from_attributes=True)


class AccountActivitySchema(BaseModel):
    """Account activity response."""

    adjustments: bool
    advances: bool
    expenses: bool
    mechanicals: bool
    physical_reserves: bool
    publishing_revenue: bool
    revenue: bool
    taxes: bool

    model_config = ConfigDict(from_attributes=True)


class AccountActivityPeriodsDataloaderSchema(BaseModel):
    """Account activity periods dataloader request body."""

    activity_period_ids: list[int]


class AccountActivityPeriodSchema(BaseModel):
    """Account activity period response."""

    activity_period_id: int
    activity_month_name: str

    model_config = ConfigDict(from_attributes=True)


class AccountContractsDataloaderSchema(BaseModel):
    """Account contracts dataloader request body."""

    contract_ids: list[int]


class AccountContractsSchema(BaseModel):
    """Account contracts schema."""

    account_id: int
    contract_id: int
    contract_name: str


class AccountImprintSchema(BaseModel):
    """Imprint schema for account filters."""

    imprintid: int
    imprint: str
    account_id: int


class AccountImprintsDataloaderSchema(BaseModel):
    """Account imprints dataloader request body."""

    imprint_ids: list[int]


class AccountArtistSchema(BaseModel):
    """Artist schema for account filters."""

    artist_id: int
    artist_name: str


class AccountProductSchema(BaseModel):
    """Product schema for account filters."""

    product_id: int
    product_name: str
    display_upc: str


class AccountTrackSchema(BaseModel):
    """Track schema for account filters."""

    track_unique_id: int
    track_name: str
    isrc: str | None = None


class AccountProjectSchema(BaseModel):
    """Project schema for account filters."""

    project_id: int


class AccountRecordingSchema(BaseModel):
    """Recording schema for account filters."""

    recording_id: str
    recording_title: str
    isrc: str | None = None

    model_config = ConfigDict(from_attributes=True)

    @field_validator('recording_id', mode='before')
    @classmethod
    def validate_recording_id(cls, value) -> str:
        """Ensure that the recording_id is a string, converting if need be."""
        return str(value)