// Copyright 2024–2026 Skip

// SPDX-License-Identifier: MPL-2.0

import Foundation

import SwiftUI

import OSLog

import Combine

import WebKit

public typealias PlatformWebView = WKWebView

public typealias PlatformWebView = android.webkit.WebView

//import android.webkit.WebView // not imported because it conflicts with SkipWeb.WebView

import androidx.compose.runtime.Composable

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.ui.viewinterop.AndroidView

import androidx.appcompat.app.AppCompatActivity

import androidx.core.content.ContextCompat.startActivity

import android.webkit.WebViewClient

import android.webkit.JavascriptInterface

import android.webkit.WebResourceRequest

import android.webkit.WebResourceResponse

import android.view.ViewGroup

import androidx.webkit.WebSettingsCompat

import androidx.webkit.WebViewAssetLoader

import androidx.webkit.WebViewClientCompat

import androidx.webkit.WebViewCompat

import androidx.webkit.WebViewFeature

/// Metadata for a browser navigation that the platform runtime wants to treat as a download.

public struct WebDownloadRequest: Equatable, Hashable, Sendable {

/// An embedded WebKit view. It is configured using a `WebEngineConfiguration`

/// and driven with a `WebViewNavigator` which can be associated

/// with user interface controls like back/forward buttons and a URL bar.

///

/// For single-page flows, a navigator is usually enough to keep one browser runtime warm.

/// For multi-tab browsers, use `persistentWebViewID` so each tab can own and later rebind

/// its own cached `WebEngine`.

public struct WebView : View {

/// The current state of a web page, including the loading status and the current URL

@Observable public final class WebViewState: @unchecked Sendable {

/// A controller that can drive a `WebEngine` from a user interface.

public final class WebViewNavigator: @unchecked Sendable {

/// The URL the navigator's `webEngine.didSet` will reload onto a

/// freshly-attached engine when it has no existing back/forward

/// history. Hosts that need their content to survive engine

/// recreation — for example a `TabView` with `PageTabViewStyle`

/// that dismantles off-screen `WKWebView`s and reinstantiates them

/// on return — should keep this in sync with the user's current

/// navigation, not just set it at construction time.

public var initialURL: URL?

public var initialHTML: String?

#if SKIP

@MainActor var androidScrollTracker: AndroidScrollTracker?

#endif

@MainActor public var webEngine: WebEngine? {

}

public init(initialURL: URL? = nil, initialHTML: String? = nil) {

self.initialURL = initialURL

self.initialHTML = initialHTML

}

@MainActor public func load(html: String, baseURL: URL? = nil, mimeType: String = "text/html") {

// TODO: handle newTab

webEngine?.loadHTML(html, baseURL: baseURL, mimeType: mimeType)

}

@MainActor public func load(url: URL) {

}

/// Loads a URL and throws any profile setup/navigation preflight errors.

@MainActor public func loadOrThrow(url: URL) async throws {

}

@MainActor public func reload() {

logger.info("reload webView: \(self.webEngine?.description ?? "NONE")")

webEngine?.reload()

}

@MainActor public func stopLoading() {

logger.info("stopLoading webView: \(self.webEngine?.description ?? "NONE")")

webEngine?.stopLoading()

}

@MainActor public func go(_ item: WebHistoryItem) {

logger.info("go: \(item.item) webView: \(self.webEngine?.description ?? "NONE")")

webEngine?.go(to: item)

}

@MainActor public func goBack() {

logger.info("goBack webView: \(self.webEngine?.description ?? "NONE")")

webEngine?.goBack()

}

@MainActor public func goForward() {

logger.info("goForward webView: \(self.webEngine?.description ?? "NONE")")

webEngine?.goForward()

}

@MainActor public func evaluateJavaScript(_ js: String) async throws -> String? {

logger.info("evaluateJavaScript: \(js)")

return try await webEngine?.evaluate(js: js)

}

@MainActor public func takeSnapshot(configuration: SkipWebSnapshotConfiguration? = nil) async throws -> SkipWebSnapshot {

}

@MainActor public func cookies(for url: URL) async -> [WebCookie] {

}

@MainActor public func cookieHeader(for url: URL) async -> String? {

}

@MainActor public func setCookie(_ cookie: WebCookie, requestURL: URL? = nil) async throws {

}

@MainActor public func applySetCookieHeaders(_ headers: [String], for responseURL: URL) async throws {

}

@MainActor public func clearCookies() async {

}

@MainActor public func removeData(ofTypes types: Set<WebSiteDataType>, modifiedSince: Date) async throws {

}

// MARK: SkipUI interop with legacy UIKit/AndroidView system

protocol ViewRepresentable {

typealias ViewRepresentable = UIViewRepresentable

typealias ViewRepresentable = NSViewRepresentable

public struct MessageHandlerRouter {

struct WebViewClient : android.webkit.WebViewClient {

struct WebViewDownloadListener : android.webkit.DownloadListener {

final class SkipWebChromeClient : android.webkit.WebChromeClient {

extension WebView : ViewRepresentable {

public typealias Coordinator = WebViewCoordinator

public func makeCoordinator() -> Coordinator {

WebViewCoordinator(webView: self, navigator: navigator, scriptCaller: scriptCaller, config: config)

}

@MainActor private func setupWebView(_ webEngine: WebEngine, coordinator: WebViewCoordinator? = nil) -> WebEngine {

}

public func update(webView: PlatformWebView, coordinator: WebViewCoordinator? = nil) {

}

#if SKIP

// Without `remember` recompositions recreate WebViewCoordinator, which resets scroll-tracking state and can swap scrollViewProxy identity mid-session

@Composable

private func rememberedCoordinator() -> WebViewCoordinator {

// SKIP INSERT: return androidx.compose.runtime.remember { makeCoordinator() }

return makeCoordinator()

}

public var body: some View {

}

#else

@MainActor private func makeWebEngine(id: String?, config: WebEngineConfiguration, coordinator: WebViewCoordinator) -> WebEngine {