// PlaceSearchManager.kt — Nominatim (OpenStreetMap)
class PlaceSearchManager(
    private val context: Context,
    private val searchInput: EditText,
    private val suggestionsView: RecyclerView,
    private val mapFragment: SupportMapFragment,
    private val onPlaceSelected: (PlaceResult) -> Unit
) {
    data class PlaceResult(
        val name: String,
        val address: String,
        val lat: Double,
        val lng: Double,
        val type: String = ""
    )

    private var googleMap: GoogleMap? = null
    private var searchJob: Job? = null
    private val adapter = PlaceSuggestionsAdapter { place ->
        selectPlace(place)
    }

    init {
        suggestionsView.adapter = adapter
        mapFragment.getMapAsync { map ->
            googleMap = map
            map.uiSettings.isZoomControlsEnabled = true
            map.mapType = GoogleMap.MAP_TYPE_NORMAL
        }
        searchInput.addTextChangedListener { text ->
            searchJob?.cancel()
            if (text.isNullOrBlank() || text.length < 3) {
                adapter.submitList(emptyList()); return@addTextChangedListener
            }
            searchJob = CoroutineScope(Dispatchers.Main).launch {
                delay(400) // debounce
                searchPlaces(text.toString())
            }
        }
    }

    private suspend fun searchPlaces(query: String) {
        try {
            val url = Uri.parse("https://nominatim.openstreetmap.org/search")
                .buildUpon()
                .appendQueryParameter("q", query)
                .appendQueryParameter("format", "json")
                .appendQueryParameter("addressdetails", "1")
                .appendQueryParameter("limit", "6")
                .appendQueryParameter("accept-language", "id")
                .build().toString()

            val results = withContext(Dispatchers.IO) {
                URL(url).readText() // parse JSON → List
            }
            adapter.submitList(parseNominatimResponse(results))
        } catch (e: Exception) {
            Log.e("PlaceSearch", "Search error", e)
        }
    }

    private fun selectPlace(place: PlaceResult) {
        searchInput.setText(place.name)
        adapter.submitList(emptyList())
        val latLng = LatLng(place.lat, place.lng)
        googleMap?.apply {
            clear()
            addMarker(MarkerOptions()
                .position(latLng).title(place.name)
                .icon(BitmapDescriptorFactory
                    .defaultMarker(BitmapDescriptorFactory.HUE_CYAN)))
            animateCamera(CameraUpdateFactory.newLatLngZoom(latLng, 15f))
        }
        onPlaceSelected(place)
    }
}

// PlaceSuggestionsAdapter.kt (RecyclerView)
class PlaceSuggestionsAdapter(
    private val onClick: (PlaceSearchManager.PlaceResult) -> Unit
) : ListAdapter<PlaceSearchManager.PlaceResult, PlaceSuggestionsAdapter.VH>(DiffCallback()) {
    inner class VH(val binding: ItemSuggestionBinding) :
        RecyclerView.ViewHolder(binding.root) {
        fun bind(item: PlaceSearchManager.PlaceResult) {
            binding.tvName.text = item.name
            binding.tvAddress.text = item.address
            binding.root.setOnClickListener { onClick(item) }
        }
    }
    override fun onCreateViewHolder(...) = VH(...)
    override fun onBindViewHolder(holder: VH, pos: Int) = holder.bind(getItem(pos))
}

// CameraManager.kt — CameraX + Watermark
class CameraManager(
    private val activity: AppCompatActivity,
    private val binding: ActivityMainBinding
) {
    fun capturePhoto(location: Location?, address: String, identity: String) {
        val outputFile = createOutputFile()
        imageCapture?.takePicture(
            ImageCapture.OutputFileOptions.Builder(outputFile).build(),
            ContextCompat.getMainExecutor(activity),
            object : ImageCapture.OnImageSavedCallback {
                override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                    WatermarkHelper.addWatermark(outputFile, location, address, identity)
                }
                override fun onError(e: ImageCaptureException) { }
            }
        )
    }
}

// LocationManager.kt — FusedLocationProvider
class LocationManager(
    private val context: Context,
    private val onUpdate: (Location) -> Unit
) {
    private val fusedClient =
        LocationServices.getFusedLocationProviderClient(context)

    @SuppressLint("MissingPermission")
    fun startTracking() {
        fusedClient.requestLocationUpdates(
            LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5000L).build(),
            locationCallback, Looper.getMainLooper()
        )
    }
    fun reverseGeocode(location: Location, onResult: (String) -> Unit) {
        CoroutineScope(Dispatchers.IO).launch {
            val address = Geocoder(context).getFromLocation(
                location.latitude, location.longitude, 1
            )?.firstOrNull()?.getAddressLine(0) ?: "-"
            withContext(Dispatchers.Main) { onResult(address) }
        }
    }
}

// WatermarkHelper.kt — logo + identitas + mini-map
object WatermarkHelper {
    fun addWatermark(file: File, location: Location?, address: String, identity: String) {
        val canvas = Canvas(mutable)
        val stripH = H * 0.22f
        // Background panel, logo, identity, timestamp, address, coords, mini-map
        MapThumbnailHelper.draw(canvas, location, W, H, stripH)
        FileOutputStream(file).use {
            mutable.compress(Bitmap.CompressFormat.JPEG, 95, it)
        }
    }
}

// build.gradle (app)
dependencies {
    implementation "androidx.camera:camera-core:1.3.1"
    implementation "androidx.camera:camera-camera2:1.3.1"
    implementation "androidx.camera:camera-lifecycle:1.3.1"
    implementation "androidx.camera:camera-view:1.3.1"
    implementation "com.google.android.gms:play-services-location:21.2.0"
    implementation "com.google.android.gms:play-services-maps:18.2.0"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
    // Place Search — menggunakan Nominatim (gratis, tidak perlu API key)
    implementation "com.squareup.okhttp3:okhttp:4.12.0"
    implementation "org.json:json:20231013"
}