from dataclasses import field
from datetime import date
from typing import Optional, List

from marshmallow import validate
from marshmallow_dataclass import dataclass

from models.campaign import Campaign
from models.campaign_provider import CampaignProvider
from models.prs_budget_category import PRSBudgetCategory
from models.prs_budget_group import PRSBudgetGroup
from models.prs_purchase_order import PRSPurchaseOrder, PRSPurchaseOrderStatus
from constants.pagination import PAGE_OFFSET_DEFAULT, PAGE_LIMIT_DEFAULT


@dataclass
class PurchaseOrderBudgetGroup:
    id: int
    name: str

    def __init__(self, group: PRSBudgetGroup):
        self.id = group.id
        self.name = group.name


@dataclass
class PurchaseOrderBudgetCategory:
    id: int
    name: str

    def __init__(self, category: PRSBudgetCategory):
        self.id = category.id
        self.name = category.name


@dataclass
class PurchaseOrderProvider:
    id: int
    name: str

    def __init__(self, provider: CampaignProvider):
        self.id = provider.id
        self.name = provider.name


@dataclass
class PurchaseOrderCampaignTypeCategorySchema:
    id: int
    name: str


@dataclass
class PurchaseOrderCampaignTypeSchema:
    id: int
    name: str
    category: Optional[PurchaseOrderCampaignTypeCategorySchema]


@dataclass
class PurchaseOrderCampaignSchema:
    id: int
    name: str
    isDeleted: bool
    type: Optional[PurchaseOrderCampaignTypeSchema]

    def __init__(self, campaign: Campaign):
        self.id = campaign.id
        self.name = campaign.name
        self.isDeleted = campaign.is_deleted
        if campaign.type:
            self.type = PurchaseOrderCampaignTypeSchema(
                id=campaign.type.id,
                name=campaign.type.name,
                category=PurchaseOrderCampaignTypeCategorySchema(
                    id=campaign.type.group.id, name=campaign.type.group.name
                ),
            )


@dataclass
class PurchaseOrderDetailsSchema:
    id: int
    name: str
    poNumber: str
    budget: float
    allocation: float
    status: str
    budgetGroup: PurchaseOrderBudgetGroup
    budgetCategory: PurchaseOrderBudgetCategory
    provider: PurchaseOrderProvider
    createdDate: date = field(metadata={"format": "%Y-%m-%d"})
    lastModifiedDate: date = field(metadata={"format": "%Y-%m-%d"})
    linkedCampaign: Optional[PurchaseOrderCampaignSchema]
    notes: Optional[str]
    budgetCurrency: str
    allocationCurrency: str
    isBlanket: bool

    def __init__(self, purchase_order: PRSPurchaseOrder):
        self.id = purchase_order.id
        self.name = purchase_order.name
        self.poNumber = str(purchase_order.po_number)
        self.budget = purchase_order.total_amount
        self.allocation = purchase_order.paid_amount
        self.status = PRSPurchaseOrderStatus.status_name(purchase_order.status)
        self.budgetGroup = PurchaseOrderBudgetGroup(purchase_order.prs_budget_group)
        self.budgetCategory = PurchaseOrderBudgetCategory(purchase_order.prs_budget_category)
        self.provider = PurchaseOrderProvider(purchase_order.provider)
        self.createdDate = purchase_order.created_date
        self.lastModifiedDate = purchase_order.last_modified_date
        self.budgetCurrency = purchase_order.total_amount_currency
        self.allocationCurrency = purchase_order.paid_amount_currency
        if purchase_order.campaigns:
            self.linkedCampaign = PurchaseOrderCampaignSchema(purchase_order.campaigns[0])
        self.notes = purchase_order.description
        self.isBlanket = purchase_order.is_blanked
        if len(purchase_order.child_purchase_orders) == 0:
            self.isBlanket = False


@dataclass
class PurchaseOrdersResponseSchema:
    items: List[PurchaseOrderDetailsSchema] = field(default_factory=list)
    total: int = field(default_factory=int)
    limit: int = field(default_factory=int)
    offset: int = field(default_factory=int)

    def __init__(self, items: List[PurchaseOrderDetailsSchema], total: int, limit: int, offset: int):
        self.items = items
        self.total = total
        self.limit = limit
        self.offset = offset


@dataclass
class BlanketPurchaseOrdersListQueryParams:
    provider: Optional[int]
    status: Optional[int]
    search: Optional[str] = field(metadata={"validate": validate.Length(min=2)})
    limit: Optional[int] = field(default=PAGE_LIMIT_DEFAULT, metadata={"validate": validate.Range(min=1)})
    offset: Optional[int] = field(default=PAGE_OFFSET_DEFAULT, metadata={"validate": validate.Range(min=0)})
    sort: Optional[str] = field(default="name")


@dataclass
class PurchaseOrderProviderSchema:
    id: int
    name: str
    isPRSVendor: bool

    def __init__(self, provider: CampaignProvider):
        self.id = provider.id
        self.name = provider.name
        self.isPRSVendor = provider.is_prs_vendor