import datetime
from typing import List, Literal
from enum import Enum

from pydantic import BaseModel, Field
from beanie.operators import ElemMatch

from ..core.models import CrudDocument, RichtextSingleline, RichtextMultiline, DictionaryEntry
from ..entity.models import Entity


class ContractStatus(str, Enum):
    published = 'published'
    signed = 'signed'
    printed = 'printed'
    executed = 'executed'


class ContractDraftStatus(str, Enum):
    in_progress = 'in_progress'
    ready = 'ready'
    published = 'published'


class DraftParty(BaseModel):
    entity_id: str = Field(
        foreignKey={
            "reference": {
                "resource": "entity",
                "schema": "Entity",
            }
        },
        default=""
    )
    part: str
    representative_id: str = Field(
        foreignKey={
            "reference": {
                "resource": "entity",
                "schema": "Entity",
            }
        },
        default=""
    )


class Signature(BaseModel):
    uuid: str
    affixed: bool


class Party(BaseModel):
    entity: Entity
    part: str
    representative: Entity = None
    signature_uuid: str
    signature_affixed: bool = False
    signature_png: str = None


class ProvisionGenuine(BaseModel):
    type: Literal['genuine'] = 'genuine'
    title: str = RichtextSingleline(props={"parametrized": True}, default="")
    body: str = RichtextMultiline(props={"parametrized": True}, default="")


class ContractProvisionTemplateReference(BaseModel):
    type: Literal['template'] = 'template'
    provision_template_id: str = Field(
        foreignKey={
            "reference": {
                "resource": "template/provision",
                "schema": "ProvisionTemplate",
                "displayedFields": ['title', 'body']
            },
        },
        props={"parametrized": True},
        default=""
    )


class DraftProvision(BaseModel):
    provision: ContractProvisionTemplateReference | ProvisionGenuine = Field(..., discriminator='type')


class Provision(BaseModel):
    title: str = RichtextSingleline()
    body: str = RichtextMultiline()


class ContractDraft(CrudDocument):
    name: str
    title: str
    parties: List[DraftParty]
    provisions: List[DraftProvision] = Field(
       props={"items-per-row": "1", "numbered": True}
    )
    variables: List[DictionaryEntry] = Field(
        default=[],
        format="dictionary",
    )
    status: ContractDraftStatus = ContractDraftStatus.in_progress
    todo: List[str] = []

    class Settings(CrudDocument.Settings):
        bson_encoders = {
            datetime.date: lambda dt: dt if hasattr(dt, 'hour')
            else datetime.datetime(year=dt.year, month=dt.month, day=dt.day,
                                   hour=0, minute=0, second=0)
        }

    async def check_is_ready(self):
        if self.status == ContractDraftStatus.published:
            return

        self.todo = []
        if len(self.parties) < 2:
            self.todo.append('Contract must have at least two parties')
        if len(self.provisions) < 1:
            self.todo.append('Contract must have at least one provision')

        for p in self.parties:
            if not p.entity_id:
                self.todo.append('All parties must have an associated entity`')

        for p in self.provisions:
            if p.provision.type == "genuine" and not (p.provision.title and p.provision.body):
                self.todo.append('Empty genuine provision')
            elif p.provision.type == "template" and not p.provision.provision_template_id:
                self.todo.append('Empty template provision')

        for v in self.variables:
            if not (v.key and v.value):
                self.todo.append('Empty variable')

        if self.todo:
            self.status = ContractDraftStatus.in_progress
        else:
            self.status = ContractDraftStatus.ready

        await self.update({"$set": {
            "status": self.status,
            "todo": self.todo
        }})


class Contract(CrudDocument):
    name: str
    title: str
    parties: List[Party]
    provisions: List[Provision] = Field(
       props={"items-per-row": "1", "numbered": True}
    )
    status: ContractStatus = ContractStatus.published
    lawyer: Entity
    location: str
    date: datetime.date

    class Settings(CrudDocument.Settings):
        # fulltext_search = ['label']

        bson_encoders = {
            datetime.date: lambda dt: dt if hasattr(dt, 'hour')
            else datetime.datetime(year=dt.year, month=dt.month, day=dt.day,
                                   hour=0, minute=0, second=0)
        }

    @classmethod
    def find_by_signature_id(cls, signature_id: str):
        crit = ElemMatch(cls.parties, {"signature_uuid": signature_id})
        return cls.find_one(crit)

    def get_signature(self, signature_id: str):
        for p in self.parties:
            if p.signature_uuid == signature_id:
                return p

    def get_signature_index(self, signature_id: str):
        for i, p in enumerate(self.parties):
            if p.signature_uuid == signature_id:
                return i

    def is_signed(self):
        for p in self.parties:
            if not p.signature_affixed:
                return False
        return True


def replace_variables_in_value(variables, value: str):
    for v in variables:
        if v.value:
            value = value.replace('%{}%'.format(v.key), v.value)
    return value