from datetime import datetime, timedelta

from sqlalchemy import select
from db.schemas import StocksRecords, ServicesRecords
from utils import logger


class StocksRecordsHandler:
    async def add(
        action: str,
        source_toolbox_id: int,
        target_toolbox_id: int,
        toolkit_id: int,
        init_user_id: int,
        reason: str,
        quantity: int,
    ):
        recordData = {
            "action": action,
            "source_toolbox_id": source_toolbox_id,
            "toolkit_id": toolkit_id,
            "init_user_id": init_user_id,
            "reason": reason,
            "quantity": quantity,
        }
        if target_toolbox_id:
            recordData["target_toolbox_id"] = target_toolbox_id
        try:
            logger.info(f"Создание записи: {action} от {init_user_id}")
            logger.debug(recordData)
            record = StocksRecords(**recordData)
            await record.save()
            logger.info(f"Запись успешно создана, id: {record.id}")
            return True
        except Exception as e:
            logger.error(f"Ошибка создания записи: {str(e)}")
            return False

    async def accept(record_id: int, accept_user_id: int):
        try:
            logger.info(f"Принятие записи {record_id} от {accept_user_id}")
            record = await StocksRecords.get(id=record_id)
            record.accept_user_id = accept_user_id
            record.accepted_at = datetime.now()
            await record.save()
            logger.info(
                f"Запись {record_id} успешно принята {accept_user_id} в {record.accepted_at.strftime('%Y-%m-%d %H:%M:%S')}"
            )
            return True
        except Exception as e:
            logger.error(f"Ошибка принятия записи: {str(e)}")
            return False

    async def edit(record_id: int, edit_user_id: int, **kwargs):
        try:
            logger.info(f"Обновление записи {record_id} от {edit_user_id}")
            record = await StocksRecords.get(id=record_id)
            record.edit_user_id = edit_user_id
            record.edited_at = datetime.now()
            edited = {}
            for key, value in kwargs.items():
                originalValue = getattr(record, key)
                setattr(record, key, value)
                edited[key] = {"original": originalValue, "new": value}
            record.edited = edited
            await record.save()
            logger.info(
                f"Запись {record_id} успешно обновлена {edit_user_id} в {record.updated_at.strftime('%Y-%m-%d %H:%M:%S')}"
            )
            logger.debug(edited)
            return True
        except Exception as e:
            logger.error(f"Ошибка обновления записи: {str(e)}")
            return False

    async def get(user_id: int = None, days: int = 30):
        from db import CRUD

        try:
            if user_id:
                userInfo = f"пользователя {user_id} "
                query = select(StocksRecords).where(
                    StocksRecords.init_user_id == user_id,
                    StocksRecords.created_at > datetime.now() - timedelta(days=days),
                )
            else:
                userInfo = "всех пользователей "
                query = select(StocksRecords).where(
                    StocksRecords.created_at > datetime.now() - timedelta(days=days),
                )
            logger.info(f"Получение всех записей {userInfo}за последние {days} дн.")
            records = await CRUD.read(query, True)
            logger.info(
                f"{len(records)} записей {userInfo}за последние {days} дн. успешно получены"
            )
            if len(records) == 0:
                return []
            records.sort(key=lambda x: x.created_at, reverse=True)
            recordsData = [record.toDict() for record in records]
            logger.debug(recordsData)
            return recordsData
        except Exception as e:
            logger.error(f"Ошибка получения записей: {str(e)}")
            return False


class ServiceRecordsHandler:
    async def add(user_id: int, details: dict):
        try:
            logger.info(f"Создание записи: {user_id}")
            logger.debug(details)
            record = ServicesRecords(user_id=user_id, details=details)
            await record.save()
            logger.info(f"Запись успешно создана, id: {record.id}")
            return True
        except Exception as e:
            logger.error(f"Ошибка создания записи: {str(e)}")
            return False