from dataclasses import dataclass, field

from configs.firebase import SERVER_TIMESTAMP, db
from V2.functions.Images.main import Image
from V2.functions.main import DocumentData, validate
from V2.functions.Products.Variants import Variant


@dataclass(kw_only=True)
class Product(DocumentData):
    name: str
    platformId:str
    platformProductId:str
    shopId:str
    images: list[Image]
    tags: list[str]
    description:str = ""
    price: int | float = 0
    mapped:str = "unMapped"

    @classmethod 
    def getByPlatformProductId(cls, platformProductId:str):
        ref = db.collection("products").where("platformProductId", "==", platformProductId).get()
        if len(ref) > 0: return cls.from_dict(ref[0].to_dict())

    @classmethod
    def get(cls, productId:str):
        snap = db.document(f"products/{productId}").get()
        if snap.exists:return cls.from_dict({"id": snap.id, **snap.to_dict()})

    def __post_init__(self):
        if not self.id: self.id = str(self.platformId)+str(self.shopId)+str(self.platformProductId)
        self.description = self.description[:100]
        validate(self)

    def save(self,variants: list[Variant],**kwargs):
        ref = db.document(f"products/{self.id}")
        batch = db.batch()
        batch.set(ref,{**self.to_dict(), **kwargs}, merge=True)
        variantsRef = ref.collection("variants")
        existingVariants = variantsRef.get()
        for variant in existingVariants:
            if variant.id not in [v.id for v in variants]: batch.delete(variant.reference)
        batch.commit()
        batch = db.batch()
        # doneProps = []
        # for variant in variants:
        #     prop = ""
        #     for p in variant.properties:
        #         prop+=p.name+p.value
        #     prop+=prop
        #     if prop not in doneProps: doneProps.append(prop)
        #     else: variant.deleted = True
        for variant in variants: batch.set(variantsRef.document(variant.id),variant.to_dict(), merge=True)
        batch.commit()
        return self.id

def getByPlatformVariantId(platformProductId:str, platformVariantId:str):
    product = Product.getByPlatformProductId(platformProductId)
    if product:
        variant = db.document(f"products/{product.id}/variants/{platformVariantId}").get()
        if variant.exists:
            return Variant.from_dict(variant.to_dict())
    return {}

@dataclass
class ProductMapping(DocumentData):
    blankProductIds:list[str]
    imageIds:list[str]
    mappedVariants:list[str] = field(default_factory=list)
    mapped:str="unMapped"
    printOnDemand:bool=True
    ignored:bool=False
    decorationType:str|None=None

    @classmethod
    def get(cls, id:str):
        ref = db.document(f"productsMapping/{id}").get()
        if ref.exists: return cls.from_dict(ref.to_dict())