package com.lunacare.app.receiver

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.Build
import android.util.Log
import com.lunacare.app.service.GuardianForegroundService

class BootReceiver : BroadcastReceiver() {

    // ════════════════════════════════════════
    //  onReceive — Boot ya App-Replace broadcast
    // ════════════════════════════════════════
    override fun onReceive(context: Context, intent: Intent) {
        val action = intent.action ?: return
        Log.d("BootReceiver", "Received broadcast: $action")

        when (action) {
            // ── Phone reboot complete ──
            Intent.ACTION_BOOT_COMPLETED,
            // ── Encrypted boot complete (Android 7+) ──
            "android.intent.action.LOCKED_BOOT_COMPLETED",
            // ── App update installed ──
            Intent.ACTION_MY_PACKAGE_REPLACED -> {
                startGuardianService(context)
            }
        }
    }

    // ════════════════════════════════════════
    //  Start Guardian Foreground Service
    // ════════════════════════════════════════
    private fun startGuardianService(context: Context) {
        try {
            val serviceIntent = Intent(context, GuardianForegroundService::class.java)

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                // Android 8+ — startForegroundService() is REQUIRED
                // Warna Android "Context.startForegroundService() did not call
                // Service.startForeground()" ANR dega
                context.startForegroundService(serviceIntent)
            } else {
                context.startService(serviceIntent)
            }

            Log.d("BootReceiver", "GuardianForegroundService started successfully.")

        } catch (e: Exception) {
            // Background service restriction (Android 12+) ya permission missing
            Log.e("BootReceiver", "Failed to start service: ${e.message}")
        }
    }
}

package com.lunacare.app.util

import android.annotation.SuppressLint
import android.app.Activity
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.PowerManager
import android.provider.Settings
import androidx.appcompat.app.AlertDialog

object BatteryOptimizationHelper {

    // ════════════════════════════════════════
    //  Check: Is the app already exempt?
    // ════════════════════════════════════════
    fun isIgnoringBatteryOptimizations(context: Context): Boolean {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return true  // Pre-M: no Doze mode
        val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
        return pm.isIgnoringBatteryOptimizations(context.packageName)
    }

    // ════════════════════════════════════════
    //  Method 1: Direct System Dialog
    //  (ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
    //  Note: REQUEST_IGNORE_BATTERY_OPTIMIZATIONS permission
    //  is REQUIRED in Manifest
    // ════════════════════════════════════════
    @SuppressLint("BatteryLife")
    fun requestDirectExemption(activity: Activity) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return
        if (isIgnoringBatteryOptimizations(activity)) return  // Already exempt

        val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
            data = Uri.parse("package:${activity.packageName}")
        }
        try {
            activity.startActivity(intent)
        } catch (e: Exception) {
            // Some devices crash here — fallback to settings page
            openBatterySettings(activity)
        }
    }

    // ════════════════════════════════════════
    //  Method 2: App-specific battery settings
    //  (Most reliable — user manually toggles)
    // ════════════════════════════════════════
    fun openBatterySettings(activity: Activity) {
        val intent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS)
        } else {
            Intent(Settings.ACTION_SETTINGS)
        }
        try {
            activity.startActivity(intent)
        } catch (e: Exception) {
            // Absolute fallback
            activity.startActivity(Intent(Settings.ACTION_SETTINGS))
        }
    }

    // ════════════════════════════════════════
    //  Show Explanation Dialog
    //  (Explain to user why it is needed — then ask)
    // ════════════════════════════════════════
    fun showBatteryOptimizationDialog(activity: Activity) {
        if (isIgnoringBatteryOptimizations(activity)) return  // Already done, skip

        AlertDialog.Builder(activity)
            .setTitle("🛡️ Battery Optimization — Disable This")
            .setMessage(
                "LunaCare SOS will only work when the app is running in the background. " +
                "\n\n" +
                "Android's Doze Mode can put the app to sleep, which may " +
                "interrupt GPS and SMS during emergencies.\n\n" +
                "Please set LunaCare to 'Unrestricted' or 'Don't optimize' " +
                "set it to High Accuracy."
            )
            .setPositiveButton("Allow ✅") { _, _ ->
                requestDirectExemption(activity)
            }
            .setNegativeButton("Baad mein") { dialog, _ ->
                dialog.dismiss()
                // Warn user SOS may not work reliably
            }
            .setCancelable(false)  // Non-dismissible dialog
            .show()
    }

    // ════════════════════════════════════════
    //  Call this on SOS Setup or Onboarding
    //  Usage in Activity/Fragment:
    //
    //  BatteryOptimizationHelper.checkAndPrompt(this)
    // ════════════════════════════════════════
    fun checkAndPrompt(activity: Activity) {
        if (!isIgnoringBatteryOptimizations(activity)) {
            showBatteryOptimizationDialog(activity)
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.lunacare.app">

    <!-- ══════════════════════════════════════════
         PERMISSIONS — Immortal Engine ke liye required
    ══════════════════════════════════════════ -->

    <!-- Foreground Service permission (Android 9+) -->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

    <!-- Foreground Service type: location (mandatory for Android 10+) -->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />

    <!-- WakeLock — Keeps CPU active even after screen turns off -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />

    <!-- Boot Receiver — Phone reboot ke baad service restart -->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

    <!-- Battery Optimization bypass prompt -->
    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />

    <!-- Location permissions (SOS GPS tracking ke liye) -->
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <!-- Background location — GPS continues even when screen is off during active SOS -->
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

    <!-- SMS sending (emergency alert) -->
    <uses-permission android:name="android.permission.SEND_SMS" />

    <!-- Internet (for any online features) -->
    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="true"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">

        <!-- Main Activity -->
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- ══════════════════════════════════════════
             GUARDIAN FOREGROUND SERVICE
             - android:foregroundServiceType="location" → Required for Android 10+
             - android:stopWithTask="false" → Service won't stop when task is swiped away
        ══════════════════════════════════════════ -->
        <service
            android:name=".service.GuardianForegroundService"
            android:enabled="true"
            android:exported="false"
            android:foregroundServiceType="location"
            android:stopWithTask="false" />

        <!-- ══════════════════════════════════════════
             BOOT RECEIVER
             - Listens to both RECEIVE_BOOT_COMPLETED and MY_PACKAGE_REPLACED
             - android:directBootAware="true" → Works during encrypted boot (Android 7+)
             - android:exported="true" → REQUIRED to receive system broadcasts
        ══════════════════════════════════════════ -->
        <receiver
            android:name=".receiver.BootReceiver"
            android:enabled="true"
            android:exported="true"
            android:directBootAware="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
            </intent-filter>
        </receiver>

    </application>

</manifest>

package com.lunacare.app.service

import android.app.AlertDialog
import android.content.Context
import android.content.Intent
import android.location.LocationManager
import android.os.Looper
import android.provider.Settings
import android.util.Log
import com.google.android.gms.location.*
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ServerValue

/**
 * ══════════════════════════════════════════════════════════════════
 *  LocationTelemetryService — LunaCare High-Precision GPS Telemetry
 * ══════════════════════════════════════════════════════════════════
 *
 *  Use this class inside GuardianForegroundService or
 *  call it as a separate helper class.
 *
 *  Dependencies (add to app/build.gradle):
 *  implementation "com.google.android.gms:play-services-location:21.0.1"
 *  implementation "com.google.firebase:firebase-database-ktx:20.3.0"
 *  implementation "com.google.firebase:firebase-auth-ktx:22.3.0"
 * ══════════════════════════════════════════════════════════════════
 */
class LocationTelemetryService(private val context: Context) {

    companion object {
        private const val TAG = "LocationTelemetry"

        // ── Configuration ──────────────────────────────────────────
        private const val UPDATE_INTERVAL_MS      = 20_000L   // 20 seconds — normal interval
        private const val FASTEST_INTERVAL_MS     = 10_000L   // 10 seconds — fastest allowed
        private const val SOS_IMMEDIATE_TIMEOUT   = 5_000L    // 5 sec max wait for instant fix

        // ── Firebase DB Path ───────────────────────────────────────
        private const val DB_PATH = "emergency_logs"
    }

    // ── FusedLocationProviderClient — Google ka best GPS provider ──
    private val fusedClient: FusedLocationProviderClient =
        LocationServices.getFusedLocationProviderClient(context)

    // ── Firebase References ────────────────────────────────────────
    private val firebaseAuth = FirebaseAuth.getInstance()
    private val firebaseDb   = FirebaseDatabase.getInstance()

    // ── LocationRequest — PRIORITY_HIGH_ACCURACY ───────────────────
    // This config is for regular SOS tracking
    private val locationRequest: LocationRequest = LocationRequest.Builder(
        Priority.PRIORITY_HIGH_ACCURACY,
        UPDATE_INTERVAL_MS
    ).apply {
        setMinUpdateIntervalMillis(FASTEST_INTERVAL_MS)   // Fastest allowed interval: 10 sec
        setWaitForAccurateLocation(true)                  // Wait for first accurate reading
        setMaxUpdateDelayMillis(UPDATE_INTERVAL_MS * 2)   // Max batch delay
    }.build()

    // ── Location Callback — Har update par Firebase push ──────────
    private val locationCallback = object : LocationCallback() {

        override fun onLocationResult(result: LocationResult) {
            result.lastLocation?.let { location ->

                // ── Speed: convert m/s → km/h ─────────────────
                val speedKmh = if (location.hasSpeed()) {
                    (location.speed * 3.6f).toDouble()   // 1 m/s = 3.6 km/h
                } else {
                    0.0
                }

                // ── Telemetry data object ───────────────────────────
                val telemetryData = mapOf(
                    "latitude"        to location.latitude,
                    "longitude"       to location.longitude,
                    "speed_kmh"       to speedKmh,
                    "accuracy_meters" to location.accuracy.toDouble(),
                    "altitude"        to location.altitude,
                    "bearing"         to location.bearing.toDouble(),
                    "provider"        to (location.provider ?: "unknown"),
                    "serverTimestamp" to ServerValue.TIMESTAMP,    // Firebase server time — tamper-proof
                    "deviceTimestamp" to location.time             // Device ka local time (backup)
                )

                pushToFirebase(telemetryData)

                Log.d(TAG, "📍 Location pushed: ${location.latitude}, ${location.longitude} | " +
                    "Speed: ${"%.1f".format(speedKmh)} km/h | " +
                    "Accuracy: ${location.accuracy}m")
            }
        }

        override fun onLocationAvailability(availability: LocationAvailability) {
            if (!availability.isLocationAvailable) {
                Log.w(TAG, "⚠️ Location unavailable — GPS disabled or no signal")
                // Show GPS disabled dialog on UI thread
                android.os.Handler(Looper.getMainLooper()).post {
                    showLocationDisabledDialog()
                }
            }
        }
    }

    // ════════════════════════════════════════════════════════════════
    //  startTracking() — Start regular 20-sec SOS tracking
    // ════════════════════════════════════════════════════════════════
    fun startTracking() {
        // First check if GPS is enabled
        if (!isLocationEnabled()) {
            showLocationDisabledDialog()
            return
        }

        try {
            fusedClient.requestLocationUpdates(
                locationRequest,
                locationCallback,
                Looper.getMainLooper()   // Callback on main thread (UI safe)
            )
            Log.d(TAG, "✅ Location tracking started — 20sec interval, PRIORITY_HIGH_ACCURACY")
        } catch (e: SecurityException) {
            Log.e(TAG, "❌ Location permission missing: ${e.message}")
        }
    }

    // ════════════════════════════════════════════════════════════════
    //  stopTracking() — Stop tracking (on SOS deactivate)
    // ════════════════════════════════════════════════════════════════
    fun stopTracking() {
        fusedClient.removeLocationUpdates(locationCallback)
        Log.d(TAG, "🛑 Location tracking stopped")
    }

    // ════════════════════════════════════════════════════════════════
    //  forceImmediateFix() — ZERO-LATENCY INJECTION
    //  ─────────────────────────────────────────────────────────────
    //  SOS trigger hone ke TURANT baad ye call karo.
    //  Standard 20-sec interval ka wait bypass karta hai and
    //  ek immediate high-priority location fix force karta hai.
    //
    //  Usage:
    //      telemetryService.forceImmediateFix()   // SOS button press ke turant baad
    //      telemetryService.startTracking()        // Regular loop start karo
    // ════════════════════════════════════════════════════════════════
    fun forceImmediateFix() {
        // ── One-shot high-priority immediate request ────────────────
        val immediateRequest = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY,
            1L   // Interval = 1ms → turant deliver karo
        ).apply {
            setMaxUpdates(1)                           // Sirf EK fix chahiye
            setWaitForAccurateLocation(false)          // Don't wait — speed priority hai
            setMinUpdateIntervalMillis(1L)
        }.build()

        try {
            fusedClient.requestLocationUpdates(
                immediateRequest,
                object : LocationCallback() {
                    override fun onLocationResult(result: LocationResult) {
                        result.lastLocation?.let { location ->

                            val speedKmh = if (location.hasSpeed()) {
                                (location.speed * 3.6f).toDouble()
                            } else { 0.0 }

                            // ── Immediate SOS telemetry with sosTriggered flag ──
                            val immediateData = mapOf(
                                "latitude"        to location.latitude,
                                "longitude"       to location.longitude,
                                "speed_kmh"       to speedKmh,
                                "accuracy_meters" to location.accuracy.toDouble(),
                                "altitude"        to location.altitude,
                                "serverTimestamp" to ServerValue.TIMESTAMP,
                                "deviceTimestamp" to location.time,
                                "sosTriggered"    to true,   // Ye SOS trigger fix hai — flag lagao
                                "provider"        to (location.provider ?: "unknown")
                            )
                            pushToFirebase(immediateData)
                            // Ek baar push after ye callback hata do
                            fusedClient.removeLocationUpdates(this)

                            Log.d(TAG, "🚨 ZERO-LATENCY SOS Fix: ${location.latitude}, " +
                                "${location.longitude} | Accuracy: ${location.accuracy}m")
                        }
                    }
                },
                Looper.getMainLooper()
            )
            Log.d(TAG, "⚡ Immediate high-priority location fix requested")
        } catch (e: SecurityException) {
            Log.e(TAG, "❌ Permission missing for immediate fix: ${e.message}")
        }
    }

    // ════════════════════════════════════════════════════════════════
    //  pushToFirebase() — /emergency_logs/{uid} pe data push karo
    // ════════════════════════════════════════════════════════════════
    private fun pushToFirebase(data: Map<String, Any>) {
        val uid = firebaseAuth.currentUser?.uid ?: run {
            // Auth nahi hai — anonymous UID use karo ya local device ID
            Log.w(TAG, "⚠️ No Firebase user — using anonymous node")
            "anonymous_${android.os.Build.SERIAL}"
        }

        // push() → automatic unique key generate karta hai (timestamp-based)
        // Isse entries kabhi overwrite nahi hoti — har fix alag node mein jaati hai
        firebaseDb.reference
            .child(DB_PATH)           // /emergency_logs
            .child(uid)               // /emergency_logs/{uid}
            .push()                   // /emergency_logs/{uid}/{auto-key}
            .setValue(data)
            .addOnSuccessListener {
                Log.d(TAG, "✅ Firebase push successful")
            }
            .addOnFailureListener { err ->
                Log.e(TAG, "❌ Firebase push failed: ${err.message}")
                // TODO: Offline queue mein store karo and baad mein retry karo
            }
    }

    // ════════════════════════════════════════════════════════════════
    //  isLocationEnabled() — checks if GPS/High Accuracy is enabled or not
    // ════════════════════════════════════════════════════════════════
    fun isLocationEnabled(): Boolean {
        val lm = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
        return lm.isProviderEnabled(LocationManager.GPS_PROVIDER) ||
               lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
    }

    // ════════════════════════════════════════════════════════════════
    //  showLocationDisabledDialog() — User ko GPS enable karne bolo
    //  High-Accuracy mode ka prompt dikhao
    // ════════════════════════════════════════════════════════════════
    private fun showLocationDisabledDialog() {
        // Ye sirf Activity context mein kaam karta hai
        // Service mein use kar rahe ho to Application context pe AlertDialog nahi banta
        // Recommended: LocalBroadcastManager se Activity ko message bhejo
        try {
            AlertDialog.Builder(context)
                .setTitle("📍 GPS Band Hai — Location Enable Karo")
                .setMessage(
                    "SOS emergency mein accurate location send karne ke liye\n\n" +
                    "Settings → Location → Mode → Enable 'High Accuracy'.\n\n" +
                    "GPS disabled hone par contacts ko sirf approximate area milega — " +
                    "exact location ke liye High Accuracy GPS zaroori hai. 🛡️"
                )
                .setPositiveButton("Settings Kholo ✅") { _, _ ->
                    // High Accuracy Location Settings direct open karo
                    val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS).apply {
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    }
                    try {
                        context.startActivity(intent)
                    } catch (e: Exception) {
                        // Fallback: General settings
                        context.startActivity(
                            Intent(Settings.ACTION_SETTINGS).apply {
                                flags = Intent.FLAG_ACTIVITY_NEW_TASK
                            }
                        )
                    }
                }
                .setNegativeButton("Baad Mein") { dialog, _ ->
                    dialog.dismiss()
                    Log.w(TAG, "User ne GPS enable karna skip kiya — SOS accuracy reduced")
                }
                .setCancelable(false)   // Dismiss cannot — safety critical
                .show()
        } catch (e: Exception) {
            // Window token error (service context) — broadcast se handle karo
            Log.e(TAG, "Dialog show failed (use Activity context): ${e.message}")
            // Send local broadcast to Activity to show dialog
            val broadcastIntent = Intent("com.lunacare.SHOW_GPS_DIALOG")
            context.sendBroadcast(broadcastIntent)
        }
    }
}


// ════════════════════════════════════════════════════════════════════
//  INTEGRATION — GuardianForegroundService mein kaise use karo
// ════════════════════════════════════════════════════════════════════
//
//  GuardianForegroundService.kt mein yeh add karo:
//
//  class GuardianForegroundService : Service() {
//
//      private lateinit var telemetry: LocationTelemetryService
//
//      override fun onCreate() {
//          super.onCreate()
//          telemetry = LocationTelemetryService(this)
//          // ...rest of onCreate...
//      }
//
//      private fun handleSosActivate() {
//          acquireWakeLock()
//          // ── Step 1: ZERO-LATENCY — Instant first fix (interval bypass)
//          telemetry.forceImmediateFix()
//          // ── Step 2: Regular 20-sec tracking loop start karo
//          telemetry.startTracking()
//          updateNotification(
//              title   = "🆘 SOS ACTIVE — LunaCare Guardian",
//              message = "Emergency mode — Live location Firebase pe sync ho rahi hai."
//          )
//      }
//
//      private fun handleSosDeactivate() {
//          releaseWakeLock()
//          telemetry.stopTracking()
//          updateNotification(
//              title   = "🛡️ LunaCare Guardian Active",
//              message = "Monitoring in background. Tap to open."
//          )
//      }
//
//      override fun onDestroy() {
//          telemetry.stopTracking()
//          super.onDestroy()
//      }
//  }
// ════════════════════════════════════════════════════════════════════