from databases.model import User, Subscription, Transaction, Administrators
from sqlalchemy.future import select
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy import desc
import random
import string
import logging


class DatabaseManager:
    def __init__(self, session_generator):
        """
        Инициализация с асинхронным генератором сессий (например, get_postgres_session).
        """
        self.session_generator = session_generator
        self.logger = logging.getLogger(__name__)

    async def create_user(self, telegram_id):
        """
        Создаёт нового пользователя, если его нет.
        """
        async for session in self.session_generator():
            try:
                username = self.generate_string(6)
                result = await session.execute(select(User).where(User.telegram_id == telegram_id))
                user = result.scalars().first()
                if not user:
                    new_user = User(telegram_id=telegram_id, username=username)
                    session.add(new_user)
                    await session.commit()
                    return new_user
                return user
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при создании пользователя {telegram_id}: {e}")
                await session.rollback()
                return "ERROR"


    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 self.add_transaction(user.id, amount)
                    await session.commit()
                else:
                    self.logger.warning(f"Пользователь с Telegram ID {telegram_id} не найден.")
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при обновлении баланса: {e}")
                await session.rollback()

    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))
                )
                print(result)
                return result.scalars().all()
            except SQLAlchemyError as e:
                self.logger.error(f"Ошибка при получении последней подписки пользователя {user_id}: {e}")
                return "ERROR"

    @staticmethod
    def generate_string(length):
        """
        Генерирует случайную строку заданной длины.
        """
        characters = string.ascii_lowercase + string.digits
        return ''.join(random.choices(characters, k=length))