"""Factories for testing models."""

from datetime import datetime
from decimal import Decimal
from types import SimpleNamespace

import factory

from moneyhub.constants import constants
from moneyhub.constants.constants import AdvanceStatus
from moneyhub.constants.constants import ContractType
from moneyhub.constants.constants import Milestone
from moneyhub.models.abacus_event import AbacusEvent
from moneyhub.models.account_contract import AccountContract
from moneyhub.models.account_payment_term import AccountPaymentTerm
from moneyhub.models.adjustments_by_type import AdjustmentsByType
from moneyhub.models.combined_adjustments import CombinedAdjustments
from moneyhub.models.combined_advances import CombinedAdvances
from moneyhub.models.combined_payments import CombinedPayments
from moneyhub.models.contract import Contract
from moneyhub.models.contract_advance import ContractAdvance
from moneyhub.models.dim_subaccount import DimSubaccount
from moneyhub.models.expenses import Expenses
from moneyhub.models.expenses_by_artist import ExpensesByArtist
from moneyhub.models.expenses_by_imprint import ExpensesByImprint
from moneyhub.models.expenses_by_subaccount import ExpensesBySubaccount
from moneyhub.models.ledger_account_contract import LedgerAccountContract
from moneyhub.models.ledger_accounting_run_vat import LedgerAccountingRunVat
from moneyhub.models.ledger_correction import LedgerCorrection
from moneyhub.models.ledger_reserve_release import LedgerReserveRelease
from moneyhub.models.ledger_reserve_release_schedule import LedgerReserveReleaseSchedule
from moneyhub.models.ledger_reserve_taken import LedgerReserveTaken
from moneyhub.models.ledger_vat_summary import LedgerVatSummary
from moneyhub.models.reference_adjustment_type import ReferenceAdjustmentType
from moneyhub.models.reference_signing_entity import ReferenceSigningEntity
from moneyhub.models.report_custom import ReportCustom
from moneyhub.models.revenue_by_activity_month import RevenueByActivityMonth
from moneyhub.models.revenue_by_artist import RevenueByArtist
from moneyhub.models.revenue_by_country import RevenueByCountry
from moneyhub.models.revenue_by_imprint import RevenueByImprint
from moneyhub.models.revenue_by_product_distro import RevenueByProductDistro
from moneyhub.models.revenue_by_project import RevenueByProject
from moneyhub.models.revenue_by_recording_distro import RevenueByRecordingDistro
from moneyhub.models.revenue_by_recording_nr import RevenueByRecordingNr
from moneyhub.models.revenue_by_statement_period import RevenueByStatementPeriod
from moneyhub.models.revenue_by_store import RevenueByStore
from moneyhub.models.revenue_by_subaccount import RevenueBySubaccount
from moneyhub.models.revenue_by_track import RevenueByTrack
from moneyhub.models.revenue_by_transaction_type import RevenueByTransactionType
from moneyhub.models.revenue_distro import RevenueDistro
from moneyhub.models.revenue_nr import RevenueNr
from moneyhub.models.statement_attachment import StatementAttachment
from moneyhub.models.statement_period import StatementPeriod
from moneyhub.models.statement_period_payment_entity import StatementPeriodPaymentEntity
from moneyhub.models.vendor import Vendor
from moneyhub.models.worksheet_adjustment import WorksheetAdjustment
from moneyhub.models.worksheet_adjustment_detail import WorksheetAdjustmentDetail
from tests.utils.base_factories import BaseModelFactory


class AbacusEventFactory(BaseModelFactory):
    """Factory to create AbacusEvent models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = AbacusEvent

    abacus_event_id = 1
    statement_period_id = 123
    event_name = 'test'
    target_type = 'statement_period'
    target_id = 123
    event_date = datetime.now(constants.SYSTEM_TIMEZONE)
    previous_abacus_event_id = None
    rolled_back_at = None
    created_by = 'me'


class AccountImprintFactory(factory.Factory):
    """Factory to create account imprint objects."""

    class Meta:
        """Meta definition for the factory."""

        model = SimpleNamespace

    account_id = 24601
    imprint = 'Testing'
    imprintid = 1


class ContractAdvanceFactory(BaseModelFactory):
    """Factory to create ContractAdvance models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ContractAdvance

    contract_id = 1
    advance_description = 'An advance'
    amount = 100
    currency_code = 'NOK'
    milestone = Milestone.CONTRACT_EXECUTION
    milestone_description = 'other'
    milestone_date = None
    advance_status = AdvanceStatus.PAID
    note = None
    created_by = 'me'
    created_at = datetime.now(constants.SYSTEM_TIMEZONE)
    last_modified_by = 'me'
    last_modified = datetime.now(constants.SYSTEM_TIMEZONE)
    deleted_at = None
    deleted_by = None


class ContractFactory(BaseModelFactory):
    """Factory to create Contract models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = Contract

    contract_id = 1
    contract_name = 'Fake Contract'
    contract_type = ContractType.NEIGHBOURING_RIGHTS
    term_start = datetime.now(constants.SYSTEM_TIMEZONE)
    term_end = datetime.now(constants.SYSTEM_TIMEZONE)


class ExpensesFactory(BaseModelFactory):
    """Factory to create Expenses models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = Expenses

    account_id = 123
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'USD'
    apply_to_statement_period_id = 123
    contract_id = 10001
    reference_adjustment_type_id = 1
    reference_adjustment_type_name = 'Freight'
    upc = '101010'


class ExpensesByImprintFactory(BaseModelFactory):
    """Factory to create Expenses By Imprint models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ExpensesByImprint

    account_id = 123
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'USD'
    imprint = 'TEST'
    imprint_id = 123456


class ExpensesBySubaccountFactory(BaseModelFactory):
    """Factory to create Expenses By subaccount models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ExpensesBySubaccount

    account_id = 123
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'USD'
    subaccount_id = 123456


class ExpensesByArtistFactory(BaseModelFactory):
    """Factory to create Expenses By Artist models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ExpensesByArtist

    account_id = 123
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'USD'
    artist_name = 'Artist'
    artist_id = 123456


class LedgerVatSummaryFactory(BaseModelFactory):
    """Factory to create LedgerVatSummary models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerVatSummary

    ledger_vat_summary_id = 1
    statement_period_id = 1
    activity_statement_period_id = 1
    abacus_event_id = 1
    account_id = 1
    contract_id = 10001
    vat_category = 'gross_revenue'
    payee_currency_code = 'USD'
    vat_currency_code = 'USD'
    base_amount_payee_currency = '2020.20'
    vat_rate = '20.00'
    vat_amount_payee_currency = '2020.20'
    vat_amount_vat_currency = '2020.20'
    net_amount_payee_currency = '2020.20'
    abacus_exempt_reason = None
    is_reporting_only = False
    created_by = 'me'
    created_at = datetime.now(constants.SYSTEM_TIMEZONE)
    last_modified_by = 'me'
    last_modified = datetime.now(constants.SYSTEM_TIMEZONE)


class LedgerAccountingRunVatFactory(BaseModelFactory):
    """Factory to create LedgerAccountingRunVat models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerAccountingRunVat

    ledger_accounting_run_vat_id = 1
    accounting_run_id = 1
    abacus_event_id = 1
    contract_id = 10001
    currency_code = 'NOK'
    country_of_tax_residence = 'NOR'
    gross_revenue = None
    net_revenue = None
    distribution_fee = None
    gross_vat_rate = None
    distribution_vat_rate = None
    gross_vat = None
    distribution_vat = None
    adjusted_net_revenue = None
    exempt_reason = None
    created_by = 'me'
    created_at = datetime.now(constants.SYSTEM_TIMEZONE)
    last_modified_by = 'me'
    last_modified = datetime.now(constants.SYSTEM_TIMEZONE)


class ReferenceSigningEntityFactory(BaseModelFactory):
    """Factory to create Reference Signing models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ReferenceSigningEntity

    reference_signing_entity_id = 1
    reference_payment_entity_id = 1
    reference_sap_profit_center_id = 1
    company_code = '4914'
    tax_entity_company_code = '4914',
    legal_name = 'AWAL Digital Limited'
    vat_number = 'GB 423 4787 86'
    company_registration_number = '04430703'
    address = '2 Canal Reach, London, N1C 4DB'


class ReportCustomFactory(BaseModelFactory):
    """Factory to create Report Custom models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ReportCustom

    report_custom_id = 1
    contract_id = 11
    account_id = 24601
    subaccount_id = None
    statement_period_ids = '1,2,3'
    revenue_type = constants.RevenueType.DISTRIBUTION
    revenue_display_type = constants.RevenueDisplayType.NET
    report_custom_status = \
        constants.ReportCustomStatus.IN_PROGRESS
    dimension_column = \
        constants.ReportCustomColumnDimension.TERRITORY
    dimension_row = \
        constants.ReportCustomRowDimension.PRODUCT
    filters = None
    number_format = constants.NumberFormat.EU
    file_type = constants.StatementAttachmentFileType.CSV
    created_at = datetime.now(constants.SYSTEM_TIMEZONE)
    created_by = 'me'


class StatementAttachmentFactory(BaseModelFactory):
    """Factory to create Statement Attachment models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = StatementAttachment

    account_id = 1
    contract_id = 1
    subaccount_id = None
    statement_period_id = 1
    statement_period_ids = None
    statement_attachment_status = \
        constants.StatementAttachmentStatus.IN_PROGRESS
    statement_attachment_type = \
        constants.StatementAttachmentType.DISTRIBUTION_FEE_INVOICE
    failure_reason = None
    invoice_number = '1234'
    file_location = None
    file_type = constants.StatementAttachmentFileType.CSV
    number_format = constants.NumberFormat.US
    created_at = datetime.now(constants.SYSTEM_TIMEZONE)
    created_by = 'me'
    filters = None


class StatementPeriodFactory(BaseModelFactory):
    """Factory to create Statement Period models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = StatementPeriod

    statement_period_id = 1
    statement_period_name = 'Test'
    statement_period_status = \
        constants.StatementPeriodStatus.CLOSED


class StatementPeriodPaymentEntityFactory(BaseModelFactory):
    """Factory to create Statement Period Payment Entity models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = StatementPeriodPaymentEntity

    statement_period_payment_entity_id = 1
    statement_period_id = 1
    is_visible_to_customer = 0
    reference_payment_entity_id = 1


class ReferenceAdjustmentTypeFactory(BaseModelFactory):
    """Factory to create Reference Adjustment Type models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = ReferenceAdjustmentType

    reference_adjustment_type_id = 1
    type_name = 'Label Earnings'
    oa_category_name = 'Label Earnings'


class LedgerReserveReleaseFactory(BaseModelFactory):
    """Factory to create Ledger Reserve Release models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerReserveRelease

    ledger_reserve_release_id = 1
    abacus_event_id = 1
    statement_period_id = 1
    ledger_reserve_release_schedule_id = 1
    installment_amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))


class LedgerReserveReleaseScheduleFactory(BaseModelFactory):
    """Factory to create Ledger Reserve Release Schedule models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerReserveReleaseSchedule

    ledger_reserve_release_schedule_id = 1
    abacus_event_id = 1
    taken_statement_period_id = 1
    release_statement_period_id = 1
    ledger_reserve_taken_id = 1
    currency_code = 'NOK'
    installment_amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    outstanding_amount_after_installment = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))


class LedgerCorrectionFactory(BaseModelFactory):
    """Factory to create a Ledger Correction models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerCorrection

    ledger_correction_id = 1
    account_id = 1
    contract_id = 1
    currency_code = 'GBP'
    statement_period_id = 1
    net_revenue = Decimal(100)
    gross_revenue = Decimal(100)
    distribution_fee = Decimal(100)


class LedgerReserveTakenFactory(BaseModelFactory):
    """Factory to create Ledger Reserve Taken models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerReserveTaken

    ledger_reserve_taken_id = 1
    abacus_event_id = 1
    contract_reserve_id = 1
    accounting_run_id = 1
    statement_period_id = 1
    currency_code = 'USD'
    gross_sales = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    gross_returns = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    net_revenue = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    reserve_amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    net_revenue_after_reserve = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))


class AccountContractFactory(BaseModelFactory):
    """Factory to create Account Contract models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = AccountContract

    account_contract_id = 1
    account_id = 1
    contract_id = 1


class LedgerAccountContractFactory(BaseModelFactory):
    """Factory to create Ledger Account Contract models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = LedgerAccountContract

    ledger_account_contract_id = 1
    abacus_event_id = 1
    account_id = 1
    contract_id = 1
    currency_code = 'GBP'
    currency_amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    previous_balance = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    current_balance = 0
    note = None


class LedgerAccountContractVatSummaryFactory(factory.Factory):
    """Factory to create ledger account contract vat summary models."""

    class Meta:
        """Meta definition for the factory."""

        model = SimpleNamespace

    account_id = 24601
    currency_amount = Decimal('100')
    currency_code = 'NOK'
    statement_period_id = 123


class AdjustmentsByTypeFactory(BaseModelFactory):
    """Factory class for AdjustmentsByType."""

    class Meta:
        """Meta definition for the factory."""

        model = AdjustmentsByType

    account_id = 1
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'NOK'
    contract_id = 10001
    statement_period_id = 123
    reference_adjustment_type_id = 9
    reference_adjustment_type_name = 'VAT Tax'


class CombinedAdjustmentsFactory(BaseModelFactory):
    """Factory class for Combined Adjustments."""

    class Meta:
        """Meta definition for the factory."""

        model = CombinedAdjustments

    account_id = 1
    activity_statement_period_id = 1
    adjustment_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_payee_currency_code = 'USD'
    apply_to_statement_period_id = 2
    contract_id = 1
    note = 'Note about adjustment'
    reference_adjustment_type_id = 1
    reference_adjustment_type_name = 'Digital Sales'
    worksheet_adjustment_id = 11
    unique_identifier = '1-1-1'


class CombinedAdvancesFactory(BaseModelFactory):
    """Factory class for combined advances."""

    class Meta:
        """Meta definition for the factory."""

        model = CombinedAdvances

    account_id = 1
    contract_id = 1
    statement_period_id = 1
    advance_amount = 100.0
    advance_currency_code = 'USD'
    advance_amount_payee_currency = 100.0
    advance_payee_currency_code = 'USD'
    advance_description = 'Something'
    unique_key = '1'


class AccountPaymentTermFactory(BaseModelFactory):
    """Factory to create Account Payment Term models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = AccountPaymentTerm

    account_payment_term_id = 1
    account_id = 1
    currency_code = 'GBP'
    payment_minimum = None
    payment_entity_id = 1
    agreement_type_id = None
    payment_schedule = constants.PaymentSchedule._30_DAYS_AFTER_HALF_YEAR_END


class RevenueByProductDistroFactory(BaseModelFactory):
    """Factory to create Revenue By Product Distro models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByProductDistro

    product_id = 1234
    product_name = 'Best Name'
    display_upc = '1111111111111'
    artist_name = 'Best Artist'
    release_date = datetime(2010, 9, 8, 7, 6, 5)
    account_id = 24601
    account_payee_currency = 'JPY'
    mechanical_deduction_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    publisher_admin_fee_payee_currency = factory.Sequence(lambda n: '%.2f' % (8 * (n + 1)))
    net_share_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))
    project_name = 'Project Alpha'


class RevenueByTrackFactory(BaseModelFactory):
    """Factory to create Revenue By Track models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByTrack

    track_unique_id = 12341234
    track_name = 'Best Name'
    isrc = 'IIIII1234187'
    account_id = 24601
    account_payee_currency = 'JPY'
    mechanical_deduction_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    publisher_admin_fee_payee_currency = factory.Sequence(lambda n: '%.2f' % (8 * (n + 1)))
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))
    project_name = 'Project Alpha'


class RevenueByArtistFactory(BaseModelFactory):
    """Factory to create Revenue By Artist models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByArtist

    artist_id = 12345
    artist_name = 'The Artist Formerly Known As Test Artist'
    account_id = 24601
    account_payee_currency = 'JPY'
    subaccount_id = None
    mechanical_deduction_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    publisher_admin_fee_payee_currency = factory.Sequence(lambda n: '%.2f' % (8 * (n + 1)))
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByRecordingBaseFactory(BaseModelFactory):
    """Factory to create Revenue By Recording NR models for testing."""

    recording_id = '1234'
    recording_title = 'Title'
    artist = 'Artist'
    version = 'Acoustic'
    isrc = 'JPYE70900611'
    account_id = 24601
    account_payee_currency = 'JPY'
    net_share_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByRecordingNrFactory(RevenueByRecordingBaseFactory):
    """Factory class for Revenue By Recording NR."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByRecordingNr


class RevenueByRecordingDistroFactory(RevenueByRecordingBaseFactory):
    """Factory class for Revenue By Recording Distro."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByRecordingDistro


class RevenueByCountryFactory(BaseModelFactory):
    """Factory to create Revenue By Country models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByCountry

    account_id = 24601
    account_payee_currency = 'GBP'
    country_code = 'GB'
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByStoreFactory(BaseModelFactory):
    """Factory to create Revenue By Store models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByStore

    store_id = 123
    store_name = 'Spotify'
    account_payee_currency = 'USD'
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByProjectFactory(BaseModelFactory):
    """Factory to create Revenue By Project models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByProject

    project_id = 101
    project_name = 'Project Alpha'
    project_code = 'PA-001'
    project_artist = 'Artist Alpha'
    product_count = 1
    statement_period_id = 123
    account_payee_currency = 'USD'
    net_share_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByImprintFactory(BaseModelFactory):
    """Factory to create Revenue By Imprint models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByImprint

    imprintid = 123456
    imprint = 'TEST'
    account_id = 123
    subaccount_id = 1234
    account_payee_currency = 'USD'
    mechanical_deduction_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    publisher_admin_fee_payee_currency = factory.Sequence(lambda n: '%.2f' % (8 * (n + 1)))
    net_share_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueBySubaccountFactory(BaseModelFactory):
    """Factory to create Revenue By Subaccount models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueBySubaccount

    subaccount_id = 111222
    subaccount_name = 'Test Subaccount'
    account_id = 123
    account_payee_currency = 'USD'
    mechanical_deduction_amount_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    publisher_admin_fee_payee_currency = factory.Sequence(lambda n: '%.2f' % (8 * (n + 1)))
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByTransactionTypeFactory(BaseModelFactory):
    """Factory to create revenue by transaction type models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByTransactionType

    transaction_type_id = 'DR'
    transaction_type_desc = 'Downloaded Ringtones'
    account_payee_currency = 'USD'
    quantity = 10
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))


class RevenueByActivityMonthFactory(BaseModelFactory):
    """Factory to create Revenue By Activity month models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByActivityMonth

    activity_period_id = 120
    activity_month_name = 'July 2024'
    account_payee_currency = 'USD'
    net_share_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))
    net_publishing_revenue_payee_currency = None
    gross_publishing_revenue_payee_currency = None


class RevenueByStatementPeriodFactory(BaseModelFactory):
    """Factory to create Revenue By Statement Period models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueByStatementPeriod

    statement_period_id = 120
    statement_period_name = 'August 2024'
    statement_period_status = constants.StatementPeriodStatus.CLOSED
    account_payee_currency = 'USD'
    net_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (80 * (n + 1)))
    gross_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (100 * (n + 1)))
    net_publishing_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (50 * (n + 1)))
    gross_publishing_revenue_payee_currency = factory.Sequence(lambda n: '%.2f' % (60 * (n + 1)))


class RevenueDistro(BaseModelFactory):
    """Factory to create Revenue Distro models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueDistro

    account_id = 120


class RevenueNr(BaseModelFactory):
    """Factory to create Revenue Nr models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = RevenueNr

    account_id = 120


class CombinedPaymentsFactory(BaseModelFactory):
    """Factory to CombinedPayments models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = CombinedPayments

    account_id = 120
    withholding_tax_currency_amount = 12.34


class WorksheetAdjustmentFactory(BaseModelFactory):
    """Factory to create worksheet adjustment models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = WorksheetAdjustment

    worksheet_adjustment_id = 1
    statement_period_adjustment_file_id = 1
    abacus_event_id = 1
    account_id = 24601
    contract_id = 10001
    activity_statement_period_id = 123
    apply_to_statement_period_id = 123
    reference_adjustment_type_id = 1
    adjustment_amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    adjustment_currency_code = 'NOK'
    note = 'testing'
    internal_note = 'testing'
    created_by = 'me'


class WorksheetAdjustmentDetailFactory(BaseModelFactory):
    """Factory to create worksheet adjustment detail models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = WorksheetAdjustmentDetail

    worksheet_adjustment_detail_id = 1
    statement_period_adjustment_file_id = 1
    worksheet_adjustment_id = 1
    account_id = 24601
    contract_id = 10001
    activity_statement_period_id = 123
    apply_to_statement_period_id = 123
    reference_adjustment_type_id = 1
    currency_code = 'NOK'
    amount = factory.Sequence(lambda n: '%.2f' % (20 * (n + 1)))
    upc = '101010'
    distribution_type = constants.DistributionType.DIGITAL
    note = 'testing'
    internal_note = 'testing'
    created_by = 'me'
    created_at = datetime(2010, 9, 8, 7, 6, 5)
    last_modified_by = 'me'
    last_modified = datetime(2010, 9, 8, 7, 6, 5)
    deleted_by = None
    deleted_at = None


class VendorFactory(BaseModelFactory):
    """Factory to create vendor models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = Vendor

    name = 'Bigtyme Recordz'
    migrated_to_abacus = True
    sap_vendor_id = None
    vendor_id = 12345
    is_owned = 'No'
    is_distributor = 'N'
    first_statement_period = 1


class DimSubaccountFactory(BaseModelFactory):
    """Factory to create dim subaccount models for testing."""

    class Meta:
        """Meta definition for the factory."""

        model = DimSubaccount

    subaccount_id = 12345
    commission_override = 0.90
    subaccount_split_type = 'Net'


class FlowthroughPayableBalanceFactory(factory.Factory):
    """Factory to create flowthrough payable balance objects."""

    class Meta:
        """Meta definition for the factory."""

        model = SimpleNamespace

    amount = Decimal('123.45')
    currency_code = 'NOK'
    statement_period_id = 123