Untitled

when (selectedGeometryType) {
                                "Area" -> {
                                    val pointGraphic = Graphic(mapPoint, pointSymbol)
                                    graphicsOverlay.graphics.add(pointGraphic)
                                    relatedGraphics.add(pointGraphic)

                                    polygonPoints.add(mapPointNotNull)
                                    if (polygonPoints.size > 1) {
                                        val polyline = Polyline(polygonPoints)
                                        val lineGraphic = Graphic(polyline, lineSymbol)
                                        graphicsOverlay.graphics.add(lineGraphic)
                                        relatedGraphics.add(lineGraphic)

                                        // Remove previous text symbols
                                        graphicsOverlay.graphics.removeAll { it.symbol is TextSymbol }

                                        if (polygonPoints.size > 2) {
                                            val polygon = Polygon(polygonPoints)
                                            val polygonGraphic = Graphic(polygon, polygonSymbol)
                                            graphicsOverlay.graphics.add(polygonGraphic)
                                            relatedGraphics.add(polygonGraphic)

                                            val areaValue = GeometryEngine.areaGeodetic(
                                                polygon,
                                                getAreaUnit(selectedUnit),
                                                GeodeticCurveType.Geodesic
                                            )
                                            area = areaValue
                                            areaText = formatMeasurementValue(areaValue, selectedUnit) // Update area text

                                        } else {
                                            val distanceValue = GeometryEngine.lengthGeodetic(
                                                polyline,
                                                getLinearUnit(selectedUnit),
                                                GeodeticCurveType.Geodesic
                                            )
                                            distance = distanceValue
                                            distanceText = formatMeasurementValue(distanceValue, selectedUnit) // Update area text
//                                            distanceTextState.postValue(distanceValue.toString())
                                        }
                                    }
                                }
                                {
                calloutLocation?.let { location ->

                    Callout(location = location, offset = Offset(0f, -50f)) {
                        Text(
                            text = if (selectedGeometryType == "Area") {

                                "${areaText.value} ${originalAreaUnit}"

                            } else {
                                "${distanceText.value} ${originalDistanceUnit}"
//                                distanceText.value
                            }
                        )
                    }
                }
            }private fun updateAreaUnits(value: Double, unit: String) {

        area = when (unit) {

            "Acre" -> {
                if (originalAreaUnit.equals("Hectare")){
                    convertHectareToAcre(area)
                }
                else if (originalAreaUnit.equals("Square Meter")){
                    convertSquareMeterToAcre(area)
                }
                else if (originalAreaUnit.equals("Square Kilometer")){
                    convertSquareKilometerToAcre(area)
                }
                else{
                    convertSquareFootToAcre(area)
                }
            }

            "Hectare" -> {
                if (originalAreaUnit.equals("Acre")){
                    convertAcreToHectare(area)
                }
                else if (originalAreaUnit.equals("Square Meter")){
                    convertSquareMeterToHectare(area)
                }
                else if (originalAreaUnit.equals("Square Kilometer")){
                    convertSquareKilometerToHectare(area)
                }
                else{
                    convertSquareFootToHectare(area)
                }
            }

            "Square Meter" -> {
                if (originalAreaUnit.equals("Acre")){
                    convertAcreToSquareMeter(area)
                }
                else if (originalAreaUnit.equals("Square Meter")){
                    convertHectareToSquareMeter(area)
                }
                else if (originalAreaUnit.equals("Square Kilometer")){
                    convertSquareKilometerToSquareMeter(area)
                }
                else{
                    convertSquareFootToSquareMeter(area)
                }
            }

            "Square Kilometer" -> {
                if (originalAreaUnit.equals("Acre")){
                    convertAcreToSquareKilometer(area)
                }
                else if (originalAreaUnit.equals("Square Meter")){
                    convertHectareToSquareKilometer(area)
                }
                else if (originalAreaUnit.equals("Square Kilometer")){
                    convertSquareMeterToSquareKilometer(area)
                }
                else{
                    convertSquareFootToSquareKilometer(area)
                }
            } originalAreaUnit = unit
//        updateAreaText("$area $unit")
        areaText.value = "%.2f" .format(area)
    }
private fun convertHectareToAcre(area: Double):Double{
        return area * 2.471055
//        return convertHectareToSquareMeter(area) * 0.000247105
    }

    private fun convertHectareToSquareMeter(area: Double):Double{
//        return area * 10000.008840
//        return area * 10_000
        return area * 10000

    }

    private fun convertHectareToSquareKilometer(area: Double):Double{
//        return area * 0.010000008
        return area / 100
//        return convertHectareToSquareMeter(area) / 1_000_000
    }

    private fun convertHectareToSquareFoot(area: Double):Double{
//        return area * 107639.199320
        return convertHectareToSquareMeter(area) * 10.7639
    }

    private fun convertSquareMeterToAcre(area: Double): Double {
        return area * 0.000247105
    }

    private fun convertSquareMeterToHectare(area: Double): Double {
        return area * 0.0001
    }