from dataclasses import dataclass, field
from typing import Optional, List
from marshmallow_dataclass import NewType
from datetime import datetime
from marshmallow import validate
from models.artists import Artist
from models.projects import Project
from models.user import User
from models.labels import Label
from models.user_project import UserProjectRoles
from typing_extensions import Literal
from config import LABEL_IMAGE_SERVICE_URL

AVAILABLE_DSPS = ["facebook", "google", "linkfire", "tiktok"]

DSPList = NewType("DSPList", List[str], validate=validate.ContainsOnly(AVAILABLE_DSPS))

missing = Literal["missing"]


rgba_regular_expression = r"rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*([01]?\.?\d+)\)"

@dataclass
class CellStyleShema:
    background: str = field(metadata={"validate": validate.Regexp(rgba_regular_expression)})


@dataclass
class RoleSchema:
    id: int
    name: str
    categoryIds: Optional[List[int]]

    def __init__(self, role: UserProjectRoles, category_ids: Optional[List[int]] = None):
        self.id = role.value
        self.name = role.name.capitalize()
        self.categoryIds = category_ids if category_ids else []


@dataclass
class LabelResponseModel:
    id: int
    name: str
    externalId: str
    imageUrl: str
    country: Optional[str] = None
    abbreviation: Optional[str] = None

    def __init__(self, label: Label):
        self.id = label.id
        self.name = label.name
        self.externalId = label.rep_owner_key
        self.country = label.country
        self.abbreviation = label.abbreviation
        self.imageUrl = LABEL_IMAGE_SERVICE_URL.format(id=label.id)


@dataclass
class ArtistImageSchema:
    url: str
    width: Optional[int] = None
    height: Optional[int] = None


@dataclass
class ArtistSchema:
    id: str
    name: str
    isUnknown: bool
    image: Optional[ArtistImageSchema] = None
    isSony: bool = True

    @staticmethod
    def from_db_model(artist: Artist):
        schema = ArtistSchema(artist.external_id, artist.name, isUnknown=artist.is_unknown)
        if artist.images:
            image = artist.images[0]
            schema.image = ArtistImageSchema(url=image.url, width=image.width, height=image.height)
        schema.isSony = artist.is_sony
        schema.isUnknown = artist.is_unknown
        return schema


@dataclass
class GRASDataSchema:
    id: str
    title: str

    def __init__(self, project: Project):
        self.id = project.gras_project_code
        self.title = project.gras_title


@dataclass
class PRSDataSchema:
    id: str
    title: str
    updatedAt: datetime

    def __init__(self, project: Project):
        self.id = project.prs_project_code
        self.title = project.prs_title
        self.updatedAt = project.updated_by_import_at


@dataclass
class CCPDataSchema:
    id: str
    title: str
    updatedAt: datetime

    def __init__(self, project: Project):
        self.id = project.ccp_project_code
        self.title = project.ccp_title
        self.updatedAt = project.updated_by_import_at


@dataclass
class PRSBudgetCategoryItem:
    id: int
    title: str
    budget: float
    allocation: float


@dataclass
class PRSBudgetGroupItem(PRSBudgetCategoryItem):
    categories: List[PRSBudgetCategoryItem]


@dataclass
class LinkfireLinkResponseSchema:
    id: Optional[int]
    linkId: str
    linkUrl: str
    deletable: Optional[bool] = True


@dataclass
class CampaignPlatformsMetadata:
    id: int
    name: str
    value: float


@dataclass
class TeamMemberResponseSchema:
    id: int
    name: str
    email: str
    phone: str
    roles: List[RoleSchema]
    labels: List[LabelResponseModel]

    def __init__(self, user: User, roles: List[RoleSchema], user_labels: List[LabelResponseModel]):
        self.id = user.id
        self.name = user.name
        self.email = user.email
        self.phone = user.phone
        self.labels = user_labels
        self.roles = roles


class CampaignLinkfireLinkListMapper:
    @staticmethod
    def map(linkfire_campaigns) -> List[LinkfireLinkResponseSchema]:
        linkfire_links = []
        for linkfire_campaign in linkfire_campaigns:
            link = linkfire_campaign.linkfire_link
            linkfire_links.append(
                LinkfireLinkResponseSchema(
                    id=link.id,
                    linkId=link.link_id,
                    linkUrl=link.link_url,
                    deletable=linkfire_campaign.is_added_manually(),
                )
            )
        return linkfire_links


class ProjectLinkfireLinkListMapper:
    @staticmethod
    def map(linkfire_projects) -> List[LinkfireLinkResponseSchema]:
        linkfire_links = []
        for linkfire_project in linkfire_projects:
            link = linkfire_project.linkfire_link
            linkfire_links.append(
                LinkfireLinkResponseSchema(
                    id=link.id,
                    linkId=link.link_id,
                    linkUrl=link.link_url,
                    deletable=linkfire_project.is_added_manually(),
                )
            )
        return linkfire_links


@dataclass
class RoleSchema:
    id: int
    name: str
    categoryIds: Optional[List[int]]

    def __init__(self, role: UserProjectRoles, category_ids: Optional[List[int]] = None):
        self.id = role.value
        self.name = role.name.capitalize()
        self.categoryIds = category_ids if category_ids else []


@dataclass
class LabelSchema:
    id: int
    name: str
    imageUrl: str


@dataclass
class ShortUserModel:
    id: int
    name: str
    email: str

    def __init__(self, user: User):
        self.name = user.name
        self.id = user.id
        self.email = user.email