dependencies {
    implementation("io.github.saggeldi:yedu-kmp-gps-listener:0.0.4")
}

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        GpsFactory.initialize(this)
    }
}

// GPS-only mode
val tracker = GpsFactory.createGpsTracker(myListener)
tracker.start(config)

// Full pipeline mode (GPS + network monitoring + sending)
val controller = GpsFactory.createTrackingController(
    serverUrl = "https://your-server.com:5055",
    listener = myControllerListener
)
controller.start(config)

// Android
val tracker = GpsTracker(AndroidLocationProvider(context), listener)

// iOS (Swift)
let tracker = GpsTracker(locationProvider: IosLocationProvider(), listener: listener)

class MyTrackingService : Service() {
    private lateinit var gpsTracker: GpsTracker

    override fun onCreate() {
        super.onCreate()
        startForeground(1, createNotification())

        // Option A: Common factory (requires GpsFactory.initialize(context) in Application)
        gpsTracker = GpsFactory.createGpsTracker(myListener)

        // Option B: Direct platform constructor
        // gpsTracker = GpsTracker(AndroidLocationProvider(this), myListener)

        gpsTracker.start(GpsConfig(
            deviceId = "my-device-123",
            interval = 300,
            accuracy = LocationAccuracy.HIGH
        ))
    }

    private val myListener = object : GpsTrackerListener {
        override fun onPositionUpdate(position: Position) {
            println("${position.latitude}, ${position.longitude}")
            println("Battery: ${position.battery.level}%")
        }
        override fun onError(error: String) {
            Log.e("GPS", error)
        }
        override fun onStatusChange(status: TrackerStatus) {
            Log.d("GPS", "Tracker: $status")
        }
    }

    override fun onDestroy() {
        gpsTracker.stop()
        super.onDestroy()
    }

    override fun onBind(intent: Intent?) = null
}

class MyTrackingService : Service() {
    private lateinit var controller: TrackingController
    private var wakeLock: PowerManager.WakeLock? = null

    override fun onCreate() {
        super.onCreate()
        startForeground(1, createNotification())

        // Acquire wake lock for reliable background tracking
        val powerManager = getSystemService(POWER_SERVICE) as PowerManager
        wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::GPS")
        wakeLock?.acquire()

        // Option A: Common factory (requires GpsFactory.initialize(context) in Application)
        controller = GpsFactory.createTrackingController(
            serverUrl = "https://your-server.com:5055",
            listener = controllerListener
        )

        // Option B: Direct platform constructors
        // controller = TrackingController(
        //     locationProvider = AndroidLocationProvider(this),
        //     positionSender = AndroidPositionSender(),
        //     networkMonitor = AndroidNetworkMonitor(this),
        //     serverUrl = "https://your-server.com:5055",
        //     listener = controllerListener
        // )

        controller.start(GpsConfig(
            deviceId = "my-device-123",
            interval = 300,
            accuracy = LocationAccuracy.HIGH
        ))
    }

    private val controllerListener = object : TrackingControllerListener {
        override fun onPositionUpdate(position: Position) {
            Log.d("GPS", "New: ${position.latitude}, ${position.longitude}")
        }
        override fun onPositionSent(position: Position) {
            Log.d("GPS", "Sent to server")
        }
        override fun onSendFailed(position: Position) {
            Log.w("GPS", "Send failed")
        }
        override fun onError(error: String) {
            Log.e("GPS", error)
        }
        override fun onStatusChange(status: TrackerStatus) {
            Log.d("GPS", "Tracker: $status")
        }
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        return START_STICKY
    }

    override fun onDestroy() {
        controller.stop()
        if (wakeLock?.isHeld == true) wakeLock?.release()
        super.onDestroy()
    }

    override fun onBind(intent: Intent?) = null
}

val tripTracker = TripTracker()

// Set a listener for stats updates and pause/resume events
tripTracker.setListener(object : TripTrackerListener {
    override fun onTripStatsUpdated(stats: TripStats) {
        println("Distance: ${stats.totalDistanceKm} km (${stats.totalDistanceMeters} m)")
        println("Time: ${stats.totalTimeSeconds}s (${stats.totalTimeMinutes} min)")
    }
    override fun onTripEnded(stats: TripStats) {
        println("Trip ended: ${stats.totalDistanceKm} km")
    }
    override fun onDriverPaused() {
        println("Driver has stopped")
    }
    override fun onDriverResumed() {
        println("Driver is moving again")
    }
})

// Start a trip with an ID and initial status
tripTracker.startTrip("trip-123", "accepted")

// Update status as the trip progresses
tripTracker.updateStatus("en_route")
tripTracker.updateStatus("arrived")
tripTracker.updateStatus("in_progress")

// Feed GPS positions (called from your GPS listener)
tripTracker.updatePosition(position)

// End the trip — triggers onTripEnded with final stats
tripTracker.endTrip()

val stats = tripTracker.getTripStats()

// Get stats for a specific status
val enRouteStats = stats.statsForStatus("en_route")
if (enRouteStats != null) {
    println("en_route: ${enRouteStats.distanceKm} km, ${enRouteStats.timeMinutes} min")
}

// Iterate all statuses
for ((statusName, statusStats) in stats.statusHistory) {
    println("$statusName: ${statusStats.distanceMeters}m in ${statusStats.timeSeconds}s")
}

val tripTracker = TripTracker()

// Configure thresholds (defaults: 2m distance, 15s time)
tripTracker.pauseDistanceThresholdMeters = 5.0   // movement within 5m = "not moving"
tripTracker.pauseTimeThresholdSeconds = 20L       // must be stationary for 20s to trigger pause

// Access pause state in stats
val stats = tripTracker.getTripStats()
println("Currently paused: ${stats.isPaused}")
println("Total stopped time: ${stats.totalStoppingSeconds}s")

// Update config without restarting
tracker.updateConfig(tracker.currentConfig()!!.copy(interval = 60))

// Change accuracy
tracker.updateConfig(tracker.currentConfig()!!.copy(accuracy = LocationAccuracy.HIGH))

// Request a single immediate position
tracker.requestSingleLocation()

// Check status
if (tracker.isTracking()) { /* ... */ }

// Stop
tracker.stop()

val permissionHelper = GpsFactory.createLocationPermissionHelper()

// Check current permission status
when (permissionHelper.checkPermissionStatus()) {
    PermissionStatus.GRANTED        -> println("Permission granted")
    PermissionStatus.DENIED         -> println("Permission denied")
    PermissionStatus.NOT_DETERMINED -> println("Permission not yet requested")
    PermissionStatus.RESTRICTED     -> println("Permission restricted by policy")
}

// Check background permission specifically
if (permissionHelper.hasBackgroundPermission()) { /* always-on tracking OK */ }

// Check if device GPS is enabled
if (!permissionHelper.isLocationEnabled()) {
    permissionHelper.openLocationSettings()  // prompt user to enable GPS
}

permissionHelper.requestPermission(background = false) { status ->
    println("Result: $status")
}

// Request background (always) permission
permissionHelper.requestPermission(background = true) { status ->
    println("Background result: $status")
}

permissionHelper.openLocationSettings()  // device GPS settings
permissionHelper.openAppSettings()       // app permission settings

// In your Activity
val helper = GpsFactory.createLocationPermissionHelper()
    as AndroidLocationPermissionHelper

helper.setActivity(this)

helper.requestPermission(background = true) { status ->
    // handle result
}

// Relay the result from your Activity
override fun onRequestPermissionsResult(
    requestCode: Int, permissions: Array<String>, grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    helper.onRequestPermissionsResult(requestCode, permissions, grantResults)
}

// Clear when Activity is destroyed
override fun onDestroy() {
    helper.clearActivity()
    super.onDestroy()
}