// MainActivity.kt
package com.example.objectdetectionwebview

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.webkit.WebView
import android.webkit.WebViewClient
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.lifecycle.ViewModelProvider

class MainActivity : AppCompatActivity() {
    
    private lateinit var webView: WebView
    private lateinit var objectDetectionViewModel: ObjectDetectionViewModel
    private val CAMERA_PERMISSION_CODE = 100
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        webView = findViewById(R.id.webView)
        setupWebView()
        
        objectDetectionViewModel = ViewModelProvider(this)[ObjectDetectionViewModel::class.java]
        
        // Observe detection results
        objectDetectionViewModel.detectionResults.observe(this) { results ->
            // Handle detection results (could update WebView or show notifications)
            results?.let {
                Toast.makeText(this, "Detected: ${it.size} objects", Toast.LENGTH_SHORT).show()
            }
        }
        
        // Check camera permission
        if (checkCameraPermission()) {
            startObjectDetection()
        } else {
            requestCameraPermission()
        }
    }
    
    private fun setupWebView() {
        webView.apply {
            webViewClient = WebViewClient()
            settings.javaScriptEnabled = true
            settings.domStorageEnabled = true
            loadUrl("https://www.example.com") // Replace with your desired URL
        }
    }
    
    private fun checkCameraPermission(): Boolean {
        return ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.CAMERA
        ) == PackageManager.PERMISSION_GRANTED
    }
    
    private fun requestCameraPermission() {
        ActivityCompat.requestPermissions(
            this,
            arrayOf(Manifest.permission.CAMERA),
            CAMERA_PERMISSION_CODE
        )
    }
    
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == CAMERA_PERMISSION_CODE) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                startObjectDetection()
            } else {
                Toast.makeText(this, "Camera permission required", Toast.LENGTH_LONG).show()
            }
        }
    }
    
    private fun startObjectDetection() {
        objectDetectionViewModel.startDetection(this)
    }
    
    override fun onDestroy() {
        super.onDestroy()
        objectDetectionViewModel.stopDetection()
    }
}

// ObjectDetectionViewModel.kt
package com.example.objectdetectionwebview

import android.content.Context
import androidx.camera.core.*
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.core.content.ContextCompat
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

data class DetectionResult(
    val label: String,
    val confidence: Float,
    val boundingBox: android.graphics.RectF
)

class ObjectDetectionViewModel : ViewModel() {
    
    private var cameraExecutor: ExecutorService? = null
    private var camera: Camera? = null
    private var cameraProvider: ProcessCameraProvider? = null
    
    val detectionResults = MutableLiveData<List<DetectionResult>>()
    
    fun startDetection(context: Context) {
        cameraExecutor = Executors.newSingleThreadExecutor()
        
        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
        cameraProviderFuture.addListener({
            try {
                cameraProvider = cameraProviderFuture.get()
                bindCameraUseCases(context)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }, ContextCompat.getMainExecutor(context))
    }
    
    private fun bindCameraUseCases(context: Context) {
        val cameraProvider = this.cameraProvider ?: return
        
        // Preview use case (not displayed, just for processing)
        val preview = Preview.Builder().build()
        
        // Image analysis use case for object detection
        val imageAnalyzer = ImageAnalysis.Builder()
            .setTargetRotation(android.view.Surface.ROTATION_0)
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .build()
            .also {
                it.setAnalyzer(cameraExecutor!!, ObjectDetectionAnalyzer { results ->
                    // Post results to LiveData on main thread
                    viewModelScope.launch(Dispatchers.Main) {
                        detectionResults.value = results
                    }
                })
            }
        
        // Select back camera
        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
        
        try {
            // Unbind all use cases before rebinding
            cameraProvider.unbindAll()
            
            // Bind use cases to camera
            camera = cameraProvider.bindToLifecycle(
                context as LifecycleOwner,
                cameraSelector,
                preview,
                imageAnalyzer
            )
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    
    fun stopDetection() {
        cameraExecutor?.shutdown()
        cameraProvider?.unbindAll()
    }
    
    override fun onCleared() {
        super.onCleared()
        stopDetection()
    }
}

// ObjectDetectionAnalyzer.kt
package com.example.objectdetectionwebview

import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageProxy
import java.nio.ByteBuffer

class ObjectDetectionAnalyzer(
    private val onDetectionResult: (List<DetectionResult>) -> Unit
) : ImageAnalysis.Analyzer {
    
    override fun analyze(image: ImageProxy) {
        // Convert image to format suitable for ML model
        val buffer = image.planes[0].buffer
        val data = buffer.toByteArray()
        
        // Simulate object detection processing
        // In a real implementation, you would:
        // 1. Preprocess the image
        // 2. Run inference with your ML model (TensorFlow Lite, ML Kit, etc.)
        // 3. Post-process results
        
        simulateObjectDetection(data) { results ->
            onDetectionResult(results)
        }
        
        image.close()
    }
    
    private fun ByteBuffer.toByteArray(): ByteArray {
        rewind()
        val data = ByteArray(remaining())
        get(data)
        return data
    }
    
    private fun simulateObjectDetection(
        imageData: ByteArray,
        callback: (List<DetectionResult>) -> Unit
    ) {
        // Simulate processing time and results
        // Replace this with actual ML model inference
        
        val mockResults = listOf(
            DetectionResult(
                label = "person",
                confidence = 0.85f,
                boundingBox = android.graphics.RectF(100f, 100f, 300f, 400f)
            ),
            DetectionResult(
                label = "car",
                confidence = 0.72f,
                boundingBox = android.graphics.RectF(400f, 200f, 600f, 350f)
            )
        )
        
        // Randomly return results to simulate detection
        if (Math.random() > 0.7) {
            callback(mockResults)
        } else {
            callback(emptyList())
        }
    }
}

// activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <WebView
        android:id="@+id/webView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
    
    <!-- Optional: Add a floating indicator for detection status -->
    <TextView
        android:id="@+id/detectionStatus"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_alignParentEnd="true"
        android:layout_margin="16dp"
        android:background="#80000000"
        android:padding="8dp"
        android:text="Detection: Active"
        android:textColor="@android:color/white"
        android:textSize="12sp" />
    
</RelativeLayout>

// AndroidManifest.xml additions
/*
Add these permissions and features to your AndroidManifest.xml:

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-feature android:name="android.hardware.camera" android:required="true" />

Add this to your application tag:
android:usesCleartextTraffic="true" (if loading HTTP URLs)
*/

// build.gradle (Module: app) dependencies
/*
dependencies {
    implementation 'androidx.camera:camera-core:1.3.0'
    implementation 'androidx.camera:camera-camera2:1.3.0'
    implementation 'androidx.camera:camera-lifecycle:1.3.0'
    implementation 'androidx.camera:camera-view:1.3.0'
    
    // For ML Kit (optional)
    implementation 'com.google.mlkit:object-detection:17.0.0'
    
    // For TensorFlow Lite (optional)
    implementation 'org.tensorflow:tensorflow-lite:2.13.0'
    implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
    
    // Standard Android dependencies
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.7.0'
}
*/