diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
index bb90a43..36b2c89 100644
--- a/.idea/deploymentTargetSelector.xml
+++ b/.idea/deploymentTargetSelector.xml
@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2025-05-06T21:02:21.268492700Z">
+        <DropdownSelection timestamp="2025-05-09T10:45:20.233683100Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="PhysicalDevice" identifier="serial=RZ8R911E2FN" />
+              <DeviceId pluginId="LocalEmulator" identifier="path=C:\Users\user\.android\avd\Medium_Phone_API_36.avd" />
             </handle>
           </Target>
         </DropdownSelection>
diff --git a/app/src/main/java/com/example/malvoayant/MainActivity.kt b/app/src/main/java/com/example/malvoayant/MainActivity.kt
index 4024005..525e4bc 100644
--- a/app/src/main/java/com/example/malvoayant/MainActivity.kt
+++ b/app/src/main/java/com/example/malvoayant/MainActivity.kt
@@ -1,31 +1,31 @@
 package com.example.malvoayant
 
-
-import android.content.Intent
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
+import androidx.lifecycle.ViewModelProvider
 import com.example.malvoayant.navigation.NavigationController
 import com.example.malvoayant.ui.screens.StepCounterViewModel
 
-import com.example.malvoayant.ui.theme.MalvoayantTheme
-
 class MainActivity : ComponentActivity() {
-    private lateinit var viewModel: StepCounterViewModel
+    private lateinit var stepCounterViewModel: StepCounterViewModel
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContent {
-            viewModel = StepCounterViewModel(application)
-            viewModel.startListening()
-            NavigationController(viewModel)        }
+            stepCounterViewModel = ViewModelProvider(this)[StepCounterViewModel::class.java]
+
+            // Start listening to sensors and WebSocket
+            stepCounterViewModel.startListening()
+
+            // Set up the navigation with the StepCounterViewModel
+            NavigationController(stepCounterViewModel)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        // Stop listening when the app is closed
+        stepCounterViewModel.stopListening()
     }
-}
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/navigation/Navigation.kt b/app/src/main/java/com/example/malvoayant/navigation/Navigation.kt
index 0744b48..cbdd755 100644
--- a/app/src/main/java/com/example/malvoayant/navigation/Navigation.kt
+++ b/app/src/main/java/com/example/malvoayant/navigation/Navigation.kt
@@ -1,4 +1,4 @@
-package com.example.malvoayant.navigation
+/*package com.example.malvoayant.navigation
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -99,4 +99,4 @@ fun NavigationController(    stepCounterViewModel: StepCounterViewModel = viewMo
             )
         }
     }
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanCanvasView.kt b/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanCanvasView.kt
index 1277c1a..c0e8572 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanCanvasView.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanCanvasView.kt
@@ -1,11 +1,9 @@
 package com.example.malvoayant.ui.screens
 
-import android.util.Log
 import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.background
 import androidx.compose.foundation.gestures.detectTransformGestures
 import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.*
 import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.ui.Modifier
@@ -20,23 +18,19 @@ import androidx.compose.ui.graphics.drawscope.rotate
 import androidx.compose.ui.graphics.drawscope.scale
 import androidx.compose.ui.graphics.drawscope.translate
 import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.unit.dp
 import androidx.lifecycle.viewmodel.compose.viewModel
-import kotlin.math.cos
-import kotlin.math.sin
 
 @Composable
 fun FloorPlanCanvasView(
     floorPlanState: FloorPlanState,
     modifier: Modifier = Modifier,
-    viewModel: StepCounterViewModel = viewModel()
+    stepCounterViewModel: StepCounterViewModel = viewModel()
 ) {
-    val pathPoints by viewModel.pathPoints.observeAsState(listOf(Pair(0f, 0f)))
-    val currentPosition by viewModel.currentPositionLive.observeAsState(Pair(0f, 0f))
-    val currentHeading by viewModel.currentHeadingLive.observeAsState(0f)
+    val pathPoints by stepCounterViewModel.pathPoints.observeAsState(listOf())
+    val wifiPosition by stepCounterViewModel.wifiPositionLive.observeAsState(null)
 
     var scale by remember { mutableStateOf(floorPlanState.scale) }
-    var offset by remember { mutableStateOf(androidx.compose.ui.geometry.Offset(floorPlanState.offset.x, floorPlanState.offset.y)) }
+    var offset by remember { mutableStateOf(Offset(floorPlanState.offset.x, floorPlanState.offset.y)) }
 
     LaunchedEffect(floorPlanState.scale, floorPlanState.offset) {
         scale = floorPlanState.scale
@@ -47,7 +41,7 @@ fun FloorPlanCanvasView(
     val doorColor = Color(0xFFAA7722)
     val windowColor = Color(0xFF6699CC)
     val poiColor = Color(0xFFCC3344)
-    val pathColor = Color(0xFF4CAF50)
+    val wifiColor = Color(0xFF4CAF50)
 
     val roomColors = remember {
         mapOf(
@@ -59,7 +53,6 @@ fun FloorPlanCanvasView(
             "default" to Color(0xFFF0DAAF)
         )
     }
-// Use the smaller scale factor to fit the floor plan within the canvas
 
     Box(
         modifier = modifier
@@ -83,70 +76,69 @@ fun FloorPlanCanvasView(
                     drawDoorWindows(floorPlanState.doors, doorColor, isDoor = true)
                     drawDoorWindows(floorPlanState.windows, windowColor, isDoor = false)
                     drawPOIs(floorPlanState.pois, poiColor)
-                    drawPath(floorPlanState.minPoint, pathPoints, currentPosition, currentHeading)
+
+                    // Draw WiFi position and path
+                    wifiPosition?.let { position ->
+                        drawWiFiPath(floorPlanState.minPoint, pathPoints, position, wifiColor)
+                    }
                 }
             }
         }
     }
 }
-private fun DrawScope.drawPath(minPoint: Point, pathPoints: List<Pair<Float, Float>>, currentPosition: Pair<Float, Float>, currentHeading: Float) {
-    val path = Path()
-
-    if (pathPoints.size > 1) {
-        path.moveTo(pathPoints[0].first * 50 + minPoint.x, pathPoints[0].second * 50 + minPoint.y)
 
-        for (i in 1 until pathPoints.size) {
-            val start = pathPoints[i - 1]
-            val end = pathPoints[i]
-            val control = Offset((start.first + end.first) / 2, (start.second + end.second) / 2)
-
-            path.quadraticBezierTo(
-                control.x * 50 + minPoint.x, control.y * 50 + minPoint.y,
-                end.first * 50 + minPoint.x, end.second * 50 + minPoint.y
-            )
-        }
-
-        drawPath(
-            path = path,
-            brush = Brush.linearGradient(
-                start = Offset(pathPoints.first().first * 50 + minPoint.x, pathPoints.first().second * 50 + minPoint.y),
-                end = Offset(pathPoints.last().first * 50 + minPoint.x, pathPoints.last().second * 50 + minPoint.y),
-                colors = listOf(Color(0xFF4CAF50), Color(0xFFFFEB3B))
-            ),
-            style = Stroke(width = 5f)
-        )
+private fun DrawScope.drawWiFiPath(
+    minPoint: Point,
+    pathPoints: List<Pair<Float, Float>>,
+    currentPosition: Pair<Float, Float>,
+    pathColor: Color
+) {
+    // Only draw path if there are points
+    if (pathPoints.isNotEmpty()) {
+        val path = Path()
+
+        // Start the path at the first point
+        if (pathPoints.size >= 1) {
+            path.moveTo(pathPoints[0].first * 50 + minPoint.x, pathPoints[0].second * 50 + minPoint.y)
+
+            // Draw lines connecting the path points
+            for (i in 1 until pathPoints.size) {
+                path.lineTo(
+                    pathPoints[i].first * 50 + minPoint.x,
+                    pathPoints[i].second * 50 + minPoint.y
+                )
+            }
 
-        pathPoints.forEach { point ->
-            drawCircle(
-                color = Color(0xFF2196F3),
-                radius = 8f,
-                center = Offset(point.first * 50 + minPoint.x, point.second * 50 + minPoint.y)
+            // Draw the path with a gradient
+            drawPath(
+                path = path,
+                brush = Brush.linearGradient(
+                    start = Offset(pathPoints.first().first * 50 + minPoint.x, pathPoints.first().second * 50 + minPoint.y),
+                    end = Offset(pathPoints.last().first * 50 + minPoint.x, pathPoints.last().second * 50 + minPoint.y),
+                    colors = listOf(Color(0xFF4CAF50), Color(0xFFFFEB3B))
+                ),
+                style = Stroke(width = 5f)
             )
-        }
 
-        if (pathPoints.isNotEmpty()) {
-            drawCircle(
-                color = Color.Red,
-                radius = 12f,
-                center = Offset(currentPosition.first * 50 + minPoint.x, currentPosition.second * 50 + minPoint.y)
-            )
+            // Draw dots at each position point
+            pathPoints.forEach { point ->
+                drawCircle(
+                    color = Color(0xFF2196F3),
+                    radius = 8f,
+                    center = Offset(point.first * 50 + minPoint.x, point.second * 50 + minPoint.y)
+                )
+            }
         }
 
-        val headingRad = Math.toRadians(currentHeading.toDouble())
-        val arrowLength = 20.dp.toPx()
-        drawLine(
+        // Draw the current position as a larger red circle
+        drawCircle(
             color = Color.Red,
-            start = Offset(currentPosition.first * 50 + minPoint.x, currentPosition.second * 50 + minPoint.y),
-            end = Offset(
-                (currentPosition.first * 50 + minPoint.x) + arrowLength * cos(headingRad).toFloat(),
-                (currentPosition.second * 50 + minPoint.y) + arrowLength * sin(headingRad).toFloat()
-            ),
-            strokeWidth = 3.dp.toPx()
+            radius = 12f,
+            center = Offset(currentPosition.first * 50 + minPoint.x, currentPosition.second * 50 + minPoint.y)
         )
     }
 }
 
-
 private fun DrawScope.drawWalls(walls: List<Wall>, wallColor: Color) {
     walls.forEach { wall ->
         drawLine(
@@ -279,4 +271,4 @@ private fun DrawScope.drawPOIs(pois: List<POI>, color: Color) {
             )
         }
     }
-}
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanScreen.kt b/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanScreen.kt
new file mode 100644
index 0000000..60b14e4
--- /dev/null
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/FloorPlanScreen.kt
@@ -0,0 +1,194 @@
+package com.example.malvoayant.ui.screens
+
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+
+@Composable
+fun FloorPlanScreen(
+    stepCounterViewModel: StepCounterViewModel = viewModel(),
+    floorPlanViewModel: FloorPlanViewModel = viewModel()
+) {
+    val context = LocalContext.current
+    val floorPlanState = floorPlanViewModel.floorPlanState
+    val isConnected by stepCounterViewModel.isConnected.observeAsState(false)
+
+    // Observe position data from Raspberry Pi
+    val wifiPosition by stepCounterViewModel.wifiPositionLive.observeAsState(null)
+    val lastWifiUpdateAgo by stepCounterViewModel.lastWifiUpdateAgo.observeAsState("Never")
+    val wifiConfidence by stepCounterViewModel.wifiConfidence.observeAsState(0f)
+
+    // Remember the launcher for file picking
+    val launcher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.GetContent()
+    ) { uri: Uri? ->
+        uri?.let {
+            floorPlanViewModel.importFromGeoJSONUri(context, it)
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        // Load default floor plan from assets when the screen is first composed
+        floorPlanViewModel.loadGeoJSONFromAssets(context)
+    }
+
+    Column(modifier = Modifier.fillMaxSize()) {
+        // Connection status indicator and WiFi position display
+        Surface(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(8.dp),
+            tonalElevation = 2.dp,
+            shape = RoundedCornerShape(8.dp)
+        ) {
+            Column(modifier = Modifier.padding(12.dp)) {
+                // Connection status and control button
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = if (isConnected) "WebSocket: Connected" else "WebSocket: Disconnected",
+                        color = if (isConnected) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error,
+                        fontWeight = FontWeight.SemiBold
+                    )
+
+                    Button(
+                        onClick = {
+                            if (isConnected) {
+                                stepCounterViewModel.stopListening()
+                            } else {
+                                stepCounterViewModel.startListening()
+                            }
+                        }
+                    ) {
+                        Text(if (isConnected) "Disconnect" else "Connect")
+                    }
+                }
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                // WiFi Position data display
+                wifiPosition?.let { position ->
+                    CoordinatesDisplay(
+                        title = "WiFi Position",
+                        x = position.first,
+                        y = position.second,
+                        confidence = wifiConfidence,
+                        lastUpdate = lastWifiUpdateAgo
+                    )
+                } ?: run {
+                    Text(
+                        text = "Waiting for WiFi position data...",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+            }
+        }
+
+        // Floor plan canvas
+        FloorPlanCanvasView(
+            floorPlanState = floorPlanState,
+            stepCounterViewModel = stepCounterViewModel,
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(1f)
+        )
+
+        // Bottom controls
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(8.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly
+        ) {
+            Button(onClick = { launcher.launch("application/json") }) {
+                Text("Load Floor Plan")
+            }
+
+            Button(onClick = { stepCounterViewModel.resetAll() }) {
+                Text("Reset Path")
+            }
+
+            Button(onClick = { stepCounterViewModel.requestSingleWifiUpdate() }) {
+                Text("Get Position")
+            }
+        }
+    }
+}
+
+@Composable
+fun CoordinatesDisplay(
+    title: String,
+    x: Float,
+    y: Float,
+    confidence: Float? = null,
+    lastUpdate: String? = null
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 4.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.7f)
+        ),
+        shape = RoundedCornerShape(4.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .padding(8.dp)
+                .fillMaxWidth()
+        ) {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.labelMedium,
+                fontWeight = FontWeight.Bold
+            )
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = "X: ${String.format("%.2f", x)}",
+                    style = MaterialTheme.typography.bodyMedium
+                )
+                Text(
+                    text = "Y: ${String.format("%.2f", y)}",
+                    style = MaterialTheme.typography.bodyMedium
+                )
+
+                confidence?.let {
+                    Text(
+                        text = "Conf: ${String.format("%.1f", it * 100)}%",
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                }
+            }
+
+            lastUpdate?.let {
+                Text(
+                    text = "Updated: $it",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
+                )
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/HomeScreen.kt b/app/src/main/java/com/example/malvoayant/ui/screens/HomeScreen.kt
index b3d7377..e28f6bc 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/HomeScreen.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/HomeScreen.kt
@@ -1,4 +1,4 @@
-package  com.example.malvoayant.ui.screens
+/*package  com.example.malvoayant.ui.screens
 
 import android.Manifest
 import android.content.Context
@@ -241,3 +241,4 @@ fun HomeScreen(context: Context,navController: NavHostController) {
     }
 }
 
+*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/LiveTrackingScreen.kt b/app/src/main/java/com/example/malvoayant/ui/screens/LiveTrackingScreen.kt
index 4cf5c12..4c97892 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/LiveTrackingScreen.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/LiveTrackingScreen.kt
@@ -1,4 +1,4 @@
-package com.example.malvoayant.ui.screens
+/*package com.example.malvoayant.ui.screens
 
 
 import androidx.compose.foundation.layout.Box
@@ -92,4 +92,4 @@ fun LiveTrackingScreen(
             }
         }
     }
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/LoginScreen.kt b/app/src/main/java/com/example/malvoayant/ui/screens/LoginScreen.kt
index 7630deb..995a80b 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/LoginScreen.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/LoginScreen.kt
@@ -1,4 +1,4 @@
-package com.example.malvoayant.ui.screens
+/*package com.example.malvoayant.ui.screens
 
 import android.Manifest
 import android.R.attr
@@ -239,3 +239,4 @@ fun LoginScreen(context: Context, navController: NavHostController) {
         }
     }
 }
+*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/NavigationController.kt b/app/src/main/java/com/example/malvoayant/ui/screens/NavigationController.kt
new file mode 100644
index 0000000..58e165c
--- /dev/null
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/NavigationController.kt
@@ -0,0 +1,22 @@
+package com.example.malvoayant.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import com.example.malvoayant.ui.screens.FloorPlanScreen
+import com.example.malvoayant.ui.screens.StepCounterViewModel
+
+@Composable
+fun NavigationController(stepCounterViewModel: StepCounterViewModel) {
+    val navController = rememberNavController()
+
+    NavHost(
+        navController = navController,
+        startDestination = "floorplan"
+    ) {
+        composable("floorplan") {
+            FloorPlanScreen(stepCounterViewModel)
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/PathTracingCanvas.kt b/app/src/main/java/com/example/malvoayant/ui/screens/PathTracingCanvas.kt
index 3d00f53..8ce2809 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/PathTracingCanvas.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/PathTracingCanvas.kt
@@ -1,4 +1,4 @@
-package com.example.malvoayant.ui.screens
+/*package com.example.malvoayant.ui.screens
 
 
 import android.util.Log
@@ -104,4 +104,4 @@ fun PathTracingCanvas(
             }
         }
     }
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/SearchPage.kt b/app/src/main/java/com/example/malvoayant/ui/screens/SearchPage.kt
index 21035b6..dfd576d 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/SearchPage.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/SearchPage.kt
@@ -1,4 +1,4 @@
-package com.example.malvoayant.ui.screens
+/*package com.example.malvoayant.ui.screens
 
 import android.content.Context
 import androidx.compose.foundation.Image
@@ -288,3 +288,4 @@ fun SearchScreen(
         }
     }
 }
+*/
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/StepCounterViewModel.kt b/app/src/main/java/com/example/malvoayant/ui/screens/StepCounterViewModel.kt
index e038cb7..470b014 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/StepCounterViewModel.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/StepCounterViewModel.kt
@@ -2,102 +2,281 @@ package com.example.malvoayant.ui.screens
 
 import android.app.Application
 import android.content.Context
-import android.hardware.Sensor
-import android.hardware.SensorEvent
-import android.hardware.SensorEventListener
-import android.hardware.SensorManager
 import android.util.Log
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
-import kotlin.math.cos
-import kotlin.math.sin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import org.java_websocket.client.WebSocketClient
+import org.java_websocket.handshake.ServerHandshake
+import org.json.JSONObject
+import java.lang.Exception
+import java.net.URI
 
 class StepCounterViewModel(application: Application) : AndroidViewModel(application) {
-    private val sensorManager = application.getSystemService(Context.SENSOR_SERVICE) as SensorManager
-    private val stepDetector = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)
-    private val rotationVector = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+    private var isReconnecting = false
 
-    private val _steps = MutableLiveData(0)
-    val steps: LiveData<Int> = _steps
+    // WebSocket properties
+    private var webSocketClient: WebSocketClient? = null
+    private val _isConnected = MutableLiveData(false)
+    val isConnected: LiveData<Boolean> = _isConnected
 
-    private val _currentHeadingLive = MutableLiveData(0f)
-    val currentHeadingLive: LiveData<Float> = _currentHeadingLive
+    // WiFi position properties
+    private val _wifiPositionLive = MutableLiveData<Pair<Float, Float>?>(null)
+    val wifiPositionLive: LiveData<Pair<Float, Float>?> = _wifiPositionLive
 
-    private var currentHeading = 0f
-    private var currentPosition = Pair(0f, 0f)
-    private val stepLength = 0.7f  // Average step length in meters
+    private val _wifiConfidence = MutableLiveData(0.0f)
+    val wifiConfidence: LiveData<Float> = _wifiConfidence
 
+    // For visualization - path tracking with only WiFi positions
+    private val _pathPoints = MutableLiveData(listOf<Pair<Float, Float>>())
+    val pathPoints: LiveData<List<Pair<Float, Float>>> = _pathPoints
+
+    // Current position (only from WiFi)
     private val _currentPositionLive = MutableLiveData(Pair(0f, 0f))
     val currentPositionLive: LiveData<Pair<Float, Float>> = _currentPositionLive
 
-    private val _pathPoints = MutableLiveData(listOf(Pair(0f, 0f)))
-    val pathPoints: LiveData<List<Pair<Float, Float>>> = _pathPoints
+    // Position update time tracking
+    private var lastWifiUpdateTime = 0L
+    private val _lastWifiUpdateAgo = MutableLiveData("Never")
+    val lastWifiUpdateAgo: LiveData<String> = _lastWifiUpdateAgo
+
+    // Connection status
+    private val _connectionStatus = MutableLiveData("Disconnected")
+    val connectionStatus: LiveData<String> = _connectionStatus
+
+    private val _errorMessage = MutableLiveData<String?>(null)
+    val errorMessage: LiveData<String?> = _errorMessage
+
+    private var reconnectAttempts = 0
+    private val maxReconnectAttempts = 5
+
+    private var reconnectionJob: kotlinx.coroutines.Job? = null
 
-    private val stepListener = object : SensorEventListener {
-        override fun onSensorChanged(event: SensorEvent) {
-            if (event.sensor.type == Sensor.TYPE_STEP_DETECTOR) {
-                _steps.postValue((_steps.value ?: 0) + 1)
-                Log.d("StepCounter", "Step detected $_steps.value")
-                updatePosition()
+    // Start a timer to update the "last update" text
+    private val updateTimer = CoroutineScope(Dispatchers.Default)
+
+    init {
+        // Start timer to update "last update ago" text
+        updateTimer.launch {
+            while (isActive) {
+                updateLastUpdateText()
+                delay(1000)  // Update every second
             }
         }
+    }
 
-        override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
+    // WebSocket functions
+    fun initWebSocket() {
+        connectWebSocket()
+        startReconnectionTimer()
     }
 
-    private val rotationListener = object : SensorEventListener {
-        override fun onSensorChanged(event: SensorEvent) {
-            if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) {
-                val rotationMatrix = FloatArray(9)
-                SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values)
+    private fun connectWebSocket() {
+        if (isReconnecting) return
+        isReconnecting = true
+
+        try {
+            webSocketClient?.close()
+            webSocketClient = null
+        } catch (e: Exception) {
+            // Ignore any exceptions during cleanup
+        }
 
-                val orientationAngles = FloatArray(3)
-                SensorManager.getOrientation(rotationMatrix, orientationAngles)
+        val serverUri = URI("ws://192.168.205.205:8000/ws/position") // Update with Pi's IP
+
+        webSocketClient = object : WebSocketClient(serverUri) {
+            override fun onOpen(handshakedata: ServerHandshake?) {
+                reconnectAttempts = 0  // Reset counter on successful connection
+                _isConnected.postValue(true)
+                _connectionStatus.postValue("Connected to Raspberry Pi")
+                _errorMessage.postValue(null)
+                requestWifiPositionUpdates()
+
+                // Cancel reconnection timer since we're connected
+                reconnectionJob?.cancel()
+                reconnectionJob = null
+            }
 
-                currentHeading = Math.toDegrees(orientationAngles[0].toDouble()).toFloat()
+            override fun onMessage(message: String?) {
+                Log.d("WebSocket", "Message received: $message")
+                message?.let {
+                    try {
+                        val json = JSONObject(it)
+                        when (json.getString("type")) {
+                            "wifi_position" -> {
+                                val position = json.getJSONObject("position")
+                                val x = position.getDouble("x").toFloat()
+                                val y = position.getDouble("y").toFloat()
+
+                                // Optional: default confidence to 1.0 if not present
+                                val confidence = if (position.has("confidence")) {
+                                    position.getDouble("confidence").toFloat()
+                                } else {
+                                    1.0f
+                                }
+
+                                _wifiPositionLive.postValue(Pair(x, y))
+                                _wifiConfidence.postValue(confidence)
+                                lastWifiUpdateTime = System.currentTimeMillis()
+
+                                // Update current position with WiFi position
+                                _currentPositionLive.postValue(Pair(x, y))
+
+                                // Update path points with WiFi position
+                                val currentPath = _pathPoints.value ?: listOf()
+                                val updatedPath = currentPath + Pair(x, y)
+                                _pathPoints.postValue(updatedPath)
+                            }
+                        }
+                    } catch (e: Exception) {
+                        Log.e("WebSocket", "Error parsing message: ${e.message}", e)
+                        _errorMessage.postValue("Error parsing message: ${e.message}")
+                    }
+                }
+            }
+
+            override fun onClose(code: Int, reason: String?, remote: Boolean) {
+                _isConnected.postValue(false)
+                _connectionStatus.postValue("Disconnected: $reason")
+
+                // reconnect with exponential backoff
+                if (reconnectAttempts < maxReconnectAttempts) {
+                    reconnectAttempts++
+                }
+
+                startReconnectionTimer()
+            }
+
+            override fun onError(ex: Exception?) {
+                _isConnected.postValue(false)
+                _errorMessage.postValue("WebSocket error: ${ex?.message}")
+                // Attempt reconnect after delay
+                CoroutineScope(Dispatchers.IO).launch {
+                    delay(5000)
+                    connectWebSocket()
+                }
+            }
+        }
 
-                if (currentHeading < 0) {
-                    currentHeading += 360f
+        // connection timeout and handle reconnection
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                delay(10000)
+                if (webSocketClient != null && !_isConnected.value!!) {
+                    _connectionStatus.postValue("Connection timed out")
+                    _errorMessage.postValue("Failed to connect to server")
+                    webSocketClient?.close()
+                    webSocketClient = null
                 }
+            } finally {
+                isReconnecting = false
+            }
+        }
+
+        try {
+            webSocketClient?.connect()
+        } catch (e: Exception) {
+            _errorMessage.postValue("Connection error: ${e.message}")
+            isReconnecting = false
+        }
+    }
 
-                _currentHeadingLive.postValue(currentHeading)
+    private fun requestWifiPositionUpdates(intervalSeconds: Double = 1.0) {
+        val jsonObject = JSONObject()
+        jsonObject.put("type", "start_position_updates")
+        jsonObject.put("interval", intervalSeconds)
+
+        webSocketClient?.let { client ->
+            if (client.isOpen) {
+                client.send(jsonObject.toString())
             }
         }
+    }
 
-        override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
+    fun requestSingleWifiUpdate() {
+        try {
+            val jsonObject = JSONObject()
+            jsonObject.put("type", "single_position_request")
+
+            webSocketClient?.let { client ->
+                if (client.isOpen) {
+                    client.send(jsonObject.toString())
+                }
+            }
+        } catch (e: Exception) {
+            _errorMessage.postValue("Error sending request: ${e.message}")
+        }
     }
 
-    private fun updatePosition() {
-        val adjustedHeading = (currentHeading + 90) % 360
-        val rad = Math.toRadians(adjustedHeading.toDouble())
+    private fun updateLastUpdateText() {
+        if (lastWifiUpdateTime == 0L) {
+            _lastWifiUpdateAgo.postValue("Never")
+            return
+        }
 
-        val deltaX = (stepLength * cos(rad)).toFloat()
-        val deltaY = (stepLength * sin(rad)).toFloat()
+        val age = System.currentTimeMillis() - lastWifiUpdateTime
+        val text = when {
+            age < 1000 -> "Just now"
+            age < 60000 -> "${age / 1000} seconds ago"
+            else -> "${age / 60000} minutes ago"
+        }
 
-        currentPosition = Pair(currentPosition.first + deltaX, currentPosition.second + deltaY)
-        _currentPositionLive.postValue(currentPosition)
-        Log.d("position updated ", "poisiton updated $currentPosition")
-        val updatedPath = _pathPoints.value.orEmpty() + currentPosition
-        _pathPoints.postValue(updatedPath)
+        _lastWifiUpdateAgo.postValue(text)
     }
 
+    // Public functions for controlling the system
     fun startListening() {
-        sensorManager.registerListener(stepListener, stepDetector, SensorManager.SENSOR_DELAY_NORMAL)
-        Log.d("start listen","start listen ")
-
-        sensorManager.registerListener(rotationListener, rotationVector, SensorManager.SENSOR_DELAY_GAME)
+        // Only initialize WebSocket connection - no sensors
+        initWebSocket()
     }
 
     fun stopListening() {
-        sensorManager.unregisterListener(stepListener)
-        sensorManager.unregisterListener(rotationListener)
+        // Close WebSocket connection
+        webSocketClient?.close()
     }
 
     fun resetAll() {
-        _steps.value = 0
-        currentPosition = Pair(0f, 0f)
-        _currentPositionLive.value = currentPosition
-        _pathPoints.value = listOf(currentPosition)
+        // Clear path points
+        _pathPoints.value = listOf()
+
+        // Keep the last WiFi position but reset the path
+        val lastWifiPos = _wifiPositionLive.value ?: Pair(0f, 0f)
+        _currentPositionLive.value = lastWifiPos
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        reconnectionJob?.cancel()
+        webSocketClient?.close()
+        updateTimer.cancel()
+    }
+
+    private fun startReconnectionTimer() {
+        // Cancel any existing job first
+        reconnectionJob?.cancel()
+
+        // Start a new job that periodically attempts to reconnect
+        reconnectionJob = CoroutineScope(Dispatchers.IO).launch {
+            while (isActive && (!_isConnected.value!!)) {
+                // Calculate delay based on reconnect attempts
+                val delayMs = if (reconnectAttempts < maxReconnectAttempts) {
+                    1000L * (1 shl reconnectAttempts) // Exponential backoff
+                } else {
+                    30000L // Once every 30 seconds after max attempts
+                }
+
+                delay(delayMs)
+                if (!_isConnected.value!!) {
+                    _connectionStatus.postValue("Attempting to reconnect...")
+                    connectWebSocket()
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/example/malvoayant/ui/screens/WebSocketClient.kt b/app/src/main/java/com/example/malvoayant/ui/screens/WebSocketClient.kt
index fafbee2..c978b9e 100644
--- a/app/src/main/java/com/example/malvoayant/ui/screens/WebSocketClient.kt
+++ b/app/src/main/java/com/example/malvoayant/ui/screens/WebSocketClient.kt
@@ -1,9 +1,6 @@
 package com.example.malvoayant.ui.screens
 
-
 import android.util.Log
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.ui.geometry.Offset
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -12,20 +9,23 @@ import org.json.JSONObject
 import java.util.concurrent.TimeUnit
 import okhttp3.*
 
-class WebSocketClient(private val url: String) {
+class WebSocketClient(private var url: String) {
     private val TAG = "WebSocketClient"
     private var webSocket: WebSocket? = null
     private val client = OkHttpClient.Builder()
         .readTimeout(0, TimeUnit.MILLISECONDS) // No timeout for reading
         .build()
 
-    // Store path points
-    val pathPoints = mutableStateListOf<Offset>()
-
     // Connection status
     private var isConnected = false
     private var reconnectJob: Job? = null
 
+    // Message handler callback
+    private var onMessageReceived: ((Float, Float) -> Unit)? = null
+
+    // Connection status handler
+    private var onConnectionStatusChanged: ((Boolean) -> Unit)? = null
+
     fun connect() {
         val request = Request.Builder()
             .url(url)
@@ -35,8 +35,7 @@ class WebSocketClient(private val url: String) {
             override fun onOpen(webSocket: WebSocket, response: Response) {
                 Log.d(TAG, "WebSocket connection established")
                 isConnected = true
-                // Reset path on new connection
-                pathPoints.clear()
+                onConnectionStatusChanged?.invoke(true)
             }
 
             override fun onMessage(webSocket: WebSocket, text: String) {
@@ -45,10 +44,10 @@ class WebSocketClient(private val url: String) {
                     val x = json.getDouble("x").toFloat()
                     val y = json.getDouble("y").toFloat()
 
-                    // Add new point to path
+                    // Pass coordinates to handler
                     CoroutineScope(Dispatchers.Main).launch {
-                        pathPoints.add(Offset(x, y))
-                        Log.d(TAG, "Received point: x=$x, y=$y, total points: ${pathPoints.size}")
+                        onMessageReceived?.invoke(x, y)
+                        Log.d(TAG, "Received point: x=$x, y=$y")
                     }
                 } catch (e: Exception) {
                     Log.e(TAG, "Error parsing message: $text", e)
@@ -59,11 +58,13 @@ class WebSocketClient(private val url: String) {
                 Log.d(TAG, "WebSocket closing: $code - $reason")
                 webSocket.close(1000, null)
                 isConnected = false
+                onConnectionStatusChanged?.invoke(false)
             }
 
             override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                 Log.e(TAG, "WebSocket failure", t)
                 isConnected = false
+                onConnectionStatusChanged?.invoke(false)
 
                 // Attempt reconnection
                 reconnect()
@@ -87,5 +88,18 @@ class WebSocketClient(private val url: String) {
         webSocket = null
         reconnectJob?.cancel()
         isConnected = false
+        onConnectionStatusChanged?.invoke(false)
+    }
+
+    fun setMessageHandler(handler: (Float, Float) -> Unit) {
+        onMessageReceived = handler
+    }
+
+    fun setConnectionStatusHandler(handler: (Boolean) -> Unit) {
+        onConnectionStatusChanged = handler
+    }
+
+    fun setUrl(newUrl: String) {
+        url = newUrl
     }
 }
\ No newline at end of file