mnemo_cards/mnemo_cards_backend/lib/database/daos/subscription_dao.dart

import 'package:drift/drift.dart';
import 'package:drift_postgres/drift_postgres.dart';
import '../database.dart';
import '../tables/subscriptions.dart';
import '../tables/users.dart';

part 'subscription_dao.g.dart';

@DriftAccessor(tables: [SubscriptionPlans, UserSubscriptions])
class SubscriptionDao extends DatabaseAccessor<AppDatabase> with _$SubscriptionDaoMixin {
  SubscriptionDao(super.db);
  
  // ==================== SubscriptionPlans ====================
  
  /// Получить план подписки по ID
  Future<SubscriptionPlan?> getPlanById(String id) {
    return (select(subscriptionPlans)..where((p) => p.id.equals(id))).getSingleOrNull();
  }
  
  /// Получить все планы подписки
  Future<List<SubscriptionPlan>> getAllPlans() {
    return (select(subscriptionPlans)
      ..where((p) => p.isDeleted.equals(false))
    ).get();
  }
  
  /// Создать план подписки
  Future<String> createPlan(SubscriptionPlansCompanion plan) async {
    final inserted = await into(subscriptionPlans).insertReturning(plan);
    return inserted.id;
  }
  
  /// Обновить план подписки
  Future<bool> updatePlan(SubscriptionPlan plan) {
    return update(subscriptionPlans).replace(plan);
  }
  
  // ==================== UserSubscriptions ====================
  
  /// Получить подписку пользователя
  Future<UserSubscription?> getUserSubscription(String userId) {
    return (select(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
      ..orderBy([(us) => OrderingTerm.desc(us.finish)])
    ).getSingleOrNull();
  }
  
  /// Получить активную подписку пользователя
  Future<UserSubscription?> getActiveSubscription(String userId) async {
    final now = PgDateTime(DateTime.now());
    return (select(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
      ..where((us) => us.start.isSmallerThanValue(now))
      ..where((us) => us.finish.isBiggerThanValue(now))
      ..orderBy([(us) => OrderingTerm.desc(us.finish)])
    ).getSingleOrNull();
  }
  
  /// Проверить, есть ли у пользователя активная подписка
  Future<bool> hasActiveSubscription(String userId) async {
    final subscription = await getActiveSubscription(userId);
    return subscription != null;
  }
  
  /// Создать подписку пользователя
  Future<String> createUserSubscription(UserSubscriptionsCompanion subscription) async {
    final inserted = await into(userSubscriptions).insertReturning(subscription);
    return inserted.id;
  }
  
  /// Обновить подписку пользователя
  Future<bool> updateUserSubscription(UserSubscription subscription) {
    return update(userSubscriptions).replace(subscription);
  }
  
  /// Удалить подписку пользователя
  Future<void> deleteUserSubscription(String userId) {
    return (delete(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
    ).go();
  }
  
  /// Получить всех пользователей с активными подписками
  Future<List<UserSubscription>> getActiveSubscriptions() async {
    final now = PgDateTime(DateTime.now());
    return (select(userSubscriptions)
      ..where((us) => us.start.isSmallerThanValue(now))
      ..where((us) => us.finish.isBiggerThanValue(now))
      ..orderBy([(us) => OrderingTerm.desc(us.finish)])
    ).get();
  }

  /// Получить активную подписку пользователя (alias для getActiveSubscription)
  Future<UserSubscription?> getActiveUserSubscription(String userId) {
    return getActiveSubscription(userId);
  }

  /// Отменить подписку пользователя (установить finish на текущее время)
  Future<void> cancelUserSubscription(String userId) async {
    final subscription = await getActiveSubscription(userId);
    if (subscription != null) {
      await update(userSubscriptions).replace(
        subscription.copyWith(
          finish: PgDateTime(DateTime.now()),
        ),
      );
    }
  }
}