package social.grain

import androidx.test.ext.junit.runners.AndroidJUnit4
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.runBlocking
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import social.grain.data.auth.SecureStore
import social.grain.data.local.Appearance
import social.grain.data.local.AppearanceStore
import social.grain.data.local.FeedCache
import social.grain.data.local.LabelDefinitionsCache
import social.grain.data.local.RecentProfileSearch
import social.grain.data.local.RecentSearchStore
import social.grain.data.local.StoryStatusCache
import social.grain.data.local.ViewedStoryStore
import social.grain.data.model.GrainLabels
import social.grain.data.model.StoryViewerState
import social.grain.support.Fixtures
import social.grain.support.Harness
import social.grain.support.FakeAndroidKeyStore
import social.grain.support.StubServer
import social.grain.support.awaitCall
import social.grain.support.awaitValue
import social.grain.support.appContext
import social.grain.support.awaitCall
import social.grain.support.json
import social.grain.support.testJson
import social.grain.support.xrpc
import java.time.Instant

/**
 * The small on-device stores every screen leans on.
 *
 * Each one exists to answer a question cheaply that the network would answer
 * slowly, so the failures they can have are all of the same shape: a stale or
 * cross-account answer that looks perfectly plausible.
 */
@RunWith(AndroidJUnit4::class)
class LocalStoresTest {

    private lateinit var scope: CoroutineScope

    @Before
    fun setUp() {
        scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
    }

    @After
    fun tearDown() {
        scope.coroutineContext[kotlinx.coroutines.Job]?.cancel()
    }

    // MARK: - SecureStore

    @Test
    fun aSealedValueComesBackOutAndCanBeRemoved() {
        FakeAndroidKeyStore.install()
        val store = SecureStore(appContext)

        store.putString("credential", "hunter2")

        assertEquals(
            "A second store finds the master key the first one made",
            "hunter2",
            SecureStore(appContext).getString("credential"),
        )
        assertTrue(store.contains("credential"))

        store.remove("credential")
        assertNull(store.getString("credential"))
        assertFalse(store.contains("credential"))
    }

    @Test
    fun writingNullIsTheSameAsRemoving() {
        FakeAndroidKeyStore.install()
        val store = SecureStore(appContext)
        store.putString("gone", "value")

        store.putString("gone", null)

        assertNull(store.getString("gone"))
    }

    @Test
    fun rawBytesRoundTripAsWellAsStrings() {
        FakeAndroidKeyStore.install()
        val store = SecureStore(appContext)
        val bytes = byteArrayOf(1, 2, 3, 4, 5)

        store.putBytes("key", bytes)

        assertTrue(bytes.contentEquals(store.getBytes("key")))
        store.remove("key")
    }

    @Test
    fun aValueThatCannotBeDecryptedIsDroppedRatherThanThrowingForever() {
        FakeAndroidKeyStore.install()
        val store = SecureStore(appContext)
        store.putString("corrupt", "value")
        // What a cleared app or a restored device leaves behind: ciphertext
        // that no key on this install can open.
        appContext.getSharedPreferences("social.grain.secure", android.content.Context.MODE_PRIVATE)
            .edit().putString("corrupt", "bm90IGEgY2lwaGVydGV4dA==").commit()

        assertNull(store.getString("corrupt"))
        assertFalse("The unreadable value is swept up on the way past", store.contains("corrupt"))
    }

    // MARK: - FeedCache

    @Test
    fun aCachedFeedComesBackForTheAccountThatFetchedIt() = runBlocking {
        val cache = FeedCache(appContext, testJson)
        cache.activeDid = "did:plc:one"
        cache.save(listOf(Fixtures.gallery(title = "Mine")), "recent")

        assertEquals("Mine", cache.load("recent").single().title)

        cache.activeDid = "did:plc:two"
        assertTrue("Another account must not see it", cache.load("recent").isEmpty())

        cache.activeDid = "did:plc:one"
        cache.purge("did:plc:one")
        assertTrue(cache.load("recent").isEmpty())
    }

    @Test
    fun anEmptyPageIsNotWorthCaching() = runBlocking {
        val cache = FeedCache(appContext, testJson)
        cache.activeDid = "did:plc:empty"
        cache.save(listOf(Fixtures.gallery()), "recent")
        cache.save(emptyList(), "recent")

        assertEquals("An empty save must not wipe what was there", 1, cache.load("recent").size)
        cache.purge("did:plc:empty")
    }

    @Test
    fun feedKeysWithSlashesAndColonsStillNameOneFileEach() = runBlocking {
        val cache = FeedCache(appContext, testJson)
        cache.activeDid = "did:plc:paths"
        cache.save(listOf(Fixtures.gallery(title = "Camera")), "camera:Leica M6")

        assertEquals("Camera", cache.load("camera:Leica M6").single().title)
        cache.purge("did:plc:paths")
    }

    // MARK: - StoryStatusCache

    @Test
    fun anAuthorWithALiveStoryWearsARingUntilItExpires() {
        val cache = StoryStatusCache()
        val now = Instant.parse("2026-03-01T12:00:00Z")
        cache.update(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:alice"),
                    latestAt = "2026-03-01T11:00:00Z",
                ),
            ),
        )

        assertTrue(cache.hasStory("did:plc:alice", now))
        assertNotNull(cache.author("did:plc:alice", now))
        assertEquals(1, cache.liveAuthors(now).size)

        val tomorrow = now.plusSeconds(60 * 60 * 25)
        assertFalse("A day later the story is gone", cache.hasStory("did:plc:alice", tomorrow))
        assertTrue(cache.liveAuthors(tomorrow).isEmpty())
    }

    @Test
    fun anAuthorWithNoStoriesIsNotInTheCacheAtAll() {
        val cache = StoryStatusCache()
        cache.update(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:quiet"),
                    storyCount = 0,
                ),
            ),
        )
        assertFalse(cache.hasStory("did:plc:quiet"))
    }

    @Test
    fun theLiveListIsNewestStoryFirst() {
        val cache = StoryStatusCache()
        val now = Instant.parse("2026-03-01T12:00:00Z")
        cache.update(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:older"),
                    latestAt = "2026-03-01T06:00:00Z",
                ),
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:newer"),
                    latestAt = "2026-03-01T11:00:00Z",
                ),
            ),
        )

        assertEquals("did:plc:newer", cache.liveAuthors(now).first().did)
    }

    @Test
    fun anAuthorCanBeForgottenAndTheWholeCacheCleared() {
        val cache = StoryStatusCache()
        cache.update(
            listOf(
                Fixtures.storyAuthor(profile = Fixtures.profile(did = "did:plc:a")),
                Fixtures.storyAuthor(profile = Fixtures.profile(did = "did:plc:b")),
            ),
        )

        cache.remove("did:plc:a")
        assertFalse(cache.hasStory("did:plc:a"))
        assertTrue(cache.hasStory("did:plc:b"))

        cache.clear()
        assertTrue(cache.statuses.value.entries.isEmpty())
    }

    @Test
    fun expiredEntriesCanBeSweptOut() {
        val cache = StoryStatusCache()
        cache.update(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:old"),
                    latestAt = "2026-03-01T00:00:00Z",
                ),
            ),
        )

        cache.purgeExpired(Instant.parse("2026-03-03T00:00:00Z"))

        assertTrue(cache.statuses.value.entries.isEmpty())
    }

    @Test
    fun anAuthorWithAnUnparseableTimestampNeverCountsAsLive() {
        val cache = StoryStatusCache()
        cache.update(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:bad"),
                    latestAt = "not a date",
                ),
            ),
        )
        assertFalse(cache.hasStory("did:plc:bad"))
    }

    @Test
    fun askingAboutNobodyIsAnswerable() {
        assertFalse(StoryStatusCache().statuses.value.hasStory(null))
        assertNull(StoryStatusCache().statuses.value.author(null))
    }

    // MARK: - ViewedStoryStore

    @Test
    fun watchedStoriesAreRememberedPerAccount() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:one")
        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T10:00:00Z")

        assertTrue(store.isViewed("at://s/1"))
        assertTrue(store.hasViewedAll("did:plc:alice", "2026-03-01T10:00:00Z"))

        store.switchAccount("did:plc:two")
        assertFalse("Another account has watched nothing", store.isViewed("at://s/1"))

        store.switchAccount("did:plc:one")
        assertTrue("Coming back finds it again", store.isViewed("at://s/1"))
    }

    @Test
    fun theHighWaterMarkOnlyEverMovesForward() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:marks")
        store.markViewed("at://s/new", "did:plc:alice", "2026-03-01T12:00:00Z")
        store.markViewed("at://s/old", "did:plc:alice", "2026-03-01T06:00:00Z")

        assertTrue(
            "Rewatching an older story must not un-see a newer one",
            store.hasViewedAll("did:plc:alice", "2026-03-01T12:00:00Z"),
        )
    }

    @Test
    fun anAuthorNeverWatchedIsNotCaughtUp() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:fresh-${System.nanoTime()}")
        assertFalse(store.hasViewedAll("did:plc:stranger", "2026-03-01T12:00:00Z"))
    }

    @Test
    fun theViewerOpensAtTheFirstStoryNotYetWatched() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:resume-${System.nanoTime()}")
        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T10:00:00Z")

        assertEquals(1, store.firstUnviewedIndex(listOf("at://s/1", "at://s/2")))
        assertEquals(
            "A fully watched author replays from the start",
            0,
            store.firstUnviewedIndex(listOf("at://s/1")),
        )
    }

    @Test
    fun watchedMarksOlderThanADayAreSweptOut() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:cleanup-${System.nanoTime()}")
        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T00:00:00Z")

        store.cleanup(Instant.parse("2026-03-03T00:00:00Z"))

        assertFalse(store.hasViewedAll("did:plc:alice", "2026-03-01T00:00:00Z"))
    }

    @Test
    fun watchingSomethingBumpsTheVersionTheRingsWatch() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:version-${System.nanoTime()}")
        val before = store.version.value

        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T10:00:00Z")

        assertTrue(store.version.value > before)
    }

    @Test
    fun theServersHighWaterMarkIsTakenOnAndOnlyEverMovesForward() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:absorb-${System.nanoTime()}")
        store.markViewed("at://s/2", "did:plc:alice", "2026-03-01T12:00:00Z")

        store.absorb(
            listOf(
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:alice"),
                    latestAt = "2026-03-01T12:00:00Z",
                ).copy(lastViewedAt = "2026-03-01T06:00:00Z"),
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:bob"),
                    latestAt = "2026-03-01T09:00:00Z",
                ).copy(lastViewedAt = "2026-03-01T09:00:00Z"),
                Fixtures.storyAuthor(
                    profile = Fixtures.profile(did = "did:plc:carol"),
                    latestAt = "2026-03-01T09:00:00Z",
                ),
            ),
        )

        assertTrue("An older server mark does not un-see alice", store.hasViewedAll("did:plc:alice", "2026-03-01T12:00:00Z"))
        assertTrue("Bob was watched on another device", store.hasViewedAll("did:plc:bob", "2026-03-01T09:00:00Z"))
        assertFalse("Carol carries no mark", store.hasViewedAll("did:plc:carol", "2026-03-01T09:00:00Z"))
        assertEquals("Nothing the server said goes back up to it", 1, store.pendingUploadCount)
    }

    @Test
    fun storiesTheServerFlagsAsWatchedJoinTheSet() {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:flags-${System.nanoTime()}")
        val alice = Fixtures.profile(did = "did:plc:alice")

        store.absorb(
            listOf(
                Fixtures.story(rkey = "s1", creator = alice, createdAt = "2026-03-01T10:00:00Z")
                    .copy(viewer = StoryViewerState(viewed = true)),
                Fixtures.story(rkey = "s2", creator = alice, createdAt = "2026-03-01T11:00:00Z"),
            ),
        )

        assertTrue(store.isViewed("at://did:plc:alice/social.grain.story/s1"))
        assertFalse(store.isViewed("at://did:plc:alice/social.grain.story/s2"))
        assertEquals(
            "The viewer opens on the one not yet watched",
            1,
            store.firstUnviewedIndex(
                listOf("at://did:plc:alice/social.grain.story/s1", "at://did:plc:alice/social.grain.story/s2"),
            ),
        )
        assertFalse(store.hasViewedAll("did:plc:alice", "2026-03-01T11:00:00Z"))
        assertEquals(0, store.pendingUploadCount)
    }

    @Test
    fun watchedStoriesAreReportedAndAFailedReportStaysQueued() = runBlocking {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:report-${System.nanoTime()}")
        val sent = mutableListOf<List<String>>()
        store.uploader = { uris -> throw java.io.IOException("offline") }

        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T10:00:00Z")
        store.markViewed("at://s/2", "did:plc:alice", "2026-03-01T11:00:00Z")
        store.flushPending()

        assertEquals("Both wait for a connection", 2, store.pendingUploadCount)
        assertTrue("Locally they are still watched", store.isViewed("at://s/1"))

        store.uploader = { uris -> sent += uris.sorted() }
        store.flushPending()

        assertEquals(listOf(listOf("at://s/1", "at://s/2")), sent)
        assertEquals(0, store.pendingUploadCount)
    }

    @Test
    fun reportsGoUpInServerSizedBatches() = runBlocking {
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount("did:plc:batches-${System.nanoTime()}")
        val batches = mutableListOf<Int>()
        store.uploader = { uris -> batches += uris.size }
        repeat(150) { store.markViewed("at://s/$it", "did:plc:alice", "2026-03-01T10:00:00Z") }

        store.flushPending()

        assertEquals(listOf(100, 50), batches)
        assertEquals(0, store.pendingUploadCount)
    }

    @Test
    fun theReportQueueSurvivesARelaunch() {
        val did = "did:plc:relaunch-${System.nanoTime()}"
        val store = ViewedStoryStore(appContext, testJson, scope)
        store.switchAccount(did)
        store.markViewed("at://s/1", "did:plc:alice", "2026-03-01T10:00:00Z")

        val relaunched = ViewedStoryStore(appContext, testJson, scope)
        relaunched.switchAccount(did)

        assertEquals(1, relaunched.pendingUploadCount)
    }

    // MARK: - RecentSearchStore

    @Test
    fun recentTermsAreDedupedCaseInsensitivelyAndMostRecentFirst() {
        val store = RecentSearchStore(appContext, testJson)
        store.switchAccount("did:plc:terms-${System.nanoTime()}")

        store.addTerm("fog")
        store.addTerm("mist")
        store.addTerm("  FOG  ")

        assertEquals(listOf("FOG", "mist"), store.terms)
    }

    @Test
    fun anEmptyTermIsNotRemembered() {
        val store = RecentSearchStore(appContext, testJson)
        store.switchAccount("did:plc:blank-${System.nanoTime()}")
        store.addTerm("   ")
        assertTrue(store.terms.isEmpty())
    }

    @Test
    fun recentProfilesAreDedupedByDidAndCapped() {
        val store = RecentSearchStore(appContext, testJson)
        store.switchAccount("did:plc:profiles-${System.nanoTime()}")

        repeat(12) { index ->
            store.addProfile(RecentProfileSearch(did = "did:plc:p$index", handle = "p$index"))
        }
        store.addProfile(RecentProfileSearch(did = "did:plc:p0", handle = "p0-again"))

        assertEquals(10, store.profiles.size)
        assertEquals("did:plc:p0", store.profiles.first().did)
        assertEquals(1, store.profiles.count { it.did == "did:plc:p0" })
    }

    @Test
    fun recentsAreRemovableOneAtATimeAndAllAtOnce() {
        val store = RecentSearchStore(appContext, testJson)
        store.switchAccount("did:plc:remove-${System.nanoTime()}")
        store.addTerm("fog")
        store.addProfile(RecentProfileSearch(did = "did:plc:bob"))

        store.removeTerm("fog")
        store.removeProfile("did:plc:bob")
        assertTrue(store.terms.isEmpty())
        assertTrue(store.profiles.isEmpty())

        store.addTerm("mist")
        store.clear()
        assertTrue(store.terms.isEmpty())
    }

    @Test
    fun searchHistoryDoesNotCrossAccounts() {
        val store = RecentSearchStore(appContext, testJson)
        val one = "did:plc:hist-a-${System.nanoTime()}"
        val two = "did:plc:hist-b-${System.nanoTime()}"
        store.switchAccount(one)
        store.addTerm("private")

        store.switchAccount(two)
        assertTrue(store.terms.isEmpty())

        store.switchAccount(one)
        assertEquals(listOf("private"), store.terms)
        store.clear()
    }

    // MARK: - AppearanceStore

    @Test
    fun theAppearanceChoiceSurvivesANewStore() {
        AppearanceStore(appContext).set(Appearance.DARK)
        assertEquals(Appearance.DARK, AppearanceStore(appContext).appearance.value)

        AppearanceStore(appContext).set(Appearance.AUTOMATIC)
        assertEquals(Appearance.AUTOMATIC, AppearanceStore(appContext).appearance.value)
    }

    @Test
    fun everyAppearanceHasALabelToPutOnItsButton() {
        assertEquals(listOf("Automatic", "Light", "Dark"), Appearance.entries.map { it.label })
    }

    // MARK: - LabelDefinitionsCache

    private val described = """
        {"did":"did:web:stub.grain.test","policies":{
          "labelValues":["!takedown","gore"],
          "labelValueDefinitions":[{"identifier":"gore","severity":"alert","blurs":"media",
            "defaultSetting":"warn","locales":[{"lang":"en","name":"Gore","description":"Blood."}]}]}}
    """.trimIndent()

    @Test
    fun labelDefinitionsAreTheBundledOnesUntilTheServerAnswers() {
        val harness = Harness()
        try {
            val cache = LabelDefinitionsCache(harness.client, harness.auth, harness.scope)
            assertEquals(
                listOf("copyright", "csae", "gore", "harassment", "misleading", "nudity", "other", "sexual", "spam"),
                cache.definitions.value.map { it.identifier },
            )
            val gore = cache.definitions.value.first { it.identifier == "gore" }
            assertEquals("media", gore.blurs)
            assertEquals("hide", gore.defaultSetting)
            assertEquals("Graphic Media", gore.displayName)
        } finally {
            harness.tearDown()
        }
    }

    @Test
    fun labelDefinitionsAreReadFromTheServerOnceThroughTheProxy() {
        val harness = Harness(StubServer().on(DESCRIBE_LABELS, described))
        try {
            val cache = LabelDefinitionsCache(harness.client, harness.auth, harness.scope)
            cache.loadIfNeeded()
            val read = cache.definitions.awaitValue("the server's definitions") { it.size == 1 }
            assertEquals("Gore", read.single().displayName)
            assertEquals("warn", read.single().defaultSetting)
            assertNotNull(harness.server.lastCall(DESCRIBE_LABELS).headers["atproto-proxy"])

            cache.loadIfNeeded()
            Thread.sleep(200)
            assertEquals(1, harness.server.countOf(DESCRIBE_LABELS))
        } finally {
            harness.tearDown()
        }
    }

    @Test
    fun aFailedReadKeepsTheBundledDefinitionsAndIsTriedAgain() {
        val server = StubServer().on(DESCRIBE_LABELS, """{"error":"InternalServerError"}""", code = 500)
        val harness = Harness(server)
        try {
            val cache = LabelDefinitionsCache(harness.client, harness.auth, harness.scope)
            cache.loadIfNeeded()
            server.awaitCall(DESCRIBE_LABELS)
            Thread.sleep(200)
            assertEquals(GrainLabels.definitions, cache.definitions.value)

            server.on(DESCRIBE_LABELS, described)
            cache.loadIfNeeded()
            cache.definitions.awaitValue("the server's definitions") { it.size == 1 }
            assertEquals(2, server.countOf(DESCRIBE_LABELS))
        } finally {
            harness.tearDown()
        }
    }

    private companion object {
        const val DESCRIBE_LABELS = "social.grain.moderation.describeLabels"
    }
}