import XCTest
@testable import LChatCore

// 🤖 The shared avatar-thumbnail cache the notification extension reads to put
// a sender's face on a banner. Network-free: sync's fetch path is exercised
// only for entries whose source marker is stale, so the tests drive the
// skip/remove/roundtrip contract with seeded files and unreachable URLs.
final class SharedAvatarCacheTests: XCTestCase {
    private var dir: URL!

    override func setUp() {
        super.setUp()
        dir = FileManager.default.temporaryDirectory
            .appendingPathComponent("avatar-cache-tests-\(UUID().uuidString)", isDirectory: true)
        SharedAvatarCache.directoryOverride = dir
    }

    override func tearDown() {
        SharedAvatarCache.directoryOverride = nil
        try? FileManager.default.removeItem(at: dir)
        super.tearDown()
    }

    private func source(blobID: String) -> AvatarSource {
        // .1 is reserved/unroutable → any fetch attempt fails fast.
        AvatarSource(blobID: blobID, keyB64: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
                     baseURL: URL(string: "http://192.0.2.1")!, token: "t")
    }

    func testStoreThenReadRoundtrip() {
        let jpeg = Data([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3])
        SharedAvatarCache.store(jpeg: jpeg, blobID: "b1", origin: "https://a.example", uid: "u1")
        XCTAssertEqual(SharedAvatarCache.imageData(origin: "https://a.example", uid: "u1"), jpeg)
        // Same uid on another instance is a different person — different slot.
        XCTAssertNil(SharedAvatarCache.imageData(origin: "https://b.example", uid: "u1"))
    }

    func testStemIsFilesystemSafeAndDistinct() {
        let a = SharedAvatarCache.fileStem(origin: "https://a.example", uid: "u/1")
        let b = SharedAvatarCache.fileStem(origin: "https://b.example", uid: "u/1")
        XCTAssertNotEqual(a, b)
        XCTAssertTrue(a.allSatisfy(\.isHexDigit))
        XCTAssertEqual(a, SharedAvatarCache.fileStem(origin: "https://a.example", uid: "u/1"))
    }

    func testSyncKeepsUnchangedEntryWithoutFetching() async {
        let jpeg = Data([9, 9, 9])
        SharedAvatarCache.store(jpeg: jpeg, blobID: "b1", origin: "o", uid: "u1")
        // Marker matches the stored blob → sync must not touch the file (a
        // fetch would fail against the unroutable host and drop it).
        await SharedAvatarCache.sync(origin: "o", avatars: [("u1", source(blobID: "b1"))])
        XCTAssertEqual(SharedAvatarCache.imageData(origin: "o", uid: "u1"), jpeg)
    }

    func testSyncKeepsStaleThumbnailWhenFetchFails() async {
        let jpeg = Data([9, 9, 9])
        SharedAvatarCache.store(jpeg: jpeg, blobID: "old", origin: "o", uid: "u1")
        // Photo changed but the refetch fails → the old face beats no face.
        await SharedAvatarCache.sync(origin: "o", avatars: [("u1", source(blobID: "new"))])
        XCTAssertEqual(SharedAvatarCache.imageData(origin: "o", uid: "u1"), jpeg)
    }

    func testSyncRemovesEntryWhenPhotoCleared() async {
        SharedAvatarCache.store(jpeg: Data([1]), blobID: "b1", origin: "o", uid: "u1")
        await SharedAvatarCache.sync(origin: "o", avatars: [("u1", nil)])
        XCTAssertNil(SharedAvatarCache.imageData(origin: "o", uid: "u1"))
    }
}