package com.peachpasswords.codex

import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
import java.io.File
import java.io.FileOutputStream

/**
 * End-to-end regression test for the Codex PDF round trip: render a page of
 * Aztec codes to PDF bytes, write them to disk, then decode the same file
 * back via [CodexRestore] exactly as the real restore flow does (SAF-style
 * file URI, [android.graphics.pdf.PdfRenderer], per-cell crop). This is the
 * real bug surface: the data-layer (compression, Reed-Solomon, envelope
 * integrity) already has coverage in [CodexSuiteTest], but nothing previously
 * exercised the actual PDF render → rasterize → decode pipeline, which is
 * exactly where the bug lived (PdfDocument's raster bitmap embedding
 * corrupted crisp module edges, and 640px crop resolution was independently
 * too low once codes needed more than a couple of Aztec layers).
 */
@RunWith(AndroidJUnit4::class)
class CodexPdfRoundTripTest {

    @Test
    fun pdfRoundTripDecodesAllCodesAtRealisticScale() {
        val context = InstrumentationRegistry.getInstrumentation().targetContext

        // ~75 envelopes: matches the code count a real multi-hundred-entry
        // vault's Codex produces. Pseudo-random filler (not a single repeated
        // character) so deflate can't collapse it to a trivial size.
        val filler = StringBuilder()
        val rnd = java.util.Random(42)
        repeat(36000) { filler.append(('a' + rnd.nextInt(26))) }
        val fakePayload = CodexPayload(
            verifyCode = "PX-TEST-0000",
            vaultBlob = filler.toString(),
            timestamp = 0L,
            entryCount = 1,
            vaultFingerprint = CodexCodec.sha256Hex(filler.toString().toByteArray(Charsets.UTF_8)).take(32),
            generatedAt = 0L,
        )
        val payloadJson = CodexCodec.json.encodeToString(CodexPayload.serializer(), fakePayload)
        val compressed = CodexCodec.deflate(payloadJson.toByteArray(Charsets.UTF_8))
        val (envelopes, layout) = CodexCodec.encodeToEnvelopes(compressed, "PX-TEST-0000")

        val aztecs = envelopes.map { env ->
            val jsonStr = CodexCodec.json.encodeToString(ChunkEnvelope.serializer(), env)
            CodexAztec.encodeMatrix(jsonStr)
        }

        val manifest = CodexManifest(
            verifyCode = "PX-TEST-0000",
            totalChunks = layout.totalChunks,
            dataChunks = layout.dataChunks,
            parityChunks = layout.parityChunks,
            stripeCount = layout.stripeCount,
            pageCount = Math.ceil(layout.totalChunks.toDouble() / CODES_PER_PAGE).toInt(),
            entryCount = 1,
            vaultFingerprint = "test",
            generatedAt = 0L,
        )
        val pdfBytes = CodexPdf.render(aztecs, manifest)

        val pdfFile = File(context.cacheDir, "roundtrip_test.pdf")
        FileOutputStream(pdfFile).use { it.write(pdfBytes) }
        val uri = android.net.Uri.fromFile(pdfFile)

        val result = CodexRestore.decodeFromUri(context, uri)
        assertEquals(
            "Every generated code should decode back out of the rendered PDF",
            envelopes.size,
            result.envelopes.size,
        )

        val payload = CodexRestore.reconstructPayload(result.envelopes)
        assertEquals("PX-TEST-0000", payload.verifyCode)
        assertEquals(fakePayload.vaultBlob, payload.vaultBlob)
        assertEquals(fakePayload.vaultFingerprint, payload.vaultFingerprint)
    }
}