주행 기록이 증거야

  public func append(_ event: DriveEvent) {
    if event.kind == .fix, let at = ISO8601DateFormatter.fractional.date(from: event.at) {
      if let lastFixAt, at.timeIntervalSince(lastFixAt) < fixInterval { return }
      lastFixAt = at
    }
    guard var data = try? encoder.encode(event) else { return }
    data.append(0x0A)
    try? handle?.write(contentsOf: data)
  }

import Foundation

// One JSON line per event, written the moment it happens. Fixes are thinned to
// one a second; every other event is always kept. Each line goes to the OS as
// soon as it is encoded, with no buffer in the app, so a crash keeps every line
// written so far. Nothing calls synchronize(), so a sudden power cut is a
// different question that this sketch does not answer.

struct Event: Codable {
  var at: Date
  var kind: String
  var text: String?
}

final class DriveLog {
  let url: URL
  private let handle: FileHandle
  private let encoder = JSONEncoder()
  private var lastFixAt: Date?
  private let fixInterval: TimeInterval = 1

  init(url: URL) throws {
    FileManager.default.createFile(atPath: url.path, contents: nil)
    handle = try FileHandle(forWritingTo: url)
    encoder.dateEncodingStrategy = .secondsSince1970
    encoder.outputFormatting = [.sortedKeys]
    self.url = url
  }

  func append(_ event: Event) {
    if event.kind == "fix" {
      if let lastFixAt, event.at.timeIntervalSince(lastFixAt) < fixInterval { return }
      lastFixAt = event.at
    }
    guard var data = try? encoder.encode(event) else { return }
    data.append(0x0A)
    try? handle.write(contentsOf: data)
  }
}

let start = Date(timeIntervalSince1970: 0)
func at(_ s: Double) -> Date { start.addingTimeInterval(s) }

let url = FileManager.default.temporaryDirectory.appendingPathComponent("drive-sketch.jsonl")
let log = try DriveLog(url: url)
log.append(Event(at: at(0), kind: "start", text: "to the station"))
for s in stride(from: 0.0, through: 6.0, by: 0.4) { log.append(Event(at: at(s), kind: "fix")) }
log.append(Event(at: at(2.0), kind: "spoke", text: "300미터 앞에서 우회전해"))
log.append(Event(at: at(4.4), kind: "off_route", text: "lateral 62 m"))
log.append(Event(at: at(5.1), kind: "reroute"))
log.append(Event(at: at(9.8), kind: "back_on_route"))
// No close() and no synchronize(): read back what the file already holds.
// This shows that nothing waits for a clean close. It is not a crash or a
// power cut; the exercise below kills a real process.

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .secondsSince1970
let lines = try String(contentsOf: url, encoding: .utf8).split(separator: "\n")
let events = lines.compactMap { try? decoder.decode(Event.self, from: Data($0.utf8)) }
let fixes = events.filter { $0.kind == "fix" }.count
print("lines on disk: \(events.count) (fixes kept: \(fixes) of 16 offered)")
if let off = events.first(where: { $0.kind == "off_route" }),
  let back = events.first(where: { $0.kind == "back_on_route" })
{
  print("off the route for", String(format: "%.1f s", back.at.timeIntervalSince(off.at)))
}

// Output:
// lines on disk: 11 (fixes kept: 6 of 16 offered)
// off the route for 5.4 s

  /// A drive's log says when the watch stops hearing the guidance and when
  /// it hears it again (todo #391: in Seville the watch followed nothing and
  /// no record said why). A drive that begins with the watch heard says
  /// nothing.
  private func noteWristTrouble(_ trouble: String?) {
    guard !isSimulating, let log = driveLog else { return }
    let id = ObjectIdentifier(log)
    if let note = wristNote, note.log == id, note.trouble == trouble { return }
    let first = wristNote?.log != id
    wristNote = (id, trouble)
    if first && trouble == nil { return }
    let event = DriveEvent(at: Date(), kind: .note, text: "watch: \(trouble ?? "hears the guidance again")")
    Task { await log.append(event) }
  }