import XCTest
import CoreGraphics
@testable import LChatCore

// 🤖 Pins the CGImage adaptation of the reference BlurHash (woltapp/blurhash's
// Swift files are UIImage-only and copy-in by design — no package): structure,
// round-trip colour fidelity, and malformed-hash rejection. A DCT port's bugs
// are subtle; these tests are the confidence the adaptation didn't drift.
final class BlurhashTests: XCTestCase {
    private func solid(_ r: CGFloat, _ g: CGFloat, _ b: CGFloat,
                       w: Int = 32, h: Int = 24) -> CGImage {
        let cs = CGColorSpaceCreateDeviceRGB()
        let ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8,
                            bytesPerRow: w * 4, space: cs,
                            bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)!
        // Components in the context's OWN space — the CGColor(red:green:blue:)
        // convenience creates a generic-space colour that CG converts on draw
        // (0.3 arrived as 0.405), which read as a codec bug.
        ctx.setFillColor(CGColor(colorSpace: cs, components: [r, g, b, 1])!)
        ctx.fill(CGRect(x: 0, y: 0, width: w, height: h))
        return ctx.makeImage()!
    }

    private func averageRGB(_ image: CGImage) -> (Double, Double, Double) {
        let w = image.width, h = image.height
        var data = [UInt8](repeating: 0, count: w * h * 4)
        let cs = CGColorSpaceCreateDeviceRGB()
        let ctx = CGContext(data: &data, width: w, height: h, bitsPerComponent: 8,
                            bytesPerRow: w * 4, space: cs,
                            bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)!
        ctx.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))
        var r = 0.0, g = 0.0, b = 0.0
        for i in stride(from: 0, to: data.count, by: 4) {
            r += Double(data[i]); g += Double(data[i + 1]); b += Double(data[i + 2])
        }
        let n = Double(w * h)
        return (r / n, g / n, b / n)
    }

    func testHashShape() throws {
        let hash = try XCTUnwrap(Blurhash.encode(solid(0.8, 0.3, 0.2)))
        // 4×3 components: 1 (size) + 1 (max AC) + 4 (DC) + 2×11 (AC) = 28 chars.
        XCTAssertEqual(hash.count, 28)
    }

    // The shared vector grid: 8×6 RGBA, red ramps left→right, green top→bottom,
    // blue fixed at 64 — keep IDENTICAL to vectorGrid() in test/blurhash.test.mjs.
    private func vectorImage() -> CGImage {
        let w = 8, h = 6
        var px = [UInt8](repeating: 0, count: w * h * 4)
        for y in 0..<h {
            for x in 0..<w {
                let o = (y * w + x) * 4
                px[o] = UInt8((x * 255 + (w - 1) / 2) / (w - 1))
                px[o + 1] = UInt8((y * 255 + (h - 1) / 2) / (h - 1))
                px[o + 2] = 64
                px[o + 3] = 255
            }
        }
        let cs = CGColorSpaceCreateDeviceRGB()
        let provider = CGDataProvider(data: Data(px) as CFData)!
        return CGImage(width: w, height: h, bitsPerComponent: 8, bitsPerPixel: 32,
                       bytesPerRow: w * 4, space: cs,
                       bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.noneSkipLast.rawValue),
                       provider: provider, decode: nil, shouldInterpolate: false,
                       intent: .defaultIntent)!
    }

    func testCrossImplementationVector() throws {
        // The one true hash for the vector grid — test/blurhash.test.mjs pins
        // the same string. A change here without the twin is a platform drift.
        XCTAssertEqual(try XCTUnwrap(Blurhash.encode(vectorImage())),
                       "LyI5d=39a|%0z2NKfQnSeXf7fQf7")
    }

    func testRoundTripPreservesColour() throws {
        for (r, g, b) in [(1.0, 0.2, 0.2), (0.1, 0.7, 0.3), (0.2, 0.3, 0.9)] {
            let hash = try XCTUnwrap(Blurhash.encode(solid(r, g, b)))
            let decoded = try XCTUnwrap(Blurhash.decode(hash))
            let avg = averageRGB(decoded)
            XCTAssertEqual(avg.0 / 255, r, accuracy: 0.06, "red channel for \(hash)")
            XCTAssertEqual(avg.1 / 255, g, accuracy: 0.06, "green channel for \(hash)")
            XCTAssertEqual(avg.2 / 255, b, accuracy: 0.06, "blue channel for \(hash)")
        }
    }

    func testGradientRoundTripKeepsOrientation() throws {
        // Left-red, right-blue: the decode must keep the gradient's direction.
        let w = 32, h = 24
        let cs = CGColorSpaceCreateDeviceRGB()
        let ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8,
                            bytesPerRow: w * 4, space: cs,
                            bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)!
        ctx.setFillColor(CGColor(colorSpace: cs, components: [1, 0, 0, 1])!)
        ctx.fill(CGRect(x: 0, y: 0, width: w / 2, height: h))
        ctx.setFillColor(CGColor(colorSpace: cs, components: [0, 0, 1, 1])!)
        ctx.fill(CGRect(x: w / 2, y: 0, width: w / 2, height: h))
        let hash = try XCTUnwrap(Blurhash.encode(ctx.makeImage()!))
        let decoded = try XCTUnwrap(Blurhash.decode(hash, width: 32, height: 24))
        var left = [UInt8](repeating: 0, count: 4), right = left
        let dctx = { (px: Int, out: inout [UInt8]) in
            let c = CGContext(data: &out, width: 1, height: 1, bitsPerComponent: 8,
                              bytesPerRow: 4, space: cs,
                              bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)!
            c.draw(decoded, in: CGRect(x: -px, y: 0, width: 32, height: 24))
        }
        dctx(2, &left)
        dctx(29, &right)
        XCTAssertGreaterThan(left[0], left[2], "left edge reads red")
        XCTAssertGreaterThan(right[2], right[0], "right edge reads blue")
    }

    func testMalformedHashesRejected() {
        XCTAssertNil(Blurhash.decode(""))
        XCTAssertNil(Blurhash.decode("LEHV6"))                 // truncated
        XCTAssertNil(Blurhash.decode("LEHV6nWB2yk8pyo0adR*.7kCMdnj!!")) // wrong length
        XCTAssertNil(Blurhash.decode(String(repeating: "\u{1F600}", count: 28))) // non-base83
    }
}