import uuid

from app.config import TaskEnv
from app.models.report import StatusReport, ReportCountry, DonutList
from core.service.mongo_db import use_collection


class ReportRepository():
    async def project_status(self, _inp: StatusReport,type):
        if _inp.state:
            match = {f'{type}.sts': {'$exists': 1}, 'design.state':_inp.state}

        else:
            match = {f'{type}.sts': {'$exists': 1}}
        report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
            {
                "$match": match
            },
            {
                '$group': {
                    '_id': f"${type}.sts",
                    'count': {'$sum': 1}
                        }
            }
        ]).to_list(None)
        return report

    async def project_status_design(self, _inp: StatusReport):
        return await self.project_status(_inp, 'design')

    async def project_status_monitor(self, _inp: StatusReport):
        return await self.project_status(_inp, 'monitor')


    async def report_country(self ,_inp: ReportCountry):
        match = {}
        if _inp.state:
            match = {'design.state':_inp.state}
        if _inp.type_id:
            match.update({'design.type_id': _inp.type_id})
        if _inp.nature_id:
            match.update({'design.nature_id':_inp.nature_id})
        if _inp.monitor_type:
            match.update({'monitor.base_information.type': _inp.monitor_type})

            # count_nature = await use_collection(TaskEnv.CLN_PROJECT).count_documents(
            #     {'design.nature_id':_inp.nature_id,'design.state':_inp.state})
            # count_type = await use_collection(TaskEnv.CLN_PROJECT).count_documents({'design.type_id': _inp.type_id,'design.state':_inp.state})
            # count_monitor_type = await use_collection(TaskEnv.CLN_PROJECT).count_documents({'monitor.base_information.type': _inp.monitor_type,'design.state':_inp.state})

        report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
            {"$match":match},
            {'$group': {
                '_id': "$design.state",
                'nature_id': {'$addToSet': '$design.nature_id'},
                'type_id': {'$addToSet': '$design.type_id'},
                'monitor_type': {'$addToSet': '$monitor.base_information.type'}
            }},
            {'$project': {
                'count_nature_id': {"$size": "$nature_id"},
                'count_type_id': {"$size": "$type_id"},
                'count_monitor_type': {"$size": "$monitor_type"},
                "_id": 1
            }}
        ]).to_list(None)
            # count_nature = await use_collection(TaskEnv.CLN_PROJECT).count_documents(
            #     {'design.nature_id': _inp.nature_id})
            # count_type = await use_collection(TaskEnv.CLN_PROJECT).count_documents({'design.type_id':_inp.type_id})
            # count_monitor_type = await use_collection(TaskEnv.CLN_PROJECT).count_documents({'monitor.base_information.type': _inp.monitor_type})
        # return {'count_nature':count_nature,'count_type':count_type,'count_monitor_type':count_monitor_type}
        return report

    async def exist_project_state(self):
        report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
            {
                '$group': {
                    '_id': "$design.state",
                    'count': {'$sum': 1}
                }
            }
        ]).to_list(None)

        return report

    async def donut(self,_select:int):
        report = None
        if _select == 1:
            report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
                {"$group":{"_id":"$design.nature_id",'count':{'$sum':1}}}
            ]).to_list(None)
        elif _select == 2:
            report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
                {
                    "$group": {
                        "_id": {
                            "$cond": [
                                {"$lt": ["$design.building_infrastructure", 1000]},  # Check if a < 10
                                "less_than_1000",
                                {
                                    "$cond": [
                                        {"$and": [{"$gte": ["$design.building_infrastructure", 1000]}, {"$lt": ["$design.building_infrastructure", 5000]}]},  # Check if 10 <= a < 20
                                        "between_1000_and_5000",
                                        {
                                            "$cond": [
                                                {"$and": [{"$gte": ["$design.building_infrastructure", 5000]}, {"$lt": ["$design.building_infrastructure", 15000]}]},
                                                "between_5000_and_15000",
                                                {
                                                    "$cond": [
                                                        {"$and": [{"$gte": ["$design.building_infrastructure", 15000]}, {"$lt": ["$design.building_infrastructure", 30000]}]},
                                                        "between_15000_and_30000",
                                                        "greater_than_or_equal_30000"  # Otherwise, a >= 30
                                                    ]
                                                }
                                            ]
                                        }
                                    ]
                                }
                            ]
                        },
                        "total": {"$sum": 1},
                    }
                }
            ]).to_list(None)

        elif _select == 3:
            report = await use_collection(TaskEnv.CLN_PROJECT).aggregate([
                {"$group": {"_id": "$design.type_id", 'count': {'$sum': 1}}}
            ]).to_list(None)
        return report

    async def list_donut(self,_inp:DonutList):
        _filter = {'design.nature_id':_inp.donut_select}
        if _inp.type == 2:
            if _inp.donut_select == "less_than_1000":
                _filter = {'design.building_infrastructure': {'$lt': 1000}}
            elif _inp.donut_select == "between_1000_and_5000":
                _filter = {'design.building_infrastructure': {'$lt': 5000, "$gte": 1000 }}
            elif _inp.donut_select == "between_5000_and_15000":
                _filter = {'design.building_infrastructure': {'$lt': 15000, "$gte": 5000 }}
            elif _inp.donut_select == "between_15000_and_30000":
                _filter = {'design.building_infrastructure': {'$lt': 30000, "$gte": 15000 }}
            else:
                _filter = {'design.building_infrastructure': {'$gte': 30000}}
        elif _inp.type == 3 :
            _filter = {'design.type_id': _inp.donut_select}
        report = await use_collection(TaskEnv.CLN_PROJECT).find(_filter).to_list(None)

        return report

    async def delay_donut(self):
        ...
        # await use_collection(TaskEnv.CLN_BILL_DELAY).aggregate([
        #     {'$group':}
        # ])