package com.vgmlr.kerf

import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.viewModels
import androidx.compose.runtime.*
import androidx.navigation.compose.*

class MainActivity : ComponentActivity() {

    private val vm: KerfViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)

        KerfUtils.cleanupCache(this)
        handleIntent(intent)

        setContent {
            KerfTheme {
                val nav = rememberNavController()

                NavHost(nav, startDestination = KerfScreen.Home.route) {
                    composable(KerfScreen.Home.route) { HomeScreen(vm, nav) }
                    composable(KerfScreen.Edit.route, KerfScreen.Edit.arguments) { backStack ->
                        val id = backStack.arguments?.getInt("noteId") ?: 0
                        EditScreen(id, vm) { nav.popBackStack() }
                    }
                }

                val sharedText by vm.sharedText.collectAsState()
                val sharedFile by vm.sharedFile.collectAsState()
                val kerfImport by vm.kerfImport.collectAsState()

                kerfImport?.let { (title, content) ->
                    LaunchedEffect(kerfImport) {
                        vm.addNote(isImported = true) { id ->
                            vm.updateNoteImmediate(id, title, content, true)
                            vm.setKerfImport(null)
                            nav.navigate(KerfScreen.Edit.createRoute(id))
                        }
                    }
                }

                sharedText?.let { text ->
                    val notes by vm.allNotes.collectAsState()
                    ShareDialog(
                        notes = notes,
                        onSelect = { vm.appendContent(it, text); vm.setSharedText(null) },
                        onAddNew = {
                            vm.addNote(isImported = false) { id ->
                                val trimmedText = text.trim()
                                val urlMatch = KerfUtils.UrlRegex.find(trimmedText)
                                val urlPart = urlMatch?.value ?: ""
                                val cleanText = if (urlMatch != null) trimmedText.replace(urlPart, "").trim() else trimmedText

                                val initialContent = if (urlPart.isNotEmpty() && cleanText.isNotEmpty()) {
                                    "1. $urlPart\n$cleanText\n"
                                } else {
                                    "1. $trimmedText\n"
                                }

                                vm.updateNoteImmediate(id, "", initialContent, false)
                                vm.setSharedText(null)
                            }
                        },
                        onDismiss = { vm.setSharedText(null) }
                    )
                }

                sharedFile?.let { fileData ->
                    LaunchedEffect(fileData) {
                        vm.addNote(isImported = true) { id ->
                            vm.updateNoteImmediate(id, fileData.first, fileData.second, true)
                            vm.setSharedFile(null)
                            nav.navigate(KerfScreen.Edit.createRoute(id))
                        }
                    }
                }
            }
        }
    }

    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        setIntent(intent)
        handleIntent(intent)
    }

    private fun handleIntent(intent: Intent?) {
        if (intent == null) return

        when (intent.action) {
            Intent.ACTION_SEND -> {
                val streamUri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                    intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
                } else {
                    @Suppress("DEPRECATION")
                    intent.getParcelableExtra(Intent.EXTRA_STREAM)
                }

                if (streamUri != null) {
                    if (KerfUtils.isKerfFile(this, streamUri)) {
                        vm.setSharedFile(KerfUtils.importNoteFromUri(this, streamUri))
                    } else {
                        val localPath = KerfUtils.getLocalFilePath(this, streamUri) ?: streamUri.toString()
                        vm.setSharedText(localPath)
                    }
                } else if ("text/plain" == intent.type) {
                    val text = intent.getStringExtra(Intent.EXTRA_TEXT)
                    if (text != null) {
                        val kerfData = KerfUtils.parseKerfText(text)
                        if (kerfData != null) {
                            vm.setKerfImport(kerfData)
                        } else {
                            vm.setSharedText(text)
                        }
                    }
                }
            }
            Intent.ACTION_VIEW -> {
                intent.data?.let { uri ->
                    if (KerfUtils.isKerfFile(this, uri)) {
                        vm.setSharedFile(KerfUtils.importNoteFromUri(this, uri))
                    } else {
                        val localPath = KerfUtils.getLocalFilePath(this, uri) ?: uri.toString()
                        vm.setSharedText(localPath)
                    }
                }
            }
        }
    }
}

sealed class KerfScreen(val route: String, val arguments: List<androidx.navigation.NamedNavArgument> = emptyList()) {
    object Home : KerfScreen("home")
    object Edit : KerfScreen("edit/{noteId}", listOf(androidx.navigation.navArgument("noteId") { type = androidx.navigation.NavType.IntType })) {
        fun createRoute(id: Int) = "edit/$id"
    }
}