Configure electronic navigational charts

/* 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.configureelectronicnavigationalcharts.components

import android.app.Application
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.unit.dp
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.hydrography.EncAreaSymbolizationType
import com.arcgismaps.hydrography.EncCell
import com.arcgismaps.hydrography.EncColorScheme
import com.arcgismaps.hydrography.EncEnvironmentSettings
import com.arcgismaps.hydrography.EncExchangeSet
import com.arcgismaps.hydrography.EncFeature
import com.arcgismaps.hydrography.EncPointSymbolizationType
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.layers.EncLayer
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.R
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import com.arcgismaps.toolkit.geoviewcompose.MapViewProxy
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import java.io.File

class ConfigureElectronicNavigationalChartsScreenViewModel(application: Application) :
    AndroidViewModel(application) {
    private val provisionPath: String by lazy {
        application.getExternalFilesDir(null)?.path.toString() +
                File.separator +
                application.getString(R.string.configure_electronic_navigational_charts_app_name)
    }

    // Paths to ENC data and hydrology resources
    private val encResourcesPath = provisionPath + application.getString(R.string.enc_res_dir)
    private val encDataPath = provisionPath + application.getString(R.string.enc_data_dir)

    // Create an ENC exchange set from the local ENC data
    private val encExchangeSet = EncExchangeSet(listOf(encDataPath))
    private val encEnvironmentSettings: EncEnvironmentSettings = EncEnvironmentSettings
    private val encMarinerSettings = encEnvironmentSettings.displaySettings.marinerSettings

    // Create an empty map, to be updated once ENC data is loaded
    var arcGISMap by mutableStateOf(ArcGISMap())

    // Passed to the composable MapView to support identify operations.
    val mapViewProxy = MapViewProxy()

    private val _selectedEncFeature = MutableStateFlow<EncFeature?>(null)
    val selectedEncFeature = _selectedEncFeature.asStateFlow()

    var currentColorScheme by mutableStateOf(encMarinerSettings.colorScheme)
        private set

    var currentAreaSymbolizationType by mutableStateOf(encMarinerSettings.areaSymbolizationType)
        private set

    var currentPointSymbolizationType by mutableStateOf(encMarinerSettings.pointSymbolizationType)
        private set

    // Create a message dialog view model for handling error messages
    val messageDialogVM = MessageDialogViewModel()

    init {
        // Provide ENC environment with location of ENC resources and configure SENC caching location
        encEnvironmentSettings.resourcePath = encResourcesPath
        encEnvironmentSettings.sencDataPath = application.externalCacheDir?.path
        configureEncDisplaySettings()

        viewModelScope.launch {
            encExchangeSet.load().onSuccess {

                // Set the map to the oceans basemap style, and initial viewpoint
                arcGISMap = ArcGISMap(BasemapStyle.ArcGISOceans).apply {
                    initialViewpoint = Viewpoint(-32.5, 60.95, 67e3)
                }

                encExchangeSet.datasets.forEach { encDataset ->
                    // Create a layer for each ENC dataset and add it to the map
                    val encCell = EncCell(encDataset)
                    val encLayer = EncLayer(encCell)
                    arcGISMap.operationalLayers.add(encLayer)

                    encLayer.load().onFailure { error -> messageDialogVM.showMessageDialog(error) }
                }
            }.onFailure { error -> messageDialogVM.showMessageDialog(error) }
        }
    }

    fun updateColorScheme(colorScheme: EncColorScheme) {
        encMarinerSettings.colorScheme = colorScheme
        currentColorScheme = colorScheme
    }

    fun updateAreaSymbolizationType(areaSymbolizationType: EncAreaSymbolizationType) {
        encMarinerSettings.areaSymbolizationType = areaSymbolizationType
        currentAreaSymbolizationType = areaSymbolizationType
    }

    fun updatePointSymbolizationType(pointSymbolizationType: EncPointSymbolizationType) {
        encMarinerSettings.pointSymbolizationType = pointSymbolizationType
        currentPointSymbolizationType = pointSymbolizationType
    }

    /**
     * Identifies the ENC feature at the tapped screen coordinate and selects it for display.
     */
    fun identify(singleTapConfirmedEvent: SingleTapConfirmedEvent) {
        arcGISMap.operationalLayers.filterIsInstance<EncLayer>().forEach { encLayer ->
            encLayer.clearSelection()
        }
        viewModelScope.launch {
            mapViewProxy.identifyLayers(singleTapConfirmedEvent.screenCoordinate, 10.dp)
                .onSuccess { identifyResults ->
                    val encIdentifyResult = identifyResults.firstOrNull {
                        it.geoElements.filterIsInstance<EncFeature>().isNotEmpty()
                    }
                    val encLayer = encIdentifyResult?.layerContent as? EncLayer
                    val encFeature = encIdentifyResult?.geoElements
                        ?.filterIsInstance<EncFeature>()
                        ?.firstOrNull()
                    if (encLayer != null && encFeature != null) {
                        encLayer.selectFeature(encFeature)
                        _selectedEncFeature.value = encFeature
                    } else {
                        _selectedEncFeature.value = null
                    }
                }.onFailure { error ->
                    _selectedEncFeature.value = null
                    messageDialogVM.showMessageDialog(error)
                }
        }
    }

    override fun onCleared() {
        super.onCleared()
        encEnvironmentSettings.resourcePath = null
        encEnvironmentSettings.sencDataPath = null
        encEnvironmentSettings.displaySettings.marinerSettings.resetToDefaults()
        encEnvironmentSettings.displaySettings.textGroupVisibilitySettings.resetToDefaults()
        encEnvironmentSettings.displaySettings.viewingGroupSettings.resetToDefaults()
    }

    /**
     * Disables a subset of text and viewing groups so the charts start less cluttered.
     */
    private fun configureEncDisplaySettings() {
        encEnvironmentSettings.displaySettings.textGroupVisibilitySettings.apply {
            includeGeographicNames = false
            includeNatureOfSeabed = false
        }

        encEnvironmentSettings.displaySettings.viewingGroupSettings.apply {
            includeDepthContours = false
            includeLights = false
            includeSpotSoundings = false
        }

        currentColorScheme = encMarinerSettings.colorScheme
        currentAreaSymbolizationType = encMarinerSettings.areaSymbolizationType
        currentPointSymbolizationType = encMarinerSettings.pointSymbolizationType
    }
}

val colorSchemes: List<EncColorScheme> = listOf(
    EncColorScheme.Day, EncColorScheme.Dusk, EncColorScheme.Night
)
val areaSymbolizationTypes: List<EncAreaSymbolizationType> = listOf(
    EncAreaSymbolizationType.Plain, EncAreaSymbolizationType.Symbolized
)
val pointSymbolizationTypes: List<EncPointSymbolizationType> = listOf(
    EncPointSymbolizationType.PaperChart, EncPointSymbolizationType.Simplified
)

/* 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.configureelectronicnavigationalcharts

import android.content.Intent
import android.os.Bundle
import com.esri.arcgismaps.sample.sampleslib.DownloaderActivity

class DownloadActivity : DownloaderActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        downloadAndStartSample(
            Intent(this, MainActivity::class.java),
            // get the app name of the sample
            getString(R.string.configure_electronic_navigational_charts_app_name),
            listOf(
                // ArcGIS Portal item containing ENC hydrography resources
                "https://www.arcgis.com/home/item.html?id=5028bf3513ff4c38b28822d010a4937c",
                // ArcGIS Portal item containing the ENC dataset
                "https://www.arcgis.com/home/item.html?id=9d2987a825c646468b3ce7512fb76e2d"
            )
        )
    }
}

/* 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.configureelectronicnavigationalcharts

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.esri.arcgismaps.sample.sampleslib.theme.SampleAppTheme
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.screens.ConfigureElectronicNavigationalChartsScreen

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        enableEdgeToEdge()
        setContent {
            SampleAppTheme {
                SampleApp()
            }
        }
    }

    @Composable
    private fun SampleApp() {
        Surface(
            color = MaterialTheme.colorScheme.background
        ) {
            ConfigureElectronicNavigationalChartsScreen(
                sampleName = getString(R.string.configure_electronic_navigational_charts_app_name)
            )
        }
    }
}

/* 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.configureelectronicnavigationalcharts.screens

import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.geometry.Point
import com.arcgismaps.hydrography.EncAreaSymbolizationType
import com.arcgismaps.hydrography.EncColorScheme
import com.arcgismaps.hydrography.EncPointSymbolizationType
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.components.ConfigureElectronicNavigationalChartsScreenViewModel
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.components.areaSymbolizationTypes
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.components.colorSchemes
import com.esri.arcgismaps.sample.configureelectronicnavigationalcharts.components.pointSymbolizationTypes
import com.esri.arcgismaps.sample.sampleslib.components.DropDownMenuBox
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar

/**
 * Main screen layout for the sample app
 */
@Composable
fun ConfigureElectronicNavigationalChartsScreen(sampleName: String) {
    // create a ViewModel to handle MapView interactions
    val mapViewModel: ConfigureElectronicNavigationalChartsScreenViewModel = viewModel()
    val selectedEncFeature by mapViewModel.selectedEncFeature.collectAsStateWithLifecycle()
    var isSettingsDialogVisible by remember { mutableStateOf(false) }
    var tapLocation by remember { mutableStateOf<Point?>(null) }

    Scaffold(
        topBar = { SampleTopAppBar(title = sampleName) },
        content = {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(it),
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                MapView(
                    modifier = Modifier
                        .fillMaxSize()
                        .weight(1f),
                    arcGISMap = mapViewModel.arcGISMap,
                    mapViewProxy = mapViewModel.mapViewProxy,
                    onSingleTapConfirmed = { tapEvent ->
                        tapLocation = tapEvent.mapPoint
                        mapViewModel.identify(tapEvent)
                    }
                ) {
                    selectedEncFeature?.let { encFeature ->
                        tapLocation?.let { location ->
                            Callout(location = location) {
                                Column {
                                    Text(encFeature.acronym)
                                    Text(encFeature.description)
                                }
                            }
                        }
                    }
                }
                OutlinedButton(
                    modifier = Modifier.padding(12.dp),
                    onClick = { isSettingsDialogVisible = true }
                ) { Text("Display Settings") }

                DisplaySettingsContent(
                    isSettingsDialogVisible = isSettingsDialogVisible,
                    currentColorScheme = mapViewModel.currentColorScheme,
                    currentAreaSymbolizationType = mapViewModel.currentAreaSymbolizationType,
                    currentPointSymbolizationType = mapViewModel.currentPointSymbolizationType,
                    onColorSchemeSelected = mapViewModel::updateColorScheme,
                    onAreaSymbolizationSelected = mapViewModel::updateAreaSymbolizationType,
                    onPointSymbolizationSelected = mapViewModel::updatePointSymbolizationType,
                    onDismiss = { isSettingsDialogVisible = false }
                )
            }

            mapViewModel.messageDialogVM.apply {
                if (dialogStatus) {
                    MessageDialog(
                        title = messageTitle,
                        description = messageDescription,
                        onDismissRequest = ::dismissDialog
                    )
                }
            }
        }
    )
}

@Composable
fun DisplaySettingsContent(
    isSettingsDialogVisible: Boolean,
    currentColorScheme: EncColorScheme,
    currentAreaSymbolizationType: EncAreaSymbolizationType,
    currentPointSymbolizationType: EncPointSymbolizationType,
    onColorSchemeSelected: (EncColorScheme) -> Unit,
    onAreaSymbolizationSelected: (EncAreaSymbolizationType) -> Unit,
    onPointSymbolizationSelected: (EncPointSymbolizationType) -> Unit,
    onDismiss: () -> Unit,
) {
    AnimatedVisibility(isSettingsDialogVisible) {
        SampleDialog(onDismissRequest = onDismiss) {
            Text("Display Settings", style = MaterialTheme.typography.titleMedium)
            DropDownMenuBox(
                modifier = Modifier.fillMaxWidth(),
                textFieldLabel = "Color Scheme",
                textFieldValue = currentColorScheme.javaClass.simpleName,
                dropDownItemList = colorSchemes.map { it.javaClass.simpleName },
                onIndexSelected = { index -> onColorSchemeSelected(colorSchemes[index]) }
            )
            DropDownMenuBox(
                modifier = Modifier.fillMaxWidth(),
                textFieldLabel = "Area Symbolization Type",
                textFieldValue = currentAreaSymbolizationType.javaClass.simpleName,
                dropDownItemList = areaSymbolizationTypes.map { it.javaClass.simpleName },
                onIndexSelected = { index -> onAreaSymbolizationSelected(areaSymbolizationTypes[index]) }
            )
            DropDownMenuBox(
                modifier = Modifier.fillMaxWidth(),
                textFieldLabel = "Point Symbolization Type",
                textFieldValue = currentPointSymbolizationType.javaClass.simpleName,
                dropDownItemList = pointSymbolizationTypes.map { it.javaClass.simpleName },
                onIndexSelected = { index -> onPointSymbolizationSelected(pointSymbolizationTypes[index]) }
            )
        }
    }
}