enum SyncStatus: Int, Hashable {
  case notSynced
  case inProgress
  case synced
  case failed
}

enum SyncEvent {
  case sync
}

class SyncExtraState: ExtraStateProtocol {
  var expiryDate: Date?
  
  required init() {
  }
}

  private var stateMachine: StateMachine<SyncStatus, SyncEvent>?

  // This property will be used for observing
  var currentStatus: Property<SyncStatus> {
    return self.stateMachine!.currentStatus
  }

// Scheduler will be used for running states' works
let builder = StateMachineBuilder<SyncStatus, SyncEvent, SyncExtraState>(scheduler: QueueScheduler())

let notSynced: StateBuilder<SyncStatus, SyncEvent, SyncExtraState> = StateBuilder(.notSynced)
let synced: StateBuilder<SyncStatus, SyncEvent, SyncExtraState> = StateBuilder(.synced)
let failed: StateBuilder<SyncStatus, SyncEvent, SyncExtraState> = StateBuilder(.failed)

// For describing states with "Work" we need to use a special type of StateBuilder - WorkStateBuilder.
let inProgress: WorkStateBuilder<SyncStatus, SyncEvent, SyncExtraState, ResultDomainModel<Void>> =
  WorkStateBuilder(.inProgress, work: self.doSync)
 
// If the state machine is in Not Synced state and gets the event "sync"
// it will transit to In Progress state immediately.
builder.shouldTransit(notSynced ~> inProgress).by(event: .sync).immediately()
 
// If the state machine is in In Progress state and In Progress work returns true
// the state machine will transit to Synced state immediately.
// After the transition it will call "on" condition for synced State (It sets SyncExtraState->expiryDate to now + 30 seconds).
builder.shouldTransit(inProgress ~> synced)
  .on { $0.expiryDate = Date() + 10.seconds }
  .ifResult { (result, _) in result }
 
// If the state machine is in In Progress state and In Progress work returns false
// the state machine will transit to Failed state immediately.
builder.shouldTransit(inProgress ~> failed).ifResult { (result, _) in !result }
 
// If the state machine is in Synced state and gets the event "sync" and if cache has expired
// then if all conditions fulfilled it will transit to In Progress state immediately.
builder.shouldTransit(synced ~> inProgress)
  .by(event: .sync)
  .ifCondition { $0.expiryDate == nil || $0.expiryDate! < Date() }
 
// If the state machine is in Failed state and gets the event "sync"
// it will transit to In Progress state immediately.
builder.shouldTransit(failed ~> inProgress).by(event: .sync).immediately()
 
// Create the state machine with initial state Not Synced
self.stateMachine = builder.build(initialState: notSynced)

  func doSync() -> SignalProducer<Bool, NoError> {
    // Write some sycnronization code
  }

  func sync() {
    self.stateMachine?.execute(event: .sync)
  }