Day 6 · 조립 ② — 컬렉션

struct TodoItem: Identifiable, Equatable {
  let id: Int
  var title: String
  var isDone = false
}

@MainActor @Observable
final class TodoListModel {
  var items: [TodoItem] = []
  func sync(id: TodoItem.ID) async {
    try? await Task.sleep(for: .seconds(1))
    // await 뒤에는 인덱스를 새로 찾아야 한다 — O(n)
    guard let index = items.firstIndex(where: { $0.id == id }) else { return }
    items[index].isDone = true
  }
}

func identifiedBasics() {
  var todos: IdentifiedArrayOf<TodoItem> = [
    TodoItem(id: 1, title: "우유"),
    TodoItem(id: 2, title: "메일"),
  ]
  todos[id: 2]?.isDone = true            // id로 O(1) 접근·수정
  todos.remove(id: 1)                    // id로 삭제
  todos.append(TodoItem(id: 3, title: "운동"))
  todos[id: 3] = nil                     // nil 대입도 삭제
  print(todos.ids)                       // [2] — 순서 있는 id 집합(OrderedSet)
  print(todos[0].title)                  // 인덱스 접근도 그대로 된다
}

@Reducer
struct TodoRow {
  @ObservableState
  struct State: Equatable, Identifiable {
    let id: Int
    var title = ""
    var isDone = false
    var isSyncing = false
  }
  enum Action {
    case checkboxTapped
    case titleChanged(String)
    case syncButtonTapped
    case syncFinished
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .checkboxTapped:
        state.isDone.toggle()
        return .none
      case let .titleChanged(title):
        state.title = title
        return .none
      case .syncButtonTapped:
        state.isSyncing = true
        return .run { send in
          try await Task.sleep(for: .seconds(1))
          await send(.syncFinished)
        }
      case .syncFinished:
        state.isSyncing = false
        return .none
      }
    }
  }
}

@Reducer
struct TodoList {
  @ObservableState
  struct State: Equatable {
    var rows: IdentifiedArrayOf<TodoRow.State> = []
    var nextID = 0
  }
  enum Action {
    case addButtonTapped
    case delete(IndexSet)
    case move(IndexSet, Int)
    case rows(IdentifiedActionOf<TodoRow>)
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .addButtonTapped:
        state.rows.append(TodoRow.State(id: state.nextID))
        state.nextID += 1
        return .none
      case let .delete(offsets):
        state.rows.remove(atOffsets: offsets)
        return .none
      case let .move(source, destination):
        state.rows.move(fromOffsets: source, toOffset: destination)
        return .none
      case .rows(.element(id: _, action: .checkboxTapped)):
        // 행이 먼저 isDone을 바꾼 뒤 부모가 본다 → 완료 항목을 아래로
        state.rows.sort { !$0.isDone && $1.isDone }
        return .none
      case .rows:
        return .none
      }
    }
    .forEach(\.rows, action: \.rows) {
      TodoRow()
    }
  }
}

func actionShape() {
  let action: TodoList.Action = .rows(.element(id: 3, action: .checkboxTapped))
  // 테스트에서는 case key path로: \.rows[id: 3].checkboxTapped
  _ = action
}

struct State {
  var rows: [TodoRow.State] = []      // IdentifiedArray가 아니다
}
// .forEach(\.rows, action: \.rows) { TodoRow() }
// → forEach는 WritableKeyPath<State, IdentifiedArray<ID, Element>>만 받는다

struct TodoRowView: View {
  @Bindable var store: StoreOf<TodoRow>
  var body: some View {
    HStack {
      Button { store.send(.checkboxTapped) } label: {
        Image(systemName: store.isDone ? "checkmark.square" : "square")
      }
      .buttonStyle(.plain)
      TextField("할 일", text: $store.title.sending(\.titleChanged))
      if store.isSyncing { ProgressView() }
      else { Button("동기화") { store.send(.syncButtonTapped) } }
    }
  }
}

struct TodoListView: View {
  let store: StoreOf<TodoList>
  var body: some View {
    List {
      ForEach(store.scope(\.rows, action: \.rows)) { rowStore in
        TodoRowView(store: rowStore)
      }
      .onDelete { store.send(.delete($0)) }
      .onMove { store.send(.move($0, $1)) }
    }
    .toolbar {
      Button("추가") { store.send(.addButtonTapped) }
    }
  }
}

struct TodoListModelView: View {
  @Bindable var model: TodoListModel
  var body: some View {
    List {
      ForEach($model.items) { $item in
        HStack {
          Toggle("", isOn: $item.isDone).labelsHidden()
          TextField("할 일", text: $item.title)
          Button("동기화") { Task { await model.sync(id: item.id) } }
        }
      }
      .onDelete { model.items.remove(atOffsets: $0) }
    }
  }
}

case let .delete(offsets):
  // 화면: [B, D] (완료 안 된 것만)   전체: [A✓, B, C✓, D]
  // offsets = [0] → 화면의 B를 지우려 했지만 전체의 A가 지워진다
  state.rows.remove(atOffsets: offsets)
  return .none

extension TodoList.State {
  var remaining: IdentifiedArrayOf<TodoRow.State> {
    rows.filter { !$0.isDone }
  }
  mutating func deleteRemaining(at offsets: IndexSet) {
    let visible = remaining
    for index in offsets {
      rows.remove(id: visible[index].id)
    }
  }
}

@Reducer
struct Folder {
  @ObservableState
  struct State: Equatable, Identifiable {
    let id: Int
    var name = ""
    var children: IdentifiedArrayOf<State> = []
  }
  enum Action {
    case addChildTapped(id: Int)
    indirect case children(IdentifiedActionOf<Folder>)   // 재귀 enum이라 indirect
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .addChildTapped(id):
        state.children.append(State(id: id))
        return .none
      case .children:
        return .none
      }
    }
    .forEach(\.children, action: \.children) {
      Self()                                            // 자식도 Folder
    }
  }
}

struct FolderView: View {
  let store: StoreOf<Folder>
  var body: some View {
    List {
      ForEach(store.scope(\.children, action: \.children)) { child in
        NavigationLink(child.name.isEmpty ? "새 폴더" : child.name) {
          FolderView(store: child)                      // 뷰도 재귀
        }
      }
    }
  }
}