한 줄에 목소리는 하나

// A minimal sketch of the all-or-nothing rule Pathfinder's VoicePlayer
// follows: a line plays in Pippa's voice only if EVERY chunk is cached;
// otherwise the whole line goes to the system voice, and the missing
// chunks are reported so they can be fetched for next time.
struct Chunk: Hashable { let text: String }

enum Decision {
  case pippa(takes: [String])
  case systemVoice(line: String, missing: [Chunk])
}

func decide(_ line: [Chunk], cache: [Chunk: String]) -> Decision {
  var takes: [String] = []
  for chunk in line {
    guard let take = cache[chunk] else {
      // One gap is enough: never half Pippa, half the system voice.
      var seen = Set<Chunk>()
      let missing = line.filter { cache[$0] == nil && seen.insert($0).inserted }
      return .systemVoice(line: line.map(\.text).joined(separator: " "), missing: missing)
    }
    takes.append(take)
  }
  return .pippa(takes: takes)
}

func describe(_ decision: Decision) -> String {
  switch decision {
  case .pippa(let takes): return "PIPPA   " + takes.joined(separator: " + ")
  case .systemVoice(let line, let missing):
    return "SYSTEM  \"\(line)\"  (fetch: \(missing.map(\.text).joined(separator: ", ")))"
  }
}

// The closed vocabulary is cached before the first drive; road names are not.
var cache: [Chunk: String] = [:]
for phrase in ["300미터 앞", "회전교차로에서", "두 번째 출구로 나가서", "들어가", "잠시 후", "좌회전해"] {
  cache[Chunk(text: phrase)] = "\(phrase).mp3"
}

let line = ["300미터 앞", "회전교차로에서", "두 번째 출구로 나가서", "Calle de Alcalá로", "들어가"].map(Chunk.init)
print(describe(decide(line, cache: cache)))

// The prefetcher fetches the reported chunk; the next time, the same line is hers.
cache[Chunk(text: "Calle de Alcalá로")] = "Calle de Alcalá로.mp3"
print(describe(decide(line, cache: cache)))

// Output:
// SYSTEM  "300미터 앞 회전교차로에서 두 번째 출구로 나가서 Calle de Alcalá로 들어가"  (fetch: Calle de Alcalá로)
// PIPPA   300미터 앞.mp3 + 회전교차로에서.mp3 + 두 번째 출구로 나가서.mp3 + Calle de Alcalá로.mp3 + 들어가.mp3

  /// Every chunk of a line, or nil when any one is missing — a line is spoken
  /// in one voice, never half Pippa and half the system voice. Use is counted
  /// only for a line that will actually play.
  public func line(_ chunks: [VoiceChunk], voiceID: String) -> [Cached]? {
    var found: [(String, Cached)] = []
    for chunk in chunks {
      guard let hit = peek(chunk, voiceID: voiceID) else { return nil }
      found.append(hit)
    }
    for (key, _) in found { markUsed(key) }
    return found.map(\.1)
  }

  private func start(_ utterance: Utterance) {
    generation += 1
    let ticket = generation
    let wasQuiet = speaking == nil
    speaking = utterance
    if wasQuiet { gate?.guidanceLine(playing: true) }
    activateSession()
    let mode = self.mode
    let voice = voiceID()
    Task { @MainActor in
      if mode == .pippa, let line = await cache.line(utterance.chunks, voiceID: voice) {
        guard ticket == generation else { return }
        if playPippa(line, ticket: ticket) {
          onSpoken?(Outcome(utterance: utterance, pippaVoice: true, missing: []))
          return
        }
      }
      guard ticket == generation else { return }
      let missing = mode == .pippa ? await cache.missing(utterance.chunks, voiceID: voice) : []
      guard ticket == generation else { return }
      speakSystem(utterance)
      onSpoken?(Outcome(utterance: utterance, pippaVoice: false, missing: missing))
    }
  }