@OptIn(ExperimentalSheetApi::class, ExperimentalPermissionsApi::class)
@SuppressLint("UnrememberedMutableState", "UnusedMaterialScaffoldPaddingParameter")
@Composable
fun SearchParkingMainScreen(
    viewModel: SearchParkingViewModel
) {
    val viewState by viewModel.uiState.collectAsState()
    var showErrorMessageBottomSheet by rememberSaveable { mutableStateOf(false) }
    var isBottomSheetClosed by rememberSaveable { mutableStateOf(true) }
    val roundedCornerRadius = 20.dp
    val sheetShape =
        RoundedCornerShape(topStart = roundedCornerRadius, topEnd = roundedCornerRadius)
    val locationPermissionState =
        rememberMultiplePermissionsState(
            listOf(
                Manifest.permission.ACCESS_FINE_LOCATION,
                Manifest.permission.ACCESS_COARSE_LOCATION
            )
        )
    Scaffold(
        backgroundColor = Color_F6F6F6,
        topBar = {
        },
        content = {
            Box {
                if (isBottomSheetClosed) {
                    FeatureRequirePermission(
                        viewModel = viewModel,
                        locationPermissionState = locationPermissionState,
                        modifier = Modifier.fillMaxSize(),
                        openErrorSheet = { showErrorMessageBottomSheet = true },
                        closeErrorSheet = { showErrorMessageBottomSheet = false }
                    )
                }
            }
        }
    )

    ModalSheet(
        visible = showErrorMessageBottomSheet,
        shape = sheetShape,
        elevation = 0.dp,
        backgroundColor = pure_white_color,
        onVisibleChange = { showErrorMessageBottomSheet = it }
    ) {
        val descriptionMessage = when (viewState.isPermissionPermanentlyDenied) {
            true -> R.string.permanently_decline_permission_message
            false -> R.string.first_time_decline_permission_message
            null -> R.string.app_name
        }
        val confirmationButtonText = when (viewState.isPermissionPermanentlyDenied) {
            true -> R.string.open_setting_button_title
            false -> R.string.grant_permission_title
            else -> parking.R.string.app_name
        }

        PermissionDeniedActionBottomSheet(
            onDismiss = {
                showErrorMessageBottomSheet = false
                isBottomSheetClosed = false
            },
            title = stringResource(id = R.string.permission_not_allowed_title),
            errorMessage = stringResource(id = descriptionMessage),
            actionOneText = stringResource(id = R.string.common_button_cancel),
            actionTwoText = stringResource(id = confirmationButtonText),
            event = viewModel::handleCommonStateEvents,
            rePermissionInvoke = {
                isBottomSheetClosed = true
                locationPermissionState.launchMultiplePermissionRequest()
            },
            settingInvoke = navigateToSetting(),
            isPermissionPermanentlyDenied = viewState.isPermissionPermanentlyDenied,
            setupToDefaultState = {
                isBottomSheetClosed = true
            }
        )
    }
    if (showErrorMessageBottomSheet) {
        viewModel.resetBottomSheetState()
    }
}

@OptIn(ExperimentalPermissionsApi::class)
@Composable
fun FeatureRequirePermission(
    viewModel: SearchParkingViewModel,
    locationPermissionState: MultiplePermissionsState,
    modifier: Modifier,
    openErrorSheet: () -> Unit = {},
    closeErrorSheet: () -> Unit = {}
) {
    val doNotShowRationale by rememberSaveable { mutableStateOf(false) }
    var firstTime by rememberSaveable { mutableStateOf(true) }

    PermissionsRequired(
        multiplePermissionsState = locationPermissionState,
        permissionsNotGrantedContent = {
            if (doNotShowRationale) {
                Text("Feature not available")
            } else {
                Column(
                    modifier = Modifier
                        .fillMaxSize()
                        .padding(20.dp),
                    verticalArrangement = Arrangement.Center,
                    horizontalAlignment = Alignment.CenterHorizontally
                ) {
                    if (firstTime) {
                        locationPermissionState.launchMultiplePermissionRequest()
                        firstTime = false
                    } else {
                        viewModel.showLocationDenyBottomSheet(isPermanentlyDeny = false)
                        openErrorSheet.invoke()
                        return@PermissionsRequired
                    }
                }
            }
        },
        permissionsNotAvailableContent = {
            viewModel.showLocationDenyBottomSheet(isPermanentlyDeny = true)
            openErrorSheet.invoke()
            return@PermissionsRequired
        },
        content = {
            closeErrorSheet.invoke()
            viewModel.fetchLocation(LocalContext.current)
            val location = viewModel.location.value
            Log.e("current->", location?.latitude.toString() + "Long" + location?.longitude)
            MainMapView(
                modifier = modifier,
                longitude = location?.longitude,
                latitude = location?.latitude
            )
        }
    )
}

@Composable
fun MainMapView(modifier: Modifier, longitude: Double?, latitude: Double?) {
    var uiSettings by remember { mutableStateOf(MapUiSettings()) }
    val properties by remember { mutableStateOf(MapProperties(mapType = MapType.SATELLITE)) }
    val location = LatLng(latitude ?: 25.204849, longitude ?: 55.270782)
    val cameraPositionState = rememberCameraPositionState {
        position = CameraPosition.fromLatLngZoom(location, 17f)
    }

    Column(modifier = modifier, horizontalAlignment = Alignment.CenterHorizontally) {
        GoogleMap(
            modifier = Modifier
                .fillMaxWidth()
                .fillMaxHeight(),
            properties = properties,
            uiSettings = uiSettings,
            cameraPositionState = cameraPositionState
        ) {
            Marker(
                state = MarkerState(position = location),
                title = "Current Location",
                snippet = "Location"
            )
        }
        Switch(
            checked = uiSettings.zoomControlsEnabled,
            onCheckedChange = {
                uiSettings = uiSettings.copy(zoomControlsEnabled = it)
            }
        )
    }
}