import SwiftUI

struct SheetGrid: View {
  @Bindable var model: SheetModel
  @State private var editing: Coordinate?
  @State private var resizing: SheetResizePreview?
  @State private var savingResize = false
  @GestureState private var draggingResize = false
  @FocusState private var focused: Bool
  var beginEditing: () -> Void = {}
  var body: some View {
    ScrollView([.horizontal, .vertical]) {
      LazyVStack(spacing: 0, pinnedViews: [.sectionHeaders]) {
        Section {
          ForEach(0..<model.rows, id: \.self) { row in
            HStack(spacing: 0) {
              ZStack(alignment: .bottom) {
                Button { selectRow(row) } label: {
                  Text(String(row + 1)).frame(width: 48, height: height(row)).background(.quaternary)
                }.buttonStyle(.plain).accessibilityLabel(String(format: sheetsMacString("Select row %d"), row + 1))
                #if os(macOS)
                resizeHandle(axis: "row", index: row).frame(width: 48, height: 8)
                #else
                Color.clear.frame(width: 48, height: 8)
                  .contentShape(.rect).gesture(resizeGesture(axis: "row", index: row))
                  .accessibilityHidden(true)
                #endif
              }
              ForEach(0..<model.cols, id: \.self) { col in
                SheetCell(
                  model: model, point: Coordinate(r: row, c: col), editing: $editing,
                  select: { select(Coordinate(r: row, c: col)) },
                  beginEditing: { edit(Coordinate(r: row, c: col)) },
                  endEditing: { editing = nil; focused = true },
                  columnWidth: width(col), rowHeight: height(row))
              }
            }
          }
        } header: {
          HStack(spacing: 0) {
            Text("").frame(width: 48, height: 32)
            ForEach(0..<model.cols, id: \.self) { col in
              ZStack(alignment: .trailing) {
                Button { selectColumn(col) } label: {
                  Text(Coordinate(r: 0, c: col).ref.dropLast())
                    .frame(width: width(col), height: 32)
                    .contentShape(.rect)
                }.buttonStyle(.plain)
                  .accessibilityLabel(String(format: sheetsMacString("Select column %@"), String(Coordinate(r: 0, c: col).ref.dropLast())))
                #if os(macOS)
                resizeHandle(axis: "col", index: col).frame(width: 8, height: 32)
                  .help(sheetsMacString("Double-click to fit column to contents"))
                #else
                Color.clear.frame(width: 8, height: 32)
                #endif
              }
              #if os(macOS)
              .contextMenu { Button(sheetsMacString("Fit column to contents")) { Task { await model.fitColumn(col) } } }
              #endif
            }
          }.background(.regularMaterial)
        }
      }
    }.defaultScrollAnchor(.topLeading)
      .accessibilityLabel("Spreadsheet grid")
      .focusable()
      .focusEffectDisabled()
      .focused($focused)
      .background { SheetSelectionObserver(model: model, editing: $editing) }
      .onChange(of: focused) { _, value in model.gridFocused = value }
      .onDisappear { model.gridFocused = false; if !savingResize { resizing = nil } }
      .onChange(of: draggingResize) { _, active in
        if !active, !savingResize { resizing = nil }
      }
      .onKeyPress(.leftArrow) { move(0, -1) }
      .onKeyPress(.rightArrow) { move(0, 1) }
      .onKeyPress(.upArrow) { move(-1, 0) }
      .onKeyPress(.downArrow) { move(1, 0) }
      .onKeyPress(.delete) {
        guard editing == nil, model.mayWrite else { return .ignored }
        Task { await model.clear() }
        return .handled
      }
      .onKeyPress(.return) {
        guard editing == nil, model.mayWrite else { return .ignored }
        edit(model.selection.start)
        return .handled
      }
      .onKeyPress(characters: .alphanumerics.union(.punctuationCharacters).union(.symbols).union(.whitespaces)) {
        press in
        guard model.mayWrite, !model.busy, !press.characters.contains(where: { $0 == "\t" || $0.isNewline }),
          press.modifiers.intersection([.command, .control, .option]).isEmpty
        else { return .ignored }
        if editing != nil {
          // Events arriving before the cell's native field gains focus still
          // belong to this edit. Once focused, NSTextField handles them itself.
          model.draft += press.characters
        } else {
          guard !model.hasUnconfirmedChanges else { return .ignored }
          model.draft = press.characters
          edit(model.selection.start)
        }
        return .handled
      }
  }
  private func edit(_ point: Coordinate) {
    guard model.mayWrite, !model.busy, model.failedWrites.isEmpty else { return }
    #if os(macOS)
    editing = point
    #else
    beginEditing()
    #endif
  }
  private func select(_ point: Coordinate) {
    guard !model.busy else { return }
    if model.hasUnconfirmedChanges {
      Task {
        await model.saveAll()
        guard !model.hasUnconfirmedChanges, !model.busy else { return }
        editing = nil; model.select(point); focused = true
      }
    } else {
      if editing != point { editing = nil }
      model.select(point)
      focused = true
    }
  }
  private func selectRow(_ row: Int) {
    guard !model.hasUnconfirmedChanges, !model.busy else { return }
    editing = nil
    model.rangeText = "A\(row + 1):" + Coordinate(r: row, c: model.cols - 1).ref
    model.selectRange()
    focused = true
  }
  private func selectColumn(_ col: Int) {
    guard !model.hasUnconfirmedChanges, !model.busy else { return }
    editing = nil
    model.rangeText = Coordinate(r: 0, c: col).ref + ":" + Coordinate(r: model.rows - 1, c: col).ref
    model.selectRange()
    focused = true
  }
  private func move(_ r: Int, _ c: Int) -> KeyPress.Result {
    guard editing == nil else { return .ignored }
    let p = model.selection.start
    model.select(
      Coordinate(r: max(0, min(model.rows - 1, p.r + r)), c: max(0, min(model.cols - 1, p.c + c))))
    return .handled
  }
  private func width(_ col: Int) -> Double {
    if let resizing, resizing.axis == "col", resizing.index == col { return resizing.size }
    return model.sizes.cols?[String(col)] ?? 110
  }
  private func height(_ row: Int) -> Double {
    if let resizing, resizing.axis == "row", resizing.index == row { return resizing.size }
    return model.sizes.rows?[String(row)] ?? 32
  }
  #if os(macOS)
  private func resizeHandle(axis: String, index: Int) -> some View {
    SheetResizeHandle(vertical: axis == "row",
      canBegin: { model.mayWrite && !model.busy && !model.hasUnconfirmedChanges && !savingResize },
      change: { translation in
        if resizing == nil {
          resizing = SheetResizePreview(axis: axis, index: index,
            original: axis == "col" ? width(index) : height(index))
        }
        resizing?.update(translation: translation)
      }, finish: { finishResize(axis: axis, index: index) },
      cancel: { if !savingResize { resizing = nil } },
      fit: axis == "col" ? { Task { await model.fitColumn(index) } } : nil)

  }
  #endif
  private func finishResize(axis: String, index: Int) {
    guard let preview = resizing, preview.axis == axis, preview.index == index else { return }
    savingResize = true
    Task {
      await model.resize(axis: axis, size: Int(preview.size), index: index)
      resizing = nil
      savingResize = false
    }
  }
  private func resizeGesture(axis: String, index: Int) -> some Gesture {
    DragGesture(minimumDistance: 2, coordinateSpace: .global)
      .updating($draggingResize) { _, active, _ in active = true }
      .onChanged { value in
        guard model.mayWrite, !model.busy, !model.hasUnconfirmedChanges else { return }
        if resizing == nil {
          resizing = SheetResizePreview(axis: axis, index: index,
            original: axis == "col" ? width(index) : height(index))
        }
        guard resizing?.axis == axis, resizing?.index == index else { return }
        resizing?.update(translation: axis == "col" ? value.translation.width : value.translation.height)
      }
      .onEnded { _ in finishResize(axis: axis, index: index) }
  }
}

/// Observe selection in a leaf, so moving between cells does not invalidate the
/// LazyVStack and every row's view construction.
private struct SheetSelectionObserver: View {
  let model: SheetModel
  @Binding var editing: Coordinate?
  var body: some View {
    Color.clear.frame(width: 0, height: 0)
      .onChange(of: model.selection.start) { _, point in
        if editing != point { editing = nil }
      }
  }
}

struct SheetResizePreview {
  let axis: String
  let index: Int
  let original: Double
  var size: Double
  init(axis: String, index: Int, original: Double) {
    self.axis = axis; self.index = index; self.original = original; self.size = original
  }
  mutating func update(translation: Double) {
    size = min(2000, max(16, (original + translation).rounded()))
  }
}