kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("com.saralapps:composemultiplatformwebview:0.1.4")
        }
    }
}

import com.saralapps.composemultiplatformwebview.PlatformWebView

@Composable
fun App() {
    PlatformWebView(
        url = "https://kotlinlang.org",
        modifier = Modifier.fillMaxSize()
    )
}

@Composable
fun WebViewWithState() {
    val webViewState = rememberPlatformWebViewState(
        url = "https://github.com",
        javaScriptEnabled = true,
        allowsFileAccess = true
    )
    
    PlatformWebView(
        state = webViewState,
        modifier = Modifier.fillMaxSize(),
        onUrlChanged = { newUrl ->
            println("Navigated to: $newUrl")
        }
    )
}

@Composable
fun InteractiveBrowser() {
    var currentUrl by remember { mutableStateOf("https://example.com") }
    var isLoading by remember { mutableStateOf(false) }
    
    Column(modifier = Modifier.fillMaxSize()) {
        // Navigation bar
        Row(
            modifier = Modifier.fillMaxWidth().padding(8.dp),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            TextField(
                value = currentUrl,
                onValueChange = { currentUrl = it },
                modifier = Modifier.weight(1f),
                placeholder = { Text("Enter URL") },
                singleLine = true
            )
            
            Button(
                onClick = { /* Trigger navigation */ },
                enabled = !isLoading
            ) {
                Text("Go")
            }
        }
        
        // Loading indicator
        if (isLoading) {
            LinearProgressIndicator(
                modifier = Modifier.fillMaxWidth()
            )
        }
        
        // WebView
        PlatformWebView(
            url = currentUrl,
            modifier = Modifier.weight(1f),
            javaScriptEnabled = true,
            onUrlChanged = { newUrl ->
                currentUrl = newUrl
                isLoading = false
            },
            onNavigating = { url ->
                isLoading = true
                true // Allow navigation
            }
        )
    }
}

@Composable
fun WebViewWithFallback() {
    PlatformWebView(
        url = "https://example.com",
        modifier = Modifier.fillMaxSize(),
        onUnavailable = { availability ->
            Box(
                modifier = Modifier.fillMaxSize(),
                contentAlignment = Alignment.Center
            ) {
                when (availability) {
                    is WebViewAvailability.NotInstalled -> {
                        Column(horizontalAlignment = Alignment.CenterHorizontally) {
                            Text("WebView not available on this device")
                            Button(onClick = { /* Handle installation */ }) {
                                Text("Install WebView2")
                            }
                        }
                    }
                    is WebViewAvailability.Error -> {
                        Text("Error: ${availability.message}")
                    }
                    else -> {
                        Text("WebView unavailable")
                    }
                }
            }
        }
    )
}

val webViewState = rememberPlatformWebViewState(
    url = "https://example.com",
    javaScriptEnabled = true,
    allowsFileAccess = false,
    onNavigating = { url ->
        // Return true to allow, false to block navigation
        url.startsWith("https://")
    }
)

@Composable
fun PlatformWebView(
    state: PlatformWebViewState,
    modifier: Modifier = Modifier,
    placeholderColor: Color = Color.White,
    onUrlChanged: ((String) -> Unit)? = null,
    onCreated: (() -> Unit)? = null,
    onDisposed: (() -> Unit)? = null,
    onUnavailable: @Composable ((WebViewAvailability) -> Unit)? = null
)

@Composable
fun PlatformWebView(
    url: String,
    modifier: Modifier = Modifier,
    javaScriptEnabled: Boolean = true,
    allowsFileAccess: Boolean = true,
    placeholderColor: Color = Color.White,
    onUrlChanged: ((String) -> Unit)? = null,
    onNavigating: ((String) -> Boolean)? = null,
    onCreated: (() -> Unit)? = null,
    onDisposed: (() -> Unit)? = null,
    onUnavailable: @Composable ((WebViewAvailability) -> Unit)? = null
)

sealed class WebViewAvailability {
    object Available : WebViewAvailability()
    object NotInstalled : WebViewAvailability()
    data class Error(val message: String) : WebViewAvailability()
}

@Composable
fun SecureWebView(url: String) {
    val webViewState = rememberPlatformWebViewState(
        url = url,
        javaScriptEnabled = false,  // Disable for untrusted content
        allowsFileAccess = false,   // Prevent file access
        onNavigating = { navigationUrl ->
            // Whitelist allowed domains
            val allowedDomains = listOf("example.com", "api.example.com")
            val uri = URI(navigationUrl)
            allowedDomains.any { uri.host?.endsWith(it) == true }
        }
    )
    
    PlatformWebView(
        state = webViewState,
        modifier = Modifier.fillMaxSize()
    )
}

@Composable
fun DynamicContentViewer() {
    var selectedContent by remember { 
        mutableStateOf("https://kotlinlang.org") 
    }
    
    val contentOptions = mapOf(
        "Kotlin" to "https://kotlinlang.org",
        "Compose" to "https://www.jetbrains.com/lp/compose-multiplatform/",
        "GitHub" to "https://github.com"
    )
    
    Column(modifier = Modifier.fillMaxSize()) {
        // Content selector
        Row(
            modifier = Modifier.fillMaxWidth().padding(8.dp),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            contentOptions.forEach { (label, url) ->
                Button(
                    onClick = { selectedContent = url },
                    colors = ButtonDefaults.buttonColors(
                        containerColor = if (selectedContent == url) 
                            MaterialTheme.colorScheme.primary 
                        else 
                            MaterialTheme.colorScheme.secondary
                    )
                ) {
                    Text(label)
                }
            }
        }
        
        // WebView with dynamic content
        PlatformWebView(
            url = selectedContent,
            modifier = Modifier.weight(1f),
            javaScriptEnabled = true
        )
    }
}

@Composable
fun TabbedBrowser() {
    var tabs by remember {
        mutableStateOf(listOf(
            "https://kotlinlang.org",
            "https://github.com"
        ))
    }
    var selectedTab by remember { mutableStateOf(0) }
    
    Column(modifier = Modifier.fillMaxSize()) {
        // Tab row
        ScrollableTabRow(selectedTabIndex = selectedTab) {
            tabs.forEachIndexed { index, url ->
                Tab(
                    selected = selectedTab == index,
                    onClick = { selectedTab = index },
                    text = { 
                        Text(
                            url.substringAfter("://")
                                .substringBefore("/")
                                .take(20)
                        ) 
                    }
                )
            }
        }
        
        // Active tab content
        PlatformWebView(
            url = tabs[selectedTab],
            modifier = Modifier.weight(1f),
            javaScriptEnabled = true,
            onUrlChanged = { newUrl ->
                tabs = tabs.toMutableList().apply {
                    set(selectedTab, newUrl)
                }
            }
        )
    }
}

@Composable
fun WebViewWithLifecycle() {
    var webViewActive by remember { mutableStateOf(false) }
    var pageTitle by remember { mutableStateOf("") }
    
    PlatformWebView(
        url = "https://example.com",
        modifier = Modifier.fillMaxSize(),
        onCreated = {
            webViewActive = true
            println("WebView initialized successfully")
        },
        onUrlChanged = { url ->
            // Update page title or handle navigation
            pageTitle = url.substringAfter("://").substringBefore("/")
        },
        onDisposed = {
            webViewActive = false
            println("WebView resources released")
        }
    )
}

// Untrusted external content
PlatformWebView(
    url = "https://untrusted-site.com",
    javaScriptEnabled = false,  // Disable JavaScript
    allowsFileAccess = false,
    modifier = Modifier.fillMaxSize()
)

// Trusted application content
PlatformWebView(
    url = "https://your-app.com",
    javaScriptEnabled = true,
    modifier = Modifier.fillMaxSize()
)

// Web content (recommended: deny file access)
val webState = rememberPlatformWebViewState(
    url = "https://example.com",
    allowsFileAccess = false
)

// Local HTML content (required: allow file access)
val localState = rememberPlatformWebViewState(
    url = "file:///android_asset/index.html",
    allowsFileAccess = true
)

val secureWebViewState = rememberPlatformWebViewState(
    url = "https://myapp.com",
    onNavigating = { url ->
        when {
            // Block non-HTTPS
            !url.startsWith("https://") -> false
            
            // Block tracking and ads
            url.contains("analytics") || url.contains("doubleclick") -> false
            
            // Whitelist domains
            !url.contains("myapp.com") && !url.contains("cdn.myapp.com") -> false
            
            // Allow all other HTTPS navigation
            else -> true
        }
    }
)

// Android-specific WebView settings can be configured
// through the native platform implementation

// iOS WKWebView provides automatic dark mode support
// and native Safari features

// WebView2 provides full Chromium engine compatibility
// with automatic updates through Windows Update

// macOS WKWebView integrates seamlessly with system
// appearance and accessibility features

// Users may need to update Android System WebView from Play Store
// Your app should handle this gracefully

// Platform-specific cache clearing can be implemented
// through the native implementation

fun isWebView2Available(): Boolean {
    // Check if WebView2 runtime is installed
    return true // Implementation depends on platform detection
}

fun checkMacOSVersion(): Boolean {
    val osVersion = System.getProperty("os.version")
    // macOS 10.15+ required
    return true
}

dependencies {
    implementation("net.java.dev.jna:jna:5.13.0")
    implementation("net.java.dev.jna:jna-platform:5.13.0")
}

@Test
fun testWebViewStateInitialization() = runComposeUiTest {
    var state: PlatformWebViewState? = null
    
    setContent {
        state = rememberPlatformWebViewState(
            url = "https://example.com",
            javaScriptEnabled = true
        )
    }
    
    assertNotNull(state)
}

@Test
fun testNavigationBlocking() = runComposeUiTest {
    var navigationBlocked = false
    
    setContent {
        val state = rememberPlatformWebViewState(
            url = "https://example.com",
            onNavigating = { url ->
                if (url.contains("malicious")) {
                    navigationBlocked = true
                    false
                } else {
                    true
                }
            }
        )
        
        PlatformWebView(state = state)
    }
    
    // Verify navigation blocking works
    assertTrue(navigationBlocked || !navigationBlocked) // Placeholder
}

@Test
fun testWebViewLifecycle() = runComposeUiTest {
    var created = false
    var disposed = false
    
    setContent {
        PlatformWebView(
            url = "https://example.com",
            onCreated = { created = true },
            onDisposed = { disposed = true }
        )
    }
    
    waitUntil(timeoutMillis = 5000) { created }
    
    setContent { /* Remove WebView */ }
    
    waitUntil(timeoutMillis = 3000) { disposed }
}