import 'package:drift/drift.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(int 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<int> createPlan(SubscriptionPlansCompanion plan) {
    return into(subscriptionPlans).insert(plan);
  }
  
  /// Обновить план подписки
  Future<bool> updatePlan(SubscriptionPlan plan) {
    return update(subscriptionPlans).replace(plan);
  }
  
  // ==================== UserSubscriptions ====================
  
  /// Получить подписку пользователя
  Future<UserSubscription?> getUserSubscription(int userId) {
    return (select(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
      ..orderBy([(us) => OrderingTerm.desc(us.finish)])
    ).getSingleOrNull();
  }
  
  /// Получить активную подписку пользователя
  Future<UserSubscription?> getActiveSubscription(int userId) async {
    final now = 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(int userId) async {
    final subscription = await getActiveSubscription(userId);
    return subscription != null;
  }
  
  /// Создать подписку пользователя
  Future<int> createUserSubscription(UserSubscriptionsCompanion subscription) {
    return into(userSubscriptions).insert(subscription);
  }
  
  /// Обновить подписку пользователя
  Future<bool> updateUserSubscription(UserSubscription subscription) {
    return update(userSubscriptions).replace(subscription);
  }
  
  /// Удалить подписку пользователя
  Future<void> deleteUserSubscription(int userId) {
    return (delete(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
    ).go();
  }
  
  /// Получить всех пользователей с активными подписками
  Future<List<UserSubscription>> getActiveSubscriptions() async {
    final now = 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(int userId) {
    return getActiveSubscription(userId);
  }

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