struct CounterState: State {
  var counter: Int = 0
}

struct IncrementCounter: StateUpdater {
  func updateState(_ state: inout CounterState) {
    state.counter += 1
  }
}

// ignore AppDependencies for the time being, it will be explained later on
let store = Store<CounterState, AppDependencies>()
store.dispatch(IncrementCounter())

store.addListener() { oldState, newState in
  // the app state has changed
}

struct GenerateRandomNumberFromBackend: SideEffect {
  func sideEffect(_ context: SideEffectContext<CounterState, AppDependencies>) throws {
    // invokes the `getRandomNumber` method that returns a promise that is fullfilled
    // when the number is received. At that point we dispatch a State Updater
    // that updates the state
    context.dependencies.APIManager
        .getRandomNumber()
        .then { randomNumber in context.dispatch(SetCounter(newValue: randomNumber)) }
  }
}

struct SetCounter: StateUpdater {
  let newValue: Int
  
  func updateState(_ state: inout CounterState) {
    state.counter = self.newValue
  }
}

struct GenerateRandomNumberFromBackend: SideEffect {
  func sideEffect(_ context: SideEffectContext<CounterState, AppDependencies>) throws {
    // invokes the `getRandomNumber` method that returns a promise that is fulfilled
    // when the number is received.
    let promise = context.dependencies.APIManager.getRandomNumber()
    
    // we use Hydra.await to wait for the promise to be fulfilled
    let randomNumber = try Hydra.await(promise)

    // then the state is updated using the proper state updater
    try Hydra.await(context.dispatch(SetCounter(newValue: randomNumber)))
  }
}

struct PurchaseProduct: ReturningSideEffect {
  let productID: ProductID

  func sideEffect(_ context: AnySideEffectContext) throws -> Result<PurchaseResult, PurchaseError> {

    // 0. Get the typed version of the context
    guard let context = context as? SideEffectContext<CounterState, AppDependencies> else {
      fatalError("Invalid context type")
    }

    // 1. purchase the product via storekit
    let storekitResult = context.dependencies.monetization.purchase(self.productID)
    if case .failure(let error) = storekitResult {
      return .storekitRejected(error)
    }

    // 2. get the receipt
    let receipt = context.dependencies.monetization.getReceipt()

    // 3. validate the receipt
    let validationResult = try Hydra.await(context.dispatch(Monetization.Validate(receipt)))

    // 4. map error
    return validationResult
      .map { .init(validation: $0) }
      .mapError { .validationRejected($0) }
  }
}

protocol AppReturningSideEffect: ReturningSideEffect {
  func sideEffect(_ context: SideEffectContext<AppState, DependenciesContainer>) -> Void
}

extension AppReturningSideEffect {
  func sideEffect(_ context: AnySideEffectContext) throws -> Void {
    guard let context = context as? SideEffectContext<AppState, DependenciesContainer> else {
      fatalError("Invalid context type")
    }
    
    self.sideEffect(context)
  }
}

final class AppDependencies: SideEffectDependencyContainer {
  required init(dispatch: @escaping PromisableStoreDispatch, getState: @escaping GetState) {
		// initialize your dependencies here
	}
}

let dispatchableLogger = DispatchableLogger.interceptor(blackList: [NotToLog.self])
let store = Store<CounterState>(interceptor: [dispatchableLogger])

let observerInterceptor = ObserverInterceptor.observe([
  .onStart([
    // list of dispatchable items dispatched when the store is initialized
  ])
])

let store = Store<CounterState>(interceptor: [observerInterceptor])