from utils import logger
from db import CRUD
from db.schemas.toolbox import Toolbox
from sqlalchemy import or_, select
from db.handlers.records import ServiceRecordsHandler


class ToolboxHandler:
    async def add(toolboxData: dict, user_id: int = None):
        title = toolboxData.get("title", None)
        if not title:
            logger.error("Не указано Назавание тулбокса")
            return {}
        query = select(Toolbox).where(Toolbox.title == title)
        toolbox = await CRUD.read(query)
        if toolbox:
            logger.error("Тулбокс с таким названием уже существует")
            return {}

        try:
            logger.info(f"Создание тулбокса {title}")
            newToolbox = await Toolbox(**toolboxData).save()
        except Exception as e:
            logger.error(f"Ошибка сохранения тулбокса: {str(e)}")
            return {}

        if not newToolbox:
            logger.error("Тулбокс не сохранен")
            return {}

        await ServiceRecordsHandler.add(
            user_id, {"Добавлен тулбокс": newToolbox.toDict()}
        )
        logger.info(f"Тулбокс {newToolbox.title} успешно создан")
        return newToolbox.toDict()

    async def edit(toolboxId: int, **kwargs):
        query = select(Toolbox).where(Toolbox.id == toolboxId)
        toolbox = await CRUD.read(query)
        if not toolbox:
            logger.error("Тулбокс не найден")
            return {}
        try:
            user_id = kwargs.pop("user_id", None)
            editedToolbox = await toolbox.edit(**kwargs)
        except Exception as e:
            logger.error(f"Ошибка обновления тулбокса: {str(e)}")
            return {}
        if not editedToolbox:
            logger.error("Тулбокс не обновлен")
            return {}
        logger.info(
            f"Тулбокс {editedToolbox.title} успешно обновлен, изменены данные: {kwargs.keys()}"
        )
        await ServiceRecordsHandler.add(
            user_id, {f"Обновлен тулбокс {toolbox.title}": editedToolbox.toDict()}
        )
        return editedToolbox.toDict()

    async def getAll() -> list:
        query = select(Toolbox)
        toolboxes = await CRUD.read(query, True)
        return [toolbox.toDict() for toolbox in toolboxes] if toolboxes else []

    async def get(toolboxId: int) -> dict:
        query = select(Toolbox).where(Toolbox.id == toolboxId)
        toolbox = await CRUD.read(query)
        if not toolbox:
            logger.error("Тулбокс не найден")
            return {}
        return toolbox.toDict()

    async def getByOwner(ownerId: int) -> list:
        query = select(Toolbox).where(
            or_(Toolbox.owner_id == ownerId, Toolbox.owner_id == None)
        )
        toolboxes = await CRUD.read(query, True)
        return [toolbox.toDict() for toolbox in toolboxes] if toolboxes else []

    async def getIdByOwner(ownerId: int) -> int:
        query = select(Toolbox).where(Toolbox.owner_id == ownerId)
        toolbox = await CRUD.read(query)
        return toolbox.id

    async def delete(toolboxId: int, user_id: int = None):
        query = select(Toolbox).where(Toolbox.id == toolboxId)
        toolbox = await CRUD.read(query)
        if not toolbox:
            logger.error("Тулбокс не найден")
            return False
        try:
            toolboxTitle = toolbox.title
            result = await CRUD.delete(toolbox)
        except Exception as e:
            logger.error(f"Ошибка удаления тулбокса: {str(e)}")
            return False
        logger.info(
            f"Тулбокс {toolboxTitle} {'успешно удален' if result else 'не удален'}"
        )
        await ServiceRecordsHandler.add(
            user_id, {"Удален тулбокс": f"Название: {toolboxTitle}"}
        )
        return result

    async def initialize():
        baseToolsboxes = [
            {
                "title": "Стеллаж",
                "description": "Основной стеллаж с режущим инструментом",
                "owner_id": None,
                "monitoring": True,
            },
            {
                "title": "Шкаф",
                "description": "Шкаф для хранения инструментов",
                "owner_id": None,
                "monitoring": True,
            },
        ]

        logger.info("Создание базовых тулбоксов")
        for toolboxData in baseToolsboxes:
            await ToolboxHandler.add(toolboxData)

        logger.info("Тулбоксы успешно созданы")
        return
