package com.yorvana.util

import android.content.ContentResolver
import android.content.Context
import android.content.Intent
import android.net.Uri
import androidx.core.content.FileProvider
import androidx.documentfile.provider.DocumentFile
import com.google.common.truth.Truth.assertThat
import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkConstructor
import io.mockk.mockkStatic
import io.mockk.unmockkAll
import io.mockk.unmockkStatic
import org.junit.After
import org.junit.Before
import org.junit.Test
import java.io.ByteArrayInputStream
import java.io.File

class FileProviderHelperTest {
    @Before
    fun setUp() {
        mockkStatic(FileProvider::class)
        mockkConstructor(Intent::class)
    }

    @After
    fun tearDown() {
        unmockkStatic(FileProvider::class)
        unmockkAll()
    }

    @Test
    fun `getShareableUri should copy file and return uri`() {
        val context = mockk<Context>(relaxed = true)
        val contentResolver = mockk<ContentResolver>()
        val mockDocFile = mockk<DocumentFile>()
        val mockUri = mockk<Uri>()
        val resultUri = mockk<Uri>()
        val tempDir =
            kotlin.io.path
                .createTempDirectory()
                .toFile()

        every { context.cacheDir } returns tempDir
        every { context.contentResolver } returns contentResolver
        every { context.packageName } returns "com.yorvana"
        every { mockDocFile.uri } returns mockUri

        every { contentResolver.openInputStream(mockUri) } returns ByteArrayInputStream("test data".toByteArray())

        every { FileProvider.getUriForFile(any(), any(), any()) } returns resultUri

        val uri = FileProviderHelper.getShareableUri(context, mockDocFile, "test.txt")

        assertThat(uri).isEqualTo(resultUri)

        val copiedFile = File(tempDir, "attachments/test.txt")
        assertThat(copiedFile.exists()).isTrue()
        assertThat(copiedFile.readText()).isEqualTo("test data")

        tempDir.deleteRecursively()
    }

    @Test
    fun `getShareableUri should return null on error`() {
        val context = mockk<Context>(relaxed = true)
        val mockDocFile = mockk<DocumentFile>()
        val mockUri = mockk<Uri>()

        every { context.cacheDir } returns
            kotlin.io.path
                .createTempDirectory()
                .toFile()
        every { mockDocFile.uri } returns mockUri
        every { context.contentResolver.openInputStream(mockUri) } throws RuntimeException("Failed")

        val uri = FileProviderHelper.getShareableUri(context, mockDocFile, "test.txt")

        assertThat(uri).isNull()
    }

    /*
    @Test
    fun `buildViewIntent should create intent with proper flags`() {
        val mockUri = mockk<Uri>()
        val intent = FileProviderHelper.buildViewIntent(mockUri, "image/jpeg")

        assertThat(intent.action).isEqualTo(Intent.ACTION_VIEW)
        assertThat(intent.flags and Intent.FLAG_GRANT_READ_URI_PERMISSION).isNotEqualTo(0)
    }
     */

    @Test
    fun `guessMimeType should return correct mime types`() {
        assertThat(FileProviderHelper.guessMimeType("document.pdf")).isEqualTo("application/pdf")
        assertThat(FileProviderHelper.guessMimeType("image.jpg")).isEqualTo("image/jpeg")
        assertThat(FileProviderHelper.guessMimeType("video.mp4")).isEqualTo("video/mp4")
        assertThat(FileProviderHelper.guessMimeType("notes.txt")).isEqualTo("text/plain")
        assertThat(FileProviderHelper.guessMimeType("unknown.xyz")).isEqualTo("*/*")
        assertThat(FileProviderHelper.guessMimeType("no_extension")).isEqualTo("*/*")
    }
}