Edit features using feature forms

/* Copyright 2024 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package com.esri.arcgismaps.sample.editfeaturesusingfeatureforms

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.ArcGISEnvironment
import com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.components.MapViewModel
import com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.screens.MainScreen
import com.esri.arcgismaps.sample.sampleslib.theme.SampleAppTheme

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ArcGISEnvironment.applicationContext = this
        enableEdgeToEdge()
        setContent {
            SampleAppTheme {
                val mapViewModel: MapViewModel = viewModel()
                MainScreen(mapViewModel)
            }
        }
    }
}

/* Copyright 2024 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.components

import android.app.Application
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.unit.dp
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.data.ArcGISFeature
import com.arcgismaps.data.ServiceFeatureTable
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.PortalItem
import com.arcgismaps.mapping.featureforms.FeatureForm
import com.arcgismaps.mapping.featureforms.FeatureFormDefinition
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.arcgismaps.toolkit.featureforms.FeatureFormState
import com.arcgismaps.toolkit.geoviewcompose.MapViewProxy
import com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.R
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import kotlinx.coroutines.launch

/**
 * A view model for the MainScreen UI
 */
class MapViewModel(application: Application) : AndroidViewModel(application) {

    val mapViewProxy = MapViewProxy()

    // feature forms enabled web-map showcasing places of interest with form fields
    private var portalItem = PortalItem(application.getString(R.string.feature_form_web_map))

    val map = ArcGISMap(portalItem)

    // keep track of the selected feature form
    private val _featureFormState = mutableStateOf<FeatureFormState?>(null)
    val featureFormState: FeatureFormState?
        get() = _featureFormState.value

    // create a ViewModel to handle dialog interactions
    val messageDialogVM: MessageDialogViewModel = MessageDialogViewModel()

    init {
        viewModelScope.launch {
            // load a map that has a FeatureFormDefinition on any of its layers
            map.load()
        }
    }

    /**
     * Apply attribute edits to the Geodatabase backing the ServiceFeatureTable
     * and refresh the local feature. Persisting changes to attributes is
     * not part of the FeatureForm API.
     *
     * @param onEditsCompleted Invoked when edits are applied successfully
     */
    fun applyEdits(onEditsCompleted: () -> Unit) {
        val featureForm = featureFormState?.activeFeatureForm
            ?: return messageDialogVM.showMessageDialog("Feature form state is not configured")

        val serviceFeatureTable = featureForm.feature.featureTable as? ServiceFeatureTable
            ?: return messageDialogVM.showMessageDialog("Cannot save feature edit without a ServiceFeatureTable")

        viewModelScope.launch {
            // commits changes of the edited feature to the database
            serviceFeatureTable.serviceGeodatabase?.let { database ->
                if (database.serviceInfo?.canUseServiceGeodatabaseApplyEdits == true) {
                    // applies all local edits in the tables to the service
                    database.applyEdits().onFailure {
                        return@onFailure messageDialogVM.showMessageDialog(
                            title = it.message.toString(),
                            description = it.cause.toString()
                        )
                    }
                } else {
                    // uploads any changes to the local table to the feature service
                    serviceFeatureTable.applyEdits().onFailure {
                        return@onFailure messageDialogVM.showMessageDialog(
                            title = it.message.toString(),
                            description = it.cause.toString()
                        )
                    }
                }
            }
            // resets the attributes and geometry to the values in the data source
            featureForm.feature.refresh()
            // unselect the feature after the edits have been saved
            (featureForm.feature.featureTable?.layer as FeatureLayer).clearSelection()
            // dismiss dialog when edits are completed
            onEditsCompleted()
        }
    }

    /**
     * Unselects the feature from the layer and resets the [featureFormState].
     */
    fun clearSelection() {
        val featureForm = featureFormState?.activeFeatureForm
        (featureForm?.feature?.featureTable?.layer as FeatureLayer).clearSelection()
        _featureFormState.value = null
    }

    /**
     * Perform an identify the tapped [ArcGISFeature] and retrieve the
     * layer's [FeatureFormDefinition] to create the respective [FeatureForm]
     */
    fun onSingleTapConfirmed(singleTapEvent: SingleTapConfirmedEvent) {
        viewModelScope.launch {
            mapViewProxy.identifyLayers(
                screenCoordinate = singleTapEvent.screenCoordinate,
                tolerance = 22.dp,
                returnPopupsOnly = false
            ).onSuccess { results ->
                try {
                    results.forEach { result ->
                        result.geoElements.firstOrNull {
                            it is ArcGISFeature && (it.featureTable?.layer as? FeatureLayer)?.featureFormDefinition != null
                        }?.let {
                            val feature = it as ArcGISFeature
                            val layer = feature.featureTable!!.layer as FeatureLayer
                            val featureForm = FeatureForm(feature)
                            // select the feature
                            layer.selectFeature(feature)
                            // set the UI to an editing state with the FeatureForm
                            _featureFormState.value = FeatureFormState(
                                featureForm = featureForm,
                                coroutineScope = viewModelScope
                            )
                        }
                    }
                } catch (e: Exception) {
                    messageDialogVM.showMessageDialog(
                        title = "Failed to create feature form for the feature",
                        description = e.message.toString()
                    )
                }
            }
        }
    }
}

/* Copyright 2024 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.screens

import android.content.res.Configuration
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.navigationBarsPadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.wrapContentSize
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SheetValue
import androidx.compose.material3.Text
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import com.arcgismaps.toolkit.featureforms.FeatureForm
import com.arcgismaps.toolkit.featureforms.FeatureFormEditingEvent
import com.arcgismaps.toolkit.featureforms.FeatureFormState
import com.arcgismaps.toolkit.featureforms.ValidationErrorVisibility
import com.arcgismaps.toolkit.featureforms.theme.FeatureFormDefaults
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.R
import com.esri.arcgismaps.sample.editfeaturesusingfeatureforms.components.MapViewModel
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar
import com.esri.arcgismaps.sample.sampleslib.theme.SampleAppTheme
import kotlinx.coroutines.launch

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun MainScreen(mapViewModel: MapViewModel) {

    val scope = rememberCoroutineScope()
    // the feature form the currently selected feature
    val featureFormState = mapViewModel.featureFormState

    // boolean trackers for save and discard edits dialogs
    var showSaveEditsDialog by remember { mutableStateOf(false) }
    var showDiscardEditsDialog by remember { mutableStateOf(false) }

    // The bottom sheet state used to control the visibility of the feature form
    val sheetState = rememberModalBottomSheetState(
        confirmValueChange = { sheetValue ->
            if (sheetValue != SheetValue.Hidden) return@rememberModalBottomSheetState true
            if (featureFormState?.hasEdits() == true) {
                // if there are unsaved edits, show the discard edits dialog
                showDiscardEditsDialog = true
                false
            } else {
                true
            }
        }
    )

    Scaffold(
        modifier = Modifier.fillMaxSize(),
        topBar = { SampleTopAppBar(title = stringResource(R.string.edit_features_using_feature_forms_app_name)) }
    ) { padding ->
        // display the composable map using the mapViewModel
        MapView(
            arcGISMap = mapViewModel.map,
            mapViewProxy = mapViewModel.mapViewProxy,
            modifier = Modifier
                .padding(padding)
                .fillMaxSize(),
            onSingleTapConfirmed = { mapViewModel.onSingleTapConfirmed(it) }
        )

        if (featureFormState != null) {
            // display feature form bottom sheet
            ModalBottomSheet(
                onDismissRequest = {
                    // clear the selected feature when the bottom sheet is dismissed
                    mapViewModel.clearSelection()
                },
                sheetState = sheetState
            ) {
                // display the selected feature form using the Toolkit component
                FeatureForm(
                    featureFormState = featureFormState,
                    modifier = Modifier
                        .fillMaxSize()
                        .padding(top = 20.dp)
                        .navigationBarsPadding(),
                    showCloseIcon = true,
                    validationErrorVisibility = ValidationErrorVisibility.Automatic,
                    onDismiss = {
                        // if there are edits, show the discard edits dialog, otherwise hide the
                        // bottom sheet
                        if (featureFormState.hasEdits()) {
                            showDiscardEditsDialog = true
                        } else {
                            scope.launch {
                                sheetState.hide()
                                mapViewModel.clearSelection()
                            }
                        }
                    },
                    onEditingEvent = { event ->
                        when (event) {
                            is FeatureFormEditingEvent.SavedEdits -> {
                                // when the save edits event is received, attempt to apply edits
                                showSaveEditsDialog = true
                                mapViewModel.applyEdits {
                                    showSaveEditsDialog = false
                                }
                            }

                            else -> {}
                        }
                    },
                    colorScheme = FeatureFormDefaults.colorScheme(
                        groupElementColors = FeatureFormDefaults.groupElementColors(
                            outlineColor = MaterialTheme.colorScheme.secondary,
                            labelColor = MaterialTheme.colorScheme.onSurface,
                            supportingTextColor = MaterialTheme.colorScheme.onSurfaceVariant,
                            containerColor = MaterialTheme.colorScheme.surfaceContainer
                        )
                    ),
                    typography = FeatureFormDefaults.typography(
                        readOnlyFieldTypography = FeatureFormDefaults.readOnlyFieldTypography(
                            labelStyle = MaterialTheme.typography.headlineSmall,
                            textStyle = MaterialTheme.typography.bodyMedium,
                            supportingTextStyle = MaterialTheme.typography.labelLarge
                        )
                    )
                )
            }
        }
    }

    if (showSaveEditsDialog) {
        // no validation errors found, show dialog when committing edits
        SaveFormDialog()
    }

    if (showDiscardEditsDialog) {
        DiscardEditsDialog(
            onConfirm = {
                scope.launch {
                    featureFormState?.discardEdits()
                    sheetState.hide()
                    mapViewModel.clearSelection()
                    showDiscardEditsDialog = false
                }
            },
            onCancel = {
                showDiscardEditsDialog = false
            }
        )
    }

    // Display a MessageDialog with any error information
    mapViewModel.messageDialogVM.apply {
        if (dialogStatus) {
            MessageDialog(
                title = messageTitle,
                description = messageDescription,
                onDismissRequest = ::dismissDialog
            )
        }
    }
}

@Composable
fun DiscardEditsDialog(onConfirm: () -> Unit, onCancel: () -> Unit) {
    AlertDialog(
        onDismissRequest = onCancel,
        confirmButton = {
            Button(onClick = onConfirm) {
                Text(text = stringResource(R.string.discard))
            }
        },
        dismissButton = {
            OutlinedButton(onClick = onCancel) {
                Text(text = stringResource(R.string.cancel))
            }
        },
        title = {
            Text(text = stringResource(R.string.discard_edits))
        },
        text = {
            Text(text = stringResource(R.string.all_changes_will_be_lost))
        }
    )
}

@Composable
private fun SaveFormDialog() {
    // show a progress dialog when no errors are present
    Dialog(onDismissRequest = { /* cannot be dismissed */ }) {
        Card(modifier = Modifier.wrapContentSize()) {
            Column(
                modifier = Modifier.padding(25.dp),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.Center,
            ) {
                CircularProgressIndicator()
                Spacer(modifier = Modifier.height(10.dp))
                Text(text = "Saving..")
            }
        }
    }
}

/**
 * Extension function to check if there are unsaved edits in the feature form.
 */
private fun FeatureFormState.hasEdits(): Boolean {
    return this.activeFeatureForm.hasEdits.value
}

@Preview
@Preview(uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
fun SavePreview() {
    SampleAppTheme { SaveFormDialog() }
}

@Preview(showBackground = true)
@Preview(uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
fun DiscardEditsDialogPreview() {
    SampleAppTheme { DiscardEditsDialog(onConfirm = {}) {} }
}