mnemo_cards/mnemo_cards_backend/lib/api/subscription/subscription_manager.dart

import 'package:drift_postgres/drift_postgres.dart';
import 'package:injectable/injectable.dart';
import 'package:mnemo_cards_backend/database/database.dart';
import 'package:mnemo_cards_common_backend/mnemo_cards_common_backend.dart';
import 'package:mnemo_cards_common/mnemo_cards_common.dart';
import 'package:drift/drift.dart';

@lazySingleton
class SubscriptionManager {
  final AppDatabase _db;

  SubscriptionManager(this._db);

  Future<SubscriptionDto> getSubscriptionDto(UserModel user) async {
    if (user.id == null) {
      return SubscriptionDto(
        page: null,
        isActive: false,
        start: null,
        finish: null,
      );
    }

    final subscription = await _db.subscriptionDao.getActiveUserSubscription(user.id!);
    
    return SubscriptionDto(
      page: null,
      isActive: subscription != null,
      start: subscription?.start.dateTime,
      finish: subscription?.finish.dateTime,
    );
  }

  Future<void> createSubscription(UserModel user, SubscriptionPlanModel plan) async {
    if (user.id == null || plan.id == null) {
      throw ArgumentError('User ID and Plan ID are required');
    }

    final now = DateTime.now();
    final endDate = now.add(Duration(days: plan.durationDays));

    await _db.subscriptionDao.createUserSubscription(
      UserSubscriptionsCompanion.insert(
        userId: user.id!,
        start: PgDateTime(now),
        finish: PgDateTime(endDate),
        features: const Value([]),
      ),
    );
  }

  Future<List<SubscriptionPlanModel>> getAllPlans() async {
    final plans = await _db.subscriptionDao.getAllPlans();
    return plans.map((plan) {
      final uiMap = plan.ui as Map<String, dynamic>?;
      final ui = uiMap != null ? SubscriptionPlanUI.fromJson(uiMap) : null;
      
      return SubscriptionPlanModel(
        id: plan.id,
        ui: ui,
        price: plan.price,
        currency: plan.currency,
        durationDays: plan.durationDays,
        features: [],
        paymentSystem: PaymentSystem.values.firstWhere(
          (ps) => ps.name == plan.paymentSystem,
          orElse: () => PaymentSystem.unknown,
        ),
        paymentId: plan.paymentId,
      );
    }).toList();
  }

  Future<List<SubscriptionPlanModel>> getAllSubscriptionPlans() async {
    return await getAllPlans();
  }

  Future<void> purchaseSubscription(String userId, String planId) async {
    final plan = await _db.subscriptionDao.getPlanById(planId);
    if (plan == null) {
      throw StateError('Subscription plan not found');
    }

    final now = DateTime.now();
    final endDate = now.add(Duration(days: plan.durationDays));

    await _db.subscriptionDao.createUserSubscription(
      UserSubscriptionsCompanion.insert(
        userId: userId,
        start: PgDateTime(now),
        finish: PgDateTime(endDate),
        features: Value(plan.features as List<dynamic>),
      ),
    );
  }

  Future<void> cancelSubscription(String userId) async {
    await _db.subscriptionDao.cancelUserSubscription(userId);
  }
}