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) async {
    final query = select(subscriptionPlans)
      ..where((p) => p.id.equals(id))
      ..limit(1);

    final results = await query.get();
    return results.isNotEmpty ? results.first : null;
  }

  /// Получить все планы подписки
  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) async {
    final query = select(userSubscriptions)
      ..where((us) => us.userId.equals(userId))
      ..orderBy([(us) => OrderingTerm.desc(us.finish)])
      ..limit(1);

    final results = await query.get();
    return results.isNotEmpty ? results.first : null;
  }

  /// Получить активную подписку пользователя
  Future<UserSubscription?> getActiveSubscription(String userId) async {
    final now = PgDateTime(DateTime.now());
    final query = 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)])
      ..limit(1);

    final results = await query.get();
    return results.isNotEmpty ? results.first : null;
  }

  /// Проверить, есть ли у пользователя активная подписка
  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())));
    }
  }
}