Command pattern və yan effektlər

// Rəsmi dizayn pattern səhifəsindəki forma (sadələşdirilmiş).
typedef CommandAction0<T> = Future<Result<T>> Function();
typedef CommandAction1<T, A> = Future<Result<T>> Function(A);

abstract class Command<T> extends ChangeNotifier {
  bool _running = false;
  Result<T>? _result;

  bool get running => _running;
  bool get error => _result is Error;
  bool get completed => _result is Ok;
  Result<T>? get result => _result;

  /// Nəticə bir dəfə istifadə olunduqdan sonra təmizlənir —
  /// beləliklə snackbar/dialoq TƏKRARLANMIR.
  void clearResult() {
    _result = null;
    notifyListeners();
  }

  Future<void> _execute(CommandAction0<T> action) async {
    // İkiqat basılmanın qarşısı: əməliyyat gedirsə, erkən qayıdır.
    if (_running) return;

    _running = true;
    _result = null;
    notifyListeners();

    try {
      _result = await action();
    } finally {
      _running = false;
      notifyListeners();
    }
  }
}

final class Command0<T> extends Command<T> {
  Command0(this._action);
  final CommandAction0<T> _action;

  Future<void> execute() async => _execute(_action);
}

final class Command1<T, A> extends Command<T> {
  Command1(this._action);
  final CommandAction1<T, A> _action;

  Future<void> execute(A argument) async =>
      _execute(() => _action(argument));
}

// ── View model-də istifadə ──
class OrderViewModel extends ChangeNotifier {
  OrderViewModel({required OrderRepository repository})
      : _repository = repository {
    load = Command0(_load);
    cancel = Command1(_cancel);
  }

  final OrderRepository _repository;

  late final Command0<List<Order>> load;
  late final Command1<Order, String> cancel;

  Future<Result<List<Order>>> _load() => _repository.fetchMine();
  Future<Result<Order>> _cancel(String id) => _repository.cancel(id);
}

// ── View-da: ListenableBuilder command-a abunə olur ──
// ListenableBuilder(
//   listenable: viewModel.load,
//   builder: (context, child) {
//     if (viewModel.load.running) return const CircularProgressIndicator();
//     if (viewModel.load.error) return const ErrorView();
//     return child!;
//   },
//   child: ...,
// )

// ══ Notifier: command + ikiqat basılma müdafiəsi ══
@riverpod
class CheckoutNotifier extends _$CheckoutNotifier {
  @override
  CheckoutState build() =>
      CheckoutState.editing(form: CheckoutForm.empty());

  Future<SubmitOutcome> submit() async {
    // 1) Müdafiə: yalnız editing/failed vəziyyətindən başlayır.
    final form = switch (state) {
      CheckoutEditing(:final form) => form,
      CheckoutFailed(:final form) => form,
      CheckoutSubmitting() => null,     // artıq gedir → təkrar yox
      CheckoutSubmitted() => null,      // artıq bitib
    };
    if (form == null) return SubmitOutcome.ignored;

    state = CheckoutState.submitting(form: form);

    final result = await ref.read(orderRepositoryProvider).place(form);

    switch (result) {
      case Ok(:final value):
        state = CheckoutState.submitted(order: value);
        // 2) Nəticə qaytarılır — naviqasiya BURADA edilmir.
        return SubmitOutcome.success(orderId: value.id);
      case Error(error: ValidationFailure(:final fieldErrors)):
        state = CheckoutState.editing(form: form, fieldErrors: fieldErrors);
        return SubmitOutcome.invalid;
      case Error(:final error):
        state = CheckoutState.failed(form: form, failure: error as Failure);
        return SubmitOutcome.failed;
    }
  }
}

// ══ View: yan effekt bir dəfə, mounted yoxlaması ilə ══
class CheckoutPage extends ConsumerWidget {
  const CheckoutPage({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final state = ref.watch(checkoutNotifierProvider);
    final isSubmitting = state is CheckoutSubmitting;

    return Scaffold(
      body: CheckoutFormView(state: state),
      bottomNavigationBar: FilledButton(
        // 3) Düymə də deaktiv edilir — iki səviyyəli müdafiə.
        onPressed: isSubmitting ? null : () => _submit(context, ref),
        child: isSubmitting
            ? const CircularProgressIndicator()
            : Text(AppLocalizations.of(context).submitOrder),
      ),
    );
  }

  Future<void> _submit(BuildContext context, WidgetRef ref) async {
    final outcome =
        await ref.read(checkoutNotifierProvider.notifier).submit();

    // 4) `await`-dan SONRA context işlədilir → mounted yoxlanılır.
    if (!context.mounted) return;

    final l10n = AppLocalizations.of(context);
    switch (outcome) {
      case SubmitSuccess(:final orderId):
        // Naviqasiya view-da: bir dəfə, açıq şəkildə.
        context.go('/orders/$orderId?justCreated=true');
      case SubmitOutcome.invalid:
        // Sahə xətaları artıq state-dədir; əlavə snackbar lazım deyil.
        break;
      case SubmitOutcome.failed:
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(l10n.submitFailed)),
        );
      case SubmitOutcome.ignored:
        break;
    }
  }
}

// ══ Alternativ: ref.listen ilə (state dəyişikliyinə reaksiya) ══
// build içində:
// ref.listen(checkoutNotifierProvider, (previous, next) {
//   if (next case CheckoutSubmitted(:final order)) {
//     context.go('/orders/${order.id}');
//   }
// });
// Bu variant "state-ə görə naviqasiya" məntiqi üçün uyğundur
// (deep link, avtomatik yönləndirmə); düymə basılması üçün isə
// yuxarıdaki `await` variantı daha aydındır.