from sqlalchemy.future import select
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy import desc
from instance.model import User, Subscription, Transaction


class PostgresRepository:
    def __init__(self, session_generator, logger):
        self.session_generator = session_generator
        self.logger = logger

    async def create_user(self, telegram_id: int, username: str):
        """
        Создаёт нового пользователя в PostgreSQL.
        """
        async for session in self.session_generator():
            try:
                new_user = User(telegram_id=telegram_id, username=username)
                session.add(new_user)
                await session.commit()
                return new_user
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при создании пользователя {telegram_id}: {e}")
                await session.rollback()
                return None

    async def get_user_by_telegram_id(self, telegram_id: int):
        """
        Возвращает пользователя по Telegram ID.
        """
        async for session in self.session_generator():
            try:
                result = await session.execute(select(User).where(User.telegram_id == telegram_id))
                return result.scalars().first()
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при получении пользователя {telegram_id}: {e}")
                return None

    async def add_transaction(self, user_id: int, amount: float):
        """
        Добавляет транзакцию для пользователя.
        """
        async for session in self.session_generator():
            try:
                transaction = Transaction(user_id=user_id, amount=amount)
                session.add(transaction)
                await session.commit()
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка добавления транзакции для пользователя {user_id}: {e}")
                await session.rollback()

    async def update_balance(self, telegram_id: int, amount: float):
        """
        Обновляет баланс пользователя.
        """
        async for session in self.session_generator():
            try:
                result = await session.execute(select(User).where(User.telegram_id == telegram_id))
                user = result.scalars().first()
                if user:
                    user.balance += amount
                    await session.commit()
                    return user
                else:
                    self.logger.warning(f"Пользователь с Telegram ID {telegram_id} не найден.")
                    return None
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при обновлении баланса: {e}")
                await session.rollback()
                return None

    async def last_subscription(self, user_id: int):
        """
        Возвращает последние подписки пользователя.
        """
        async for session in self.session_generator():
            try:
                result = await session.execute(
                    select(Subscription)
                    .where(Subscription.user_id == user_id)
                    .order_by(desc(Subscription.created_at))
                )
                return result.scalars().all()
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при получении последней подписки пользователя {user_id}: {e}")
                return None

    async def last_transaction(self, user_id: int):
        """
        Возвращает последние транзакции пользователя.
        """
        async for session in self.session_generator():
            try:
                result = await session.execute(
                    select(Transaction)
                    .where(Transaction.user_id == user_id)
                    .order_by(desc(Transaction.created_at))
                )
                return result.scalars().all()
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при получении транзакций пользователя {user_id}: {e}")
                return None