import 'package:storytime/core/error/failure.dart';

/// Résultat d'une opération qui peut échouer.
///
/// - [Ok] : succès avec une valeur de type [S].
/// - [Err] : échec avec un [Failure] typé.
///
/// Utilisé par les use cases pour renvoyer succès ou erreur sans lever
/// d'exception à travers les couches.
sealed class Result<S> {
  const Result();

  /// Transforme la valeur en cas de succès ; laisse [Err] intact.
  Result<T> map<T>(T Function(S value) transform) => switch (this) {
    Ok<S>(:final value) => Ok<T>(transform(value)),
    Err<S>(:final failure) => Err<T>(failure),
  };

  /// Réduit le résultat à une valeur unique en fournissant les deux branches.
  T fold<T>({
    required T Function(S value) onOk,
    required T Function(Failure failure) onErr,
  }) => switch (this) {
    Ok<S>(:final value) => onOk(value),
    Err<S>(:final failure) => onErr(failure),
  };

  /// Exécute un effet de bord selon la branche, sans retourner de valeur.
  void when({
    required void Function(S value) ok,
    required void Function(Failure failure) err,
  }) {
    switch (this) {
      case Ok<S>(:final value):
        ok(value);
      case Err<S>(:final failure):
        err(failure);
    }
  }
}

/// Cas succès.
final class Ok<S> extends Result<S> {
  const Ok(this.value);

  final S value;

  @override
  bool operator ==(Object other) => other is Ok<S> && other.value == value;

  @override
  int get hashCode => value.hashCode;

  @override
  String toString() => 'Ok($value)';
}

/// Cas échec.
final class Err<S> extends Result<S> {
  const Err(this.failure);

  final Failure failure;

  @override
  bool operator ==(Object other) => other is Err<S> && other.failure == failure;

  @override
  int get hashCode => failure.hashCode;

  @override
  String toString() => 'Err($failure)';
}