먼저 간직하고, 나중에 보내

struct CapturePayload: Codable, Equatable, Sendable {
    var momentId: String
    var kind: String
    var capture: CaptureTruth
    var situation: String?
    var text: String?
    var place: PlaceSample?
    var pippaFile: String?
    var pippaMediaId: String?
    var originalFile: String?
    var originalMediaId: String?
    var originalFilename: String?
    var originalContentType: String?
    var lines: [VisionLine]
    var practicalRequestId: String
    /// A text kept for high-quality work: no practical reading is asked.
    /// Optional so entries queued before it existed still decode.
    var skipsReading: Bool?
    /// A document (a shared PDF, a Word file): after the original is up,
    /// the engine reads it into the moment's text (step 6).
    var readsOriginalAsText: Bool?
    /// A crumb sent here from Waystone or Vesta: the moment arrives linked
    /// to it. Optional so entries queued before it existed still decode.
    var links: [ItemRef]?
    /// How far the send got: each step is idempotent, and a step already
    /// done is not repeated (the original is the heavy one).
    var done: Set<Step> = []

    enum Step: String, Codable, Sendable {
        case moment, copy, turn, original, text
    }
}

    /// Keep a photo on this device, then try the engine. The moment is safe
    /// the moment this returns without throwing; its id is final already.
    @discardableResult
    func capture(photo: PreparedPhoto, situation: Situation, place: PlaceSample?,
                 momentId: String = ULID.mint(), otherwise truth: CaptureTruth? = nil,
                 entryId: String = ClientRequestId.mint(prefix: "moment-"), links: [ItemRef]? = nil) async throws -> String {
        let capture = Self.truth(takenAt: photo.takenAt, otherwise: truth)
        // A camera still carries no metadata of its own; the moment's truth
        // fills it, on the original and on the copy Pippa reads (todo #590).
        var photo = photo
        photo.original = PhotoMetadata.filled(photo.original, capturedAt: capture.capturedAt, place: place)
        photo.forPippa = PhotoMetadata.filled(photo.forPippa, capturedAt: capture.capturedAt, place: place)
        let payload = CapturePayload(
            momentId: momentId,
            kind: "photo",
            capture: capture,
            situation: situation.rawValue,
            place: place,
            pippaMediaId: ULID.mint(),
            originalMediaId: ULID.mint(),
            originalFilename: photo.originalFilename,
            originalContentType: photo.originalContentType,
            lines: photo.lines,
            practicalRequestId: ClientRequestId.mint(prefix: "practical-"),
            links: links)
        _ = try await outbox.enqueue(payload, photo: photo, entryId: entryId)
        settings.situation = situation
        queued = await outbox.unsent
        Task { await drain() }
        return momentId
    }

    func testTheSendGoesMomentCopyTurnOriginalAndSkipsWhatIsDone() async throws {
        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
        defer { try? FileManager.default.removeItem(at: directory) }
        let outbox = MomentOutbox(directory: directory)
        let photo = PreparedPhoto(original: Data("original".utf8), originalFilename: "IMG_1.HEIC",
                                  originalContentType: "image/heic", forPippa: Data("copy".utf8),
                                  lines: [], takenAt: nil)
        let payload = CapturePayload(momentId: Self.momentId, kind: "photo", capture: CaptureTruth.now(),
                                     situation: "restaurant", pippaMediaId: "COPY", originalMediaId: "ORIGINAL",
                                     originalFilename: "IMG_1.HEIC", originalContentType: "image/heic",
                                     lines: [], practicalRequestId: "practical-abc12345")
        let entry = try await outbox.enqueue(payload, photo: photo)

        let media: [String: Any] = ["media_id": "M", "moment_id": Self.momentId, "filename": "f", "url": "/u", "role": "r"]
        let scripted = ScriptedHTTPTransport(replies: [
            ScriptedHTTPTransport.json(["moment": Self.momentJSON()]),
            ScriptedHTTPTransport.json(["media": media]),
            ScriptedHTTPTransport.json(["detail": "Spark's brain is not reachable"], status: 503),
        ])
        do {
            _ = try await client(scripted).send(entry, outbox: outbox, label: "Menu")
            XCTFail("a 503 must leave the entry for the next pass")
        } catch let failure as OutboxFailure {
            XCTAssertFalse(failure.isPermanent)
        }
        XCTAssertEqual(scripted.calls.map(\.path), [
            "/api/moments", "/api/moments/\(Self.momentId)/media/COPY", "/api/moments/\(Self.momentId)/practical",
        ])

        // The next pass skips the moment and the copy it already sent.
        let again = try await XCTUnwrapAsync(await outbox.entry(momentId: Self.momentId))
        XCTAssertEqual(again.payload.done, [.moment, .copy])
        let retry = ScriptedHTTPTransport(replies: [
            ScriptedHTTPTransport.json(["turn": ["id": "t1", "status": "running"]]),
            ScriptedHTTPTransport.json(["media": media]),
        ])
        let sent = try await client(retry).send(again, outbox: outbox, label: "Menu")
        XCTAssertEqual(sent, Self.momentId)
        XCTAssertEqual(retry.calls.map(\.path), [
            "/api/moments/\(Self.momentId)/practical", "/api/moments/\(Self.momentId)/media/ORIGINAL",
        ])
        XCTAssertEqual(retry.calls.last?.query, "role=original&filename=IMG_1.HEIC")
        XCTAssertEqual(retry.calls.last?.headers["Content-Type"], "image/heic")
    }