import SwiftUI
import Store

struct CounterModel { var count: Int }

struct CounterView: View {
  @ObservedObject var store = Store(model: CounterModel(count: 0))
  
  var body: some View {
    VStack {
      Text(String(describing: store.binding.count))
      HStack {
        Button("Increase") { store.binding.count += 1 }
        Button("Decrease") { store.binding.count -= 1 }
      }
    }
  }
}

final class Todo: Codable, Identifiable {
  let id = PushID.default.make()
  var text: String = "Untitled Todo"
  var done: Bool = false
}

final class TodoList: Codable {
  var todos: [Todo] = []
}

extension Store where M == TodoList {
  func addNewTodo() {
    mutate { $0.todos.append(Todo()) }
  }
  func move(from source: IndexSet, to destination: Int) {
    mutate { $0.todos.move(fromOffsets: source, toOffset: destination) }
  }
  func remove(todo: Todo) {
    mutate { model in 
      model.todos = model.todos.filter { $0.id != todo.id } 
    }
  }
}

// MARK: - Views

struct TodoView: View {
  @ObservedObject var store: CodableStore<Todo>
  let onRemove: () -> Void
  
  var body: some View {
    HStack {
      // Move handle.
      Image(systemName: "line.horizontal.3")
      // Text.
      if store.readOnlyModel.done {
        Text(store.readOnlyModel.text).strikethrough()
      } else {
        TextField("Todo", text: $store.binding.text)
      }
      Spacer()
      // Mark item as done.
      Toggle("", isOn: $store.binding.done)
      // Remove task.
      Button("Remove", action: onRemove)
    }.padding()
  }
}

struct TodoListView: View {
  @ObservedObject var store = CodableStore(model: TodoList())
  
  var body: some View {
    List {
      // Todo items.
      ForEach(store.readOnlyModel.todos) { todo in
        TodoView(store: CodableStore(model: todo)) { store.remove(todo: todo) }
      }
      .onMove(perform: store.move)
      // Add a new item.
      Button("New Todo", action: store.addNewTodo)
    }
  }
}

struct Counter { var count = 0 }
let store = Store<Counter>(model: Counter())

enum CounterAction: Action {
  case increase
  case decrease

  func mutate(context: TransactionContext<Store<Counter>, Self>) {
    defer {
      // Remember to always call `fulfill` to signal the completion of this operation.
      context.fulfill()
    }
    switch self {
    case .increase(let amount):
      context.update { $0.count += 1 }
    case .decrease(let amount):
      context.update { $0.count -= 1 }
    }
  }
  
  func cancel(context: TransactionContext<Store<Counter>, Self>) { }
}

struct IncreaseAction: Action {
  let count: Int

  func mutate(context: TransactionContext<Store<Counter>, Self>) {
    defer {
      // Remember to always call `fulfill` to signal the completion of this operation.
      context.fulfill()
    }
    context.mutate { $0.count += 1 }
  }
  
  func cancel(context: TransactionContext<Store<Counter>, Self>) { }
}

Button("Increase") { store.binding.count += 1 }

 let store = Store(model: Todo())
 [...]
 extension Store where M == Todo {
   func upload() -> Future<Void, Error> {
     run(action: TodoAction.uploadAndSynchronizeTodo, throttle: 1)
   }
 }

struct Model { let items: [Item] }
let store = Store(model: Model())
let child = store.makeChildStore(keyPath: \.[0])

let t1 = store.transaction(.addItem(cost: 125))
let t2 = store.transaction(.checkout)
let t3 = store.transaction(.showOrdern)
t2.depend(on: [t1])
t3.depend(on: [t2])
[t1, t2, t3].run()

struct MySerializableModel: Codable {
var count = 0
var label = "Foo"
var nullableLabel: String? = "Bar"
var nested = Nested()
var array: [Nested] = [Nested(), Nested()]
  struct Nested: Codable {
  var label = "Nested struct"
  }
}

let store = SerializableStore(model: TestModel(), diffing: .async)
store.$lastTransactionDiff.sink { diff in
  // diff is a `TransactionDiff` obj containing all of the changes that the last transaction has applied to the store's model.
}

public struct TransactionDiff {
  /// The set of (`path`, `value`) that has been **added**/**removed**/**changed**.
  ///
  /// e.g. ``` {
  ///   user/name: <added ⇒ "John">,
  ///   user/lastname: <removed>,
  ///   tokens/1:  <changed ⇒ "Bar">,
  /// } ```
  public let diffs: [FlatEncoding.KeyPath: PropertyDiff]
  /// The identifier of the transaction that caused this change.
  public let transactionId: String
  /// The action that caused this change.
  public let actionId: String
  /// Reference to the transaction that cause this change.
  public var transaction: AnyTransaction
  /// Returns the `diffs` map encoded as **JSON** data.
  public var json: Data
}

/// Represent a property change.
/// A change can be an **addition**, a **removal** or a **value change**.
public enum PropertyDiff {
  case added(new: Codable?)
  case changed(old: Codable?, new: Codable?)
  case removed
}

struct App {
  struct Todo {
    var name: String = "Untitled"
    var description: String = "N/A"
    var done: Bool = false
  }
  var todos: [Todo] = []
}

// This action targets a Store<Todo>...
struct TodoActionMarkAsDone: Action {
  func reduce(context: TransactionContext<Store<App.Todo>, Self>) {
    defer { context.fulfill() }
    context.reduceModel { $0.done = true }
  }
}

// ..While this one the whole collection Store<[Todo]>
struct TodoListActionCreateNew: Action {
  let name: String
  let description: String
  func reduce(context: TransactionContext<Store<Array<App.Todo>>, Self>) {
    defer { context.fulfill() }
    let new = Root.Todo(name: name, description: description)
    context.reduceModel {
      $0.append(new)
    }
  }
}

let appModel = App()
let rootStore = Store(model: appModel)

let todoListStore = rootStore.makeChildStore(keyPath: \.todos)
todoListStore.run(action: TodoListActionCreateNew(name: "New", decription: "New"), mode: .sync)

let todoStore = rootStore.makeChildStore(keyPath: \.[0])
todoStore.run(action: TodoActionMarkAsDone(), mode: .sync)

store.run(actions: [
  CounterAction.increase(amount: 1),
  CounterAction.increase(amount: 1),
  CounterAction.increase(amount: 1),
]) { context in
  // Will be executed after all of the transactions are completed.
}

store.run(action: CounterAction.increase(amount: 1), strategy: .mainThread)
store.run(action: CounterAction.increase(amount: 1), strategy: .sync)

let t1 = store.transaction(.addItem(cost: 125))
let t2 = store.transaction(.checkout)
let t3 = store.transaction(.showOrdern)
t2.depend(on: [t1])
t3.depend(on: [t2])
[t1, t2, t3].run()

func calledOften() {
  store.run(.myAction, throttle: 0.5)
}

store.run(action: CounterAction.increase(amount: 1)).$state.sink { state in
  switch(state) {
  case .pending: ...
  case .started: ...
  case .completed: ...
  }
}

sink = store.$lastTransactionDiff.sink { diff in
  diff.query { $0.path.to.my.property }.isChanged() // or .isRemoved(), .isAdded()
}

struct IncreaseAction: Action {
  let count: Int

  func reduce(context: TransactionContext<Store<Counter>, Self>) {
    // Remember to always call `fulfill` to signal the completion of this operation.
    defer { context.fulfill() }
    // The operation terminates here because an error has been raised in this dispatch group.
    guard !context.rejectOnPreviousError() { else return }
    // Kill the transaction and set TransactionGroupError.lastError.
    guard store.model.count != 42 { context.reject(error: Error("Max count reach") }
    // Business as usual...
    context.reduceModel { $0.count += 1 }
  }
}

let cancellable: AnyCancellable = store.run(action: CounterAction.increase(amount: 1)).eraseToAnyCancellable();
cancellable.cancel()