import copy
import uuid
from typing import List
from uuid import UUID

from app.models.design_progress import DesignProgressModel, CreateDesignProgress, RecordModel
from core.repositories.base import BaseRepository
from core.service.mongo_db import use_collection
from core.utils.crudify import mongo_soft_deleter

COLLECTION = "design_progress"
class DesignProgressRepository(BaseRepository[CreateDesignProgress]):
    def __int__(self):
        super().__init__(collection=COLLECTION, model=CreateDesignProgress)
    def create_progress_model(self,_inp:CreateDesignProgress)->DesignProgressModel:
        if _inp.complete_at:
            _inp.start_at = _inp.records[0].send.date_at
        progress = DesignProgressModel(
            project_id=_inp.project_id,
            type=_inp.type,
            parent_id=_inp.parent_id,
            sub_type=_inp.sub_type,
            start_at= _inp.start_at,
            complete_at= _inp.complete_at
        )
        progress.init_id().cu_at()
        return progress
    def create_record(self,_inp:CreateDesignProgress,_id:uuid.UUID=None):
        records = []
        for record in _inp.records:
            save_record = RecordModel(
                design_progress_id=_id,
                title=record.title,
                send=record.send,
                receive=record.receive
            ).init_id().cu_at()
            records.append(save_record.mongo_dict())
        return records
    async def create(self,create:CreateDesignProgress):
        progress = self.create_progress_model(create)
        await use_collection(COLLECTION).insert_one(progress.mongo_dict())
        if create.records:
            records = self.create_record(create)
            await use_collection('design_progress_record').insert_many(records)
        return self.get(progress.id)

    async def get(self, _id: UUID):
        progress = await use_collection(COLLECTION).find_one({"_id":_id})
        progress['records'] = await use_collection('design_progress_record').find({"design_progress_id":_id}).to_list(None)
        return progress

    async def update(self, _id: UUID, update: CreateDesignProgress):
        progress = self.create_progress_model(update)
        await use_collection(COLLECTION).update_one({"_id":_id},{"$set":progress.mongo_dict()})
        if update.records:
            before_records = await use_collection('design_progress_record').distinct("_id",{"design_progress_id":_id})
            update_records = []
            update_record_ids = []
            create_records = []
            delete_records = list(before_records).copy()
            for record in update.records:
                if record.id:
                    save_record = RecordModel(
                        design_progress_id=_id,
                        title=record.title,
                        send=record.send,
                        receive=record.receive
                    ).u_at()
                    update_records.append(save_record.mongo_dict())
                    update_record_ids.append(record.id)
                    delete_records.remove(record.id)
                else:
                    save_record = RecordModel(
                        design_progress_id=_id,
                        title=record.title,
                        send=record.send,
                        receive=record.receive
                    ).init_id().cu_at()
                    create_records.append(save_record.mongo_dict())
            if update_records:
                await use_collection('design_progress_record').update_many({"_id":{"$in":update_record_ids}},{"$set":update_records})
            if create_records:
                await use_collection('design_progress_record').insert_many(create_records)
            if delete_records:
                await mongo_soft_deleter({"_id":{"$in":delete_records}},'design_progress_record')
        return self.get(progress.id)