OsmAnd/OsmAnd-telegram/src/net/osmand/telegram/TelegramSettings.kt

package net.osmand.telegram

import android.content.Context
import android.location.LocationManager
import android.support.annotation.ColorRes
import android.support.annotation.DrawableRes
import android.support.annotation.StringRes
import android.text.SpannableStringBuilder
import android.text.style.ForegroundColorSpan
import com.google.gson.JsonObject
import net.osmand.PlatformUtil
import net.osmand.telegram.helpers.OsmandAidlHelper
import net.osmand.telegram.helpers.ShowLocationHelper
import net.osmand.telegram.helpers.TelegramHelper
import net.osmand.telegram.utils.*
import net.osmand.telegram.utils.OsmandFormatter.MetricsConstants
import net.osmand.telegram.utils.OsmandFormatter.SpeedConstants
import org.drinkless.td.libcore.telegram.TdApi
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject
import java.util.*
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentLinkedQueue
import kotlin.collections.ArrayList


val ADDITIONAL_ACTIVE_TIME_VALUES_SEC = listOf(15 * 60L, 30 * 60L, 60 * 60L, 180 * 60L)

const val SHARE_DEVICES_KEY = "devices"

const val LIVE_TRACKS_KEY = "live_tracks"

private val SEND_MY_LOC_VALUES_SEC =
	listOf(1L, 2L, 3L, 5L, 10L, 15L, 30L, 60L, 90L, 2 * 60L, 3 * 60L, 5 * 60L)
private val STALE_LOC_VALUES_SEC =
	listOf(1 * 60L, 2 * 60L, 5 * 60L, 10 * 60L, 15 * 60L, 30 * 60L, 60 * 60L)
private val LOC_HISTORY_VALUES_SEC = listOf(
	5 * 60L,
	15 * 60L,
	30 * 60L,
	1 * 60 * 60L,
	2 * 60 * 60L,
	3 * 60 * 60L,
	5 * 60 * 60L,
	8 * 60 * 60L,
	12 * 60 * 60L,
	24 * 60 * 60L
)
private val MIN_LOCATION_DISTANCE = listOf(0f, 2.0f, 5.0f, 10.0f, 20.0f, 30.0f, 50.0f)
private val MIN_LOCATION_ACCURACY = listOf(0f, 1.0f, 2.0f, 5.0f, 10.0f, 15.0f, 20.0f, 50.0f, 100.0f)
private val MIN_LOCATION_SPEED = listOf(0f, 0.000001f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f)

const val SHARE_TYPE_MAP = "Map"
const val SHARE_TYPE_TEXT =  "Text"
const val SHARE_TYPE_MAP_AND_TEXT = "Map_and_text"
private val SHARE_TYPE_VALUES = listOf(SHARE_TYPE_MAP, SHARE_TYPE_TEXT, SHARE_TYPE_MAP_AND_TEXT)

private const val SEND_MY_LOC_DEFAULT_INDEX = 6
private const val STALE_LOC_DEFAULT_INDEX = 0
private const val LOC_HISTORY_DEFAULT_INDEX = 7
private const val SHARE_TYPE_DEFAULT_INDEX = 2
private const val MIN_LOCATION_DISTANCE_INDEX = 0
private const val MIN_LOCATION_ACCURACY_INDEX = 0
private const val MIN_LOCATION_SPEED_INDEX = 0

private const val SETTINGS_NAME = "osmand_telegram_settings"

private const val SHARE_LOCATION_CHATS_KEY = "share_location_chats"
private const val HIDDEN_ON_MAP_CHATS_KEY = "hidden_on_map_chats"

private const val SHARING_MODE_KEY = "current_sharing_mode"

private const val METRICS_CONSTANTS_KEY = "metrics_constants"
private const val SPEED_CONSTANTS_KEY = "speed_constants"
private const val UTC_OFFSET_CONSTANTS_KEY = "utc_offset_constants"

private const val SEND_MY_LOC_INTERVAL_KEY = "send_my_loc_interval"
private const val STALE_LOC_TIME_KEY = "stale_loc_time"
private const val LOC_HISTORY_TIME_KEY = "loc_history_time"
private const val SHARE_TYPE_KEY = "share_type"

private const val MIN_LOCATION_DISTANCE_KEY = "min_location_distance"
private const val MIN_LOCATION_ACCURACY_KEY = "min_location_accuracy"
private const val MIN_LOCATION_SPEED_KEY = "min_location_speed"

private const val APP_TO_CONNECT_PACKAGE_KEY = "app_to_connect_package"

private const val DEFAULT_VISIBLE_TIME_SECONDS = 60 * 60L // 1 hour

private const val TITLES_REPLACED_WITH_IDS = "changed_to_chat_id"

private const val LIVE_NOW_SORT_TYPE_KEY = "live_now_sort_type"

private const val SHARE_CHATS_INFO_KEY = "share_chats_info"

private const val BATTERY_OPTIMISATION_ASKED = "battery_optimisation_asked"

private const val MONITORING_ENABLED = "monitoring_enabled"

private const val SHOW_GPS_POINTS = "show_gps_points"

private const val PROXY_ENABLED = "proxy_enabled"
private const val PROXY_PREFERENCES_KEY = "proxy_preferences"

private const val SHARING_INITIALIZATION_TIME = 60 * 2L // 2 minutes
private const val WAITING_TDLIB_TIME = 30 // 2 seconds

private const val GPS_UPDATE_EXPIRED_TIME = 60 * 3L // 3 minutes

private const val LAST_CHATS_INFO_KEY = "last_chats_info"

class TelegramSettings(private val app: TelegramApplication) {

	private val log = PlatformUtil.getLog(TelegramSettings::class.java)

	private var shareChatsInfo = ConcurrentHashMap<Long, ShareChatInfo>()
	private var hiddenOnMapChats: Set<Long> = emptySet()
	private var shareDevices: Set<DeviceBot> = emptySet()
	private var liveTracksInfo = emptyList<LiveTrackInfo>()
	var lastChatsInfo = ConcurrentHashMap<Long, LastChatInfo>()

	var sharingStatusChanges = ConcurrentLinkedQueue<SharingStatus>()

	var currentSharingMode = ""
		private set

	var currentProxyPref: ProxyPref = ProxySOCKS5Pref(-1, "", -1, "", "")
		private set

	var metricsConstants = MetricsConstants.KILOMETERS_AND_METERS
	var speedConstants = SpeedConstants.KILOMETERS_PER_HOUR
	var utcOffset = DataConstants.UTC_FORMAT

	var sendMyLocInterval = SEND_MY_LOC_VALUES_SEC[SEND_MY_LOC_DEFAULT_INDEX]
	var staleLocTime = STALE_LOC_VALUES_SEC[STALE_LOC_DEFAULT_INDEX]
	var locHistoryTime = LOC_HISTORY_VALUES_SEC[LOC_HISTORY_DEFAULT_INDEX]
	var shareTypeValue = SHARE_TYPE_VALUES[SHARE_TYPE_DEFAULT_INDEX]

	var minLocationDistance = MIN_LOCATION_DISTANCE[MIN_LOCATION_DISTANCE_INDEX]
	var minLocationAccuracy = MIN_LOCATION_ACCURACY[MIN_LOCATION_ACCURACY_INDEX]
	var minLocationSpeed = MIN_LOCATION_SPEED[MIN_LOCATION_SPEED_INDEX]

	var appToConnectPackage = ""
		private set

	var liveNowSortType = LiveNowSortType.SORT_BY_DISTANCE

	val gpsAndLocPrefs = listOf(SendMyLocPref(), StaleLocPref(), LocHistoryPref(), ShareTypePref())
	val gpxLoggingPrefs = listOf(MinLocationDistance(), MinLocationAccuracy(), MinLocationSpeed())
	val unitsAndFormatsPrefs = listOf(UnitsOfSpeed(), UnitsOfLength(), UtcOffset())

	var batteryOptimisationAsked = false

	var monitoringEnabled = false

	var showGpsPoints = false

	var proxyEnabled = false

	init {
		updatePrefs()
		read()
		applyProxyPref()
	}

	fun hasAnyChatToShareLocation() = shareChatsInfo.isNotEmpty()

	fun isSharingLocationToChat(chatId: Long) = shareChatsInfo.containsKey(chatId)

	fun isSharingLocationToUser(userId: Int) = shareChatsInfo.values.any { it.userId == userId }

	fun hasAnyChatToShowOnMap() = !hiddenOnMapChats.containsAll(getLiveNowChats())

	fun hasAnyLiveTracksToShowOnMap(): Boolean {
		val time = System.currentTimeMillis() - locHistoryTime * 1000
		val locations = app.locationMessages.getLastLocationMessagesSinceTime(time)
		locations.forEach { loc ->
			if (liveTracksInfo.any { it.userId == loc.userId && it.chatId == loc.chatId && it.deviceName == loc.deviceName }) {
				return true
			}
		}
		return false
	}

	fun getLiveTracksInfo() = liveTracksInfo

	fun getLiveTrackInfo(userId: Int, chatId: Long, deviceName: String) =
		liveTracksInfo.firstOrNull { it.userId == userId && it.chatId == chatId && it.deviceName == deviceName }

	fun isShowingChatOnMap(chatId: Long) = !hiddenOnMapChats.contains(chatId)

	fun isLiveTrackEnabled(userId: Int, chatId: Long, deviceName: String) =
		liveTracksInfo.any { (it.chatId == chatId && it.userId == userId && it.deviceName == deviceName) }

	fun updateLiveTrack(userId: Int, chatId: Long, deviceName: String, enable: Boolean) {
		val tracksInfo = liveTracksInfo.toMutableList()
		if (enable) {
			val colorIndex = if (tracksInfo.size > 0) (tracksInfo.last().colorIndex + 1) % ShowLocationHelper.GPX_COLORS_COUNT else 0
			tracksInfo.add(LiveTrackInfo(userId, chatId, deviceName, colorIndex))
		} else {
			tracksInfo.removeAll { it.userId == userId && it.chatId == chatId && it.deviceName == deviceName }
		}
		liveTracksInfo = tracksInfo.toList()
	}

	fun removeNonexistingChats(presentChatIds: List<Long>) {
		val hiddenChats = hiddenOnMapChats.toMutableList()
		hiddenChats.intersect(presentChatIds)
		hiddenOnMapChats = hiddenChats.toHashSet()

		shareChatsInfo = ConcurrentHashMap(shareChatsInfo.filter { (key, _) -> presentChatIds.contains(key) })
	}

	fun shareLocationToChat(
		chatId: Long,
		share: Boolean,
		livePeriod: Long = DEFAULT_VISIBLE_TIME_SECONDS,
		addActiveTime: Long = ADDITIONAL_ACTIVE_TIME_VALUES_SEC[0]
	) {
		if (share) {
			var shareChatInfo = shareChatsInfo[chatId]
			if (shareChatInfo == null) {
				shareChatInfo = ShareChatInfo()
			}
			val chat = app.telegramHelper.getChat(chatId)
			if (chat != null && (chat.type is TdApi.ChatTypePrivate || chat.type is TdApi.ChatTypeSecret)) {
				shareChatInfo.userId = app.telegramHelper.getUserIdFromChatType(chat.type)
			}
			shareChatInfo.chatId = chatId
			updateChatShareInfo(shareChatInfo, livePeriod, addActiveTime)
			shareChatsInfo[chatId] = shareChatInfo
		} else {
			shareChatsInfo.remove(chatId)
		}
	}

	fun shareLocationToUser(
		userId: Int,
		livePeriod: Long = DEFAULT_VISIBLE_TIME_SECONDS,
		addActiveTime: Long = ADDITIONAL_ACTIVE_TIME_VALUES_SEC[0]
	) {
		val shareChatInfo = ShareChatInfo()
		shareChatInfo.userId = userId
		updateChatShareInfo(shareChatInfo, livePeriod, addActiveTime)
		app.telegramHelper.createPrivateChatWithUser(userId, shareChatInfo, shareChatsInfo)
	}

	fun updateShareDevices(list: List<DeviceBot>) {
		shareDevices = list.toHashSet()
	}

	fun addShareDevice(device: DeviceBot) {
		val devices = shareDevices.toMutableList()
		devices.add(device)
		shareDevices = devices.toHashSet()
	}

	fun updateCurrentSharingMode(sharingMode: String) {
		if (currentSharingMode != sharingMode) {
			shareChatsInfo.forEach { (_, shareInfo) ->
				shareInfo.shouldSendViaBotTextMessage = true
				shareInfo.shouldSendViaBotMapMessage = true
			}
			prepareForSharingNewMessages()
		}
		currentSharingMode = sharingMode
	}

	fun updateCurrentProxyPref(proxyPref: ProxyPref, proxyEnabled: Boolean) {
		this.proxyEnabled = proxyEnabled
		currentProxyPref = proxyPref
		applyProxyPref()
	}

	fun updateProxySetting(enable: Boolean) {
		this.proxyEnabled = enable
		if (enable) {
			app.telegramHelper.enableProxy(currentProxyPref.id)
		} else {
			app.telegramHelper.disableProxy()
		}
	}

	fun applyProxyPref() {
		val proxyId = currentProxyPref.id
		if (proxyId != -1) {
			app.telegramHelper.editProxyPref(currentProxyPref, proxyEnabled)
		} else {
			app.telegramHelper.addProxyPref(currentProxyPref, proxyEnabled)
		}
	}

	fun prepareForSharingNewMessages() {
		shareChatsInfo.forEach { (_, shareInfo) ->
			prepareForSharingNewMessages(shareInfo)
		}
	}

	fun prepareForSharingNewMessages(chatsIds: List<Long>) {
		chatsIds.forEach {
			shareChatsInfo[it]?.also { shareInfo ->
				prepareForSharingNewMessages(shareInfo)
			}
		}
	}

	fun prepareForSharingNewMessages(shareInfo: ShareChatInfo) {
		shareInfo.pendingTdLibText = 0
		shareInfo.pendingTdLibMap = 0
		shareInfo.currentTextMessageId = -1L
		shareInfo.currentMapMessageId = -1L
		shareInfo.pendingTextMessage = false
		shareInfo.pendingMapMessage = false
	}

	fun getChatLivePeriod(chatId: Long) = shareChatsInfo[chatId]?.livePeriod

	fun getChatsShareInfo() = shareChatsInfo

	fun getShareDevices() = shareDevices

	fun containsShareDeviceWithName(name: String): Boolean {
		shareDevices.forEach {
			if (it.deviceName == name) {
				return true
			}
		}
		return false
	}

	fun getCurrentSharingDevice() = shareDevices.singleOrNull { it.externalId == currentSharingMode }

	fun getLastSuccessfulSendTime(): Long {
		val lastSuccessTextSend = shareChatsInfo.values.maxBy { it.lastTextSuccessfulSendTime }?.lastTextSuccessfulSendTime ?: -1
		val lastSuccessMapSend = shareChatsInfo.values.maxBy { it.lastMapSuccessfulSendTime }?.lastMapSuccessfulSendTime ?: -1
		return Math.max(lastSuccessTextSend, lastSuccessMapSend)
	}

	fun stopSharingLocationToChats() {
		shareChatsInfo.clear()
	}

	fun showChatOnMap(chatId: Long, show: Boolean) {
		val hiddenChats = hiddenOnMapChats.toMutableList()
		if (show) {
			hiddenChats.remove(chatId)
		} else {
			hiddenChats.add(chatId)
		}
		hiddenOnMapChats = hiddenChats.toHashSet()
	}

	fun getShareLocationChats() = shareChatsInfo.keys

	fun getShowOnMapChats() = getLiveNowChats().minus(hiddenOnMapChats)

	fun getShowOnMapChatsCount() = getShowOnMapChats().size

	fun clear() {
		stopSharingLocationToChats()
		app.getSharedPreferences(SETTINGS_NAME, Context.MODE_PRIVATE).edit().clear().apply()
	}

	fun updateAppToConnect(appToConnectPackage: String) {
		app.showLocationHelper.stopShowingLocation()
		this.appToConnectPackage = appToConnectPackage
		app.osmandAidlHelper.reconnectOsmand()
	}

	fun updateShareInfo(message: TdApi.Message) {
		val shareInfo = shareChatsInfo[message.chatId]
		val content = message.content
		val isOsmAndBot = app.telegramHelper.isOsmAndBot(OsmandLocationUtils.getSenderMessageId(message)) || app.telegramHelper.isOsmAndBot(message.viaBotUserId)
		if (shareInfo != null) {
			when (content) {
				is TdApi.MessageLocation -> {
					val state = message.sendingState
					if (state != null) {
						if (state.constructor == TdApi.MessageSendingStatePending.CONSTRUCTOR) {
							shareInfo.pendingMapMessage = true
							log.debug("updateShareInfo MAP ${message.id} MessageSendingStatePending")
							shareInfo.oldMapMessageId = message.id
							if (isOsmAndBot) {
								shareInfo.shouldSendViaBotMapMessage = false
							}
						} else if (state.constructor == TdApi.MessageSendingStateFailed.CONSTRUCTOR) {
							shareInfo.hasSharingError = true
							shareInfo.pendingMapMessage = false
							log.debug("updateShareInfo MAP ${message.id} MessageSendingStateFailed")
						}
					} else {
						shareInfo.currentMapMessageId = message.id
						shareInfo.pendingMapMessage = false
						shareInfo.lastMapSuccessfulSendTime = System.currentTimeMillis() / 1000
						if (!isOsmAndBot) {
							shareInfo.pendingTdLibMap--
							if (shareTypeValue == SHARE_TYPE_MAP) {
								shareInfo.sentMessages++
							}
						} else {
							shareInfo.shouldSendViaBotMapMessage = false
						}
						log.debug("updateShareInfo MAP ${message.id} SUCCESS pendingTdLibMap: ${shareInfo.pendingTdLibMap}")
					}
				}
				is TdApi.MessageText -> {
					val state = message.sendingState
					if (state != null) {
						if (state.constructor == TdApi.MessageSendingStatePending.CONSTRUCTOR) {
							log.debug("updateShareInfo TEXT ${message.id} MessageSendingStatePending")
							shareInfo.pendingTextMessage = true
							shareInfo.oldTextMessageId = message.id
							if (isOsmAndBot) {
								shareInfo.shouldSendViaBotTextMessage = false
							}
						} else if (state.constructor == TdApi.MessageSendingStateFailed.CONSTRUCTOR) {
							log.debug("updateShareInfo TEXT ${message.id} MessageSendingStateFailed")
							shareInfo.hasSharingError = true
							shareInfo.pendingTextMessage = false
						}
					} else {
						shareInfo.currentTextMessageId = message.id
						shareInfo.updateTextMessageId++
						shareInfo.pendingTextMessage = false
						shareInfo.lastTextSuccessfulSendTime = System.currentTimeMillis() / 1000
						if (!isOsmAndBot) {
							shareInfo.pendingTdLibText--
							shareInfo.sentMessages++
						} else {
							shareInfo.shouldSendViaBotTextMessage = false
						}
						log.debug("updateShareInfo TEXT ${message.id} SUCCESS pendingTdLibMap: ${shareInfo.pendingTdLibText}")
					}
				}
			}
		}
	}

	fun updateSharingStatusHistory() {
		val newSharingStatus = getNewSharingStatusHistoryItem()

		if (sharingStatusChanges.isNotEmpty()) {
			val lastSharingStatus = sharingStatusChanges.last()
			if (lastSharingStatus.statusType != newSharingStatus.statusType) {
				sharingStatusChanges.add(newSharingStatus)
			} else {
				lastSharingStatus.apply {
					statusChangeTime = newSharingStatus.statusChangeTime
					locationTime = newSharingStatus.locationTime
					chatsIds = newSharingStatus.chatsIds
					title = newSharingStatus.title

					if (statusType == SharingStatusType.INITIALIZING
						&& newSharingStatus.statusType == SharingStatusType.INITIALIZING) {
						if (!description.contains(newSharingStatus.description)) {
							description = "$description, ${newSharingStatus.description}"
						}
					} else {
						description = newSharingStatus.description
					}
				}
			}
		} else {
			sharingStatusChanges.add(newSharingStatus)
		}
	}

	private fun updateChatShareInfo(
		shareChatInfo: ShareChatInfo,
		livePeriod: Long = DEFAULT_VISIBLE_TIME_SECONDS,
		addActiveTime: Long = ADDITIONAL_ACTIVE_TIME_VALUES_SEC[0]
	) {
		val lp: Long = when {
			livePeriod < TelegramHelper.MIN_LOCATION_MESSAGE_LIVE_PERIOD_SEC -> TelegramHelper.MIN_LOCATION_MESSAGE_LIVE_PERIOD_SEC.toLong()
			else -> livePeriod
		}
		val currentTime = System.currentTimeMillis() / 1000
		val user = app.telegramHelper.getCurrentUser()
		if (user != null && currentSharingMode != user.id.toString() && shareChatInfo.start == -1L) {
			shareChatInfo.shouldSendViaBotTextMessage = true
			shareChatInfo.shouldSendViaBotMapMessage = true
		}

		shareChatInfo.start = currentTime
		if (shareChatInfo.livePeriod == -1L) {
			shareChatInfo.livePeriod = lp
		}
		shareChatInfo.userSetLivePeriod = lp
		shareChatInfo.userSetLivePeriodStart = currentTime
		shareChatInfo.currentMessageLimit = currentTime + Math.min(lp, TelegramHelper.MAX_LOCATION_MESSAGE_LIVE_PERIOD_SEC.toLong())
		shareChatInfo.additionalActiveTime = addActiveTime
	}

	private fun getNewSharingStatusHistoryItem(): SharingStatus {
		return SharingStatus().apply {
			statusChangeTime = System.currentTimeMillis()
			val lm = app.getSystemService(Context.LOCATION_SERVICE) as LocationManager
			val gpsEnabled = try {
				if (lm.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
					val loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER)
					val gpsActive = loc != null && ((statusChangeTime - loc.time) / 1000) < GPS_UPDATE_EXPIRED_TIME
					val lastSentLocationExpired = ((statusChangeTime - app.shareLocationHelper.lastLocationUpdateTime) / 1000) > GPS_UPDATE_EXPIRED_TIME
					(gpsActive || !lastSentLocationExpired)
				} else {
					false
				}
			} catch (ex: Exception) {
				false
			}

			var initializing = false
			var sendChatsErrors = false

			shareChatsInfo.forEach { (_, shareInfo) ->
				if (shareInfo.lastTextSuccessfulSendTime == -1L && shareInfo.lastMapSuccessfulSendTime == -1L
					&& ((statusChangeTime / 1000 - shareInfo.start) < SHARING_INITIALIZATION_TIME)) {
					initializing = true
				} else {
					val textSharingError = shareInfo.lastSendTextMessageTime - shareInfo.lastTextSuccessfulSendTime > WAITING_TDLIB_TIME
					val mapSharingError = shareInfo.lastSendMapMessageTime - shareInfo.lastMapSuccessfulSendTime > WAITING_TDLIB_TIME
					if (shareInfo.hasSharingError
						|| (shareTypeValue == SHARE_TYPE_MAP_AND_TEXT && (textSharingError || mapSharingError))
						|| textSharingError && (shareTypeValue == SHARE_TYPE_TEXT)
						|| mapSharingError && (shareTypeValue == SHARE_TYPE_MAP)
					) {
						sendChatsErrors = true
						locationTime = Math.max(shareInfo.lastTextSuccessfulSendTime, shareInfo.lastMapSuccessfulSendTime)
						chatsIds.add(shareInfo.chatId)
					}
				}
			}

			if (sendChatsErrors) {
				title = app.getString(R.string.not_possible_to_send_to_telegram_chats)
				description = app.getString(R.string.last_updated_location)
				statusType = SharingStatusType.NOT_POSSIBLE_TO_SENT_TO_CHATS
			} else if (!initializing) {
				when {
					!gpsEnabled -> {
						locationTime = app.shareLocationHelper.lastLocationUpdateTime / 1000
						if (locationTime <= 0) {
							locationTime = getLastSuccessfulSendTime()
						}
						title = app.getString(R.string.no_gps_connection)
						description = app.getString(R.string.last_updated_location)
						statusType = SharingStatusType.NO_GPS
					}
					!app.isInternetConnectionAvailable -> {
						locationTime = getLastSuccessfulSendTime()
						title = app.getString(R.string.no_internet_connection)
						description = app.getString(R.string.last_updated_location)
						statusType = SharingStatusType.NO_INTERNET
					}
					else -> {
						locationTime = getLastSuccessfulSendTime()
						statusType = SharingStatusType.SENDING
						if (locationTime == -1L) {
							title = app.getString(R.string.sending_location_messages)
							description = app.getString(R.string.waiting_for_response_from_telegram)
						} else {
							title = app.getString(R.string.successfully_sent_and_updated)
							description = app.getString(R.string.last_updated_location)
						}
					}
				}
			} else {
				if (gpsEnabled && app.isInternetConnectionAvailable) {
					title = app.getString(R.string.sending_location_messages)
					description = app.getString(R.string.waiting_for_response_from_telegram)
					statusType = SharingStatusType.SENDING
				} else {
					title = app.getString(R.string.initializing)
					statusType = SharingStatusType.INITIALIZING
					if (!gpsEnabled) {
						description = app.getString(R.string.searching_for_gps)
					} else if (!app.isInternetConnectionAvailable) {
						description = app.getString(R.string.connecting_to_the_internet)
					}
				}
			}
		}
	}

	fun onDeleteLiveMessages(chatId: Long, messages: List<Long>) {
		val currentMapMessageId = shareChatsInfo[chatId]?.currentMapMessageId
		if (messages.contains(currentMapMessageId)) {
			shareChatsInfo[chatId]?.currentMapMessageId = -1
			shareChatsInfo[chatId]?.shouldSendViaBotMapMessage = true
			shareChatsInfo[chatId]?.shouldSendViaBotTextMessage = true
		}
		val currentTextMessageId = shareChatsInfo[chatId]?.currentTextMessageId
		if (messages.contains(currentTextMessageId)) {
			shareChatsInfo[chatId]?.currentTextMessageId = -1
			shareChatsInfo[chatId]?.updateTextMessageId = 1
			shareChatsInfo[chatId]?.shouldSendViaBotMapMessage = true
			shareChatsInfo[chatId]?.shouldSendViaBotTextMessage = true
		}
	}
	
	fun save() {
		val prefs = app.getSharedPreferences(SETTINGS_NAME, Context.MODE_PRIVATE)
		val edit = prefs.edit()

		val hiddenChatsSet = mutableSetOf<String>()
		val hiddenChats = ArrayList(hiddenOnMapChats)
		for (chatId in hiddenChats) {
			hiddenChatsSet.add(chatId.toString())
		}
		edit.putStringSet(HIDDEN_ON_MAP_CHATS_KEY, hiddenChatsSet)

		edit.putString(SHARING_MODE_KEY, currentSharingMode)

		edit.putString(METRICS_CONSTANTS_KEY, metricsConstants.name)
		edit.putString(SPEED_CONSTANTS_KEY, speedConstants.name)
		edit.putString(UTC_OFFSET_CONSTANTS_KEY, utcOffset)

		edit.putLong(SEND_MY_LOC_INTERVAL_KEY, sendMyLocInterval)
		edit.putLong(STALE_LOC_TIME_KEY, staleLocTime)
		edit.putLong(LOC_HISTORY_TIME_KEY, locHistoryTime)

		edit.putFloat(MIN_LOCATION_DISTANCE_KEY, minLocationDistance)
		edit.putFloat(MIN_LOCATION_ACCURACY_KEY, minLocationAccuracy)
		edit.putFloat(MIN_LOCATION_SPEED_KEY, minLocationSpeed)

		edit.putString(SHARE_TYPE_KEY, shareTypeValue)

		edit.putString(APP_TO_CONNECT_PACKAGE_KEY, appToConnectPackage)

		edit.putString(LIVE_NOW_SORT_TYPE_KEY, liveNowSortType.name)

		edit.putBoolean(BATTERY_OPTIMISATION_ASKED, batteryOptimisationAsked)

		edit.putBoolean(MONITORING_ENABLED, monitoringEnabled)

		edit.putBoolean(SHOW_GPS_POINTS, showGpsPoints)

		edit.putBoolean(PROXY_ENABLED, proxyEnabled)

		val jArray = convertShareChatsInfoToJson()
		if (jArray != null) {
			edit.putString(SHARE_CHATS_INFO_KEY, jArray.toString())
		}

		val jsonObject = convertShareDevicesToJson()
		if (jsonObject != null) {
			edit.putString(SHARE_DEVICES_KEY, jsonObject.toString())
		}

		val jsonObjectProxy = convertProxyPrefToJson()
		if (jsonObjectProxy != null) {
			edit.putString(PROXY_PREFERENCES_KEY, jsonObjectProxy.toString())
		}

		val jsonArrayLiveTracks = convertLiveTracksInfoToJson()
		if (jsonArrayLiveTracks != null) {
			edit.putString(LIVE_TRACKS_KEY, jsonArrayLiveTracks.toString())
		}

		val jArrayLastInfo = convertLastChatsInfoToJson()
		if (jArrayLastInfo != null) {
			edit.putString(LAST_CHATS_INFO_KEY, jArrayLastInfo.toString())
		}

		edit.apply()
	}

	fun read() {
		val prefs = app.getSharedPreferences(SETTINGS_NAME, Context.MODE_PRIVATE)

		val hiddenChats = mutableSetOf<Long>()
		val hiddenChatsSet = prefs.getStringSet(HIDDEN_ON_MAP_CHATS_KEY, mutableSetOf())
		for (chatId in hiddenChatsSet) {
			hiddenChats.add(chatId.toLong())
		}
		hiddenOnMapChats = hiddenChats

		metricsConstants = MetricsConstants.valueOf(
			prefs.getString(METRICS_CONSTANTS_KEY, MetricsConstants.KILOMETERS_AND_METERS.name)
		)
		speedConstants = SpeedConstants.valueOf(
			prefs.getString(SPEED_CONSTANTS_KEY, SpeedConstants.KILOMETERS_PER_HOUR.name)
		)
		utcOffset = prefs.getString(UTC_OFFSET_CONSTANTS_KEY, DataConstants.UTC_FORMAT)

		try {
			parseShareChatsInfo(JSONArray(prefs.getString(SHARE_CHATS_INFO_KEY, "")))
		} catch (e: JSONException) {
			e.printStackTrace()
		}

		try {
			parseLastChatsInfo(JSONArray(prefs.getString(LAST_CHATS_INFO_KEY, "")))
		} catch (e: JSONException) {
			log.error(e)
		}

		parseShareDevices(prefs.getString(SHARE_DEVICES_KEY, ""))

		val sendMyLocDef = SEND_MY_LOC_VALUES_SEC[SEND_MY_LOC_DEFAULT_INDEX]
		sendMyLocInterval = prefs.getLong(SEND_MY_LOC_INTERVAL_KEY, sendMyLocDef)
		val staleLocDef = STALE_LOC_VALUES_SEC[STALE_LOC_DEFAULT_INDEX]
		staleLocTime = prefs.getLong(STALE_LOC_TIME_KEY, staleLocDef)
		val locHistoryDef = LOC_HISTORY_VALUES_SEC[LOC_HISTORY_DEFAULT_INDEX]
		locHistoryTime = prefs.getLong(LOC_HISTORY_TIME_KEY, locHistoryDef)
		val shareTypeDef = SHARE_TYPE_VALUES[SHARE_TYPE_DEFAULT_INDEX]
		shareTypeValue = prefs.getString(SHARE_TYPE_KEY, shareTypeDef)

		val minLocationDistanceDef = MIN_LOCATION_DISTANCE[MIN_LOCATION_DISTANCE_INDEX]
		minLocationDistance = prefs.getFloat(MIN_LOCATION_DISTANCE_KEY, minLocationDistanceDef)
		val minLocationPrecisionDef = MIN_LOCATION_ACCURACY[MIN_LOCATION_ACCURACY_INDEX]
		minLocationAccuracy = prefs.getFloat(MIN_LOCATION_ACCURACY_KEY, minLocationPrecisionDef)
		val minLocationSpeedDef = MIN_LOCATION_SPEED[MIN_LOCATION_SPEED_INDEX]
		minLocationSpeed = prefs.getFloat(MIN_LOCATION_SPEED_KEY, minLocationSpeedDef)

		val currentUserId = app.telegramHelper.getCurrentUserId()
		currentSharingMode = prefs.getString(SHARING_MODE_KEY, if (currentUserId != -1) currentUserId.toString() else "")

		val defPackage = if (AppConnect.getInstalledApps(app).size == 1) AppConnect.getInstalledApps(app).first().appPackage else ""
		appToConnectPackage = prefs.getString(APP_TO_CONNECT_PACKAGE_KEY, defPackage)

		liveNowSortType = LiveNowSortType.valueOf(
			prefs.getString(LIVE_NOW_SORT_TYPE_KEY, LiveNowSortType.SORT_BY_DISTANCE.name)
		)

		batteryOptimisationAsked = prefs.getBoolean(BATTERY_OPTIMISATION_ASKED,false)

		monitoringEnabled = prefs.getBoolean(MONITORING_ENABLED,false)

		showGpsPoints = prefs.getBoolean(SHOW_GPS_POINTS, false)

		proxyEnabled = prefs.getBoolean(PROXY_ENABLED, false)
		try {
			parseProxyPreferences(JSONObject(prefs.getString(PROXY_PREFERENCES_KEY, "")))
		} catch (e: JSONException) {
			log.error(e)
		}

		try {
			parseLiveTracks(JSONArray(prefs.getString(LIVE_TRACKS_KEY, "")))
		} catch (e: JSONException) {
			log.error(e)
		}
	}

	private fun convertShareDevicesToJson():JSONObject?{
		return try {
			val jsonObject = JSONObject()
			val jArray = JSONArray()
			shareDevices.forEach { device ->
				val obj = JSONObject()
				obj.put(DeviceBot.DEVICE_ID, device.id)
				obj.put(DeviceBot.USER_ID, device.userId)
				obj.put(DeviceBot.CHAT_ID, device.chatId)
				obj.put(DeviceBot.DEVICE_NAME, device.deviceName)
				obj.put(DeviceBot.EXTERNAL_ID, device.externalId)
				obj.put(DeviceBot.DATA, JSONObject(device.data))
				jArray.put(obj)
			}
			jsonObject.put(SHARE_DEVICES_KEY, jArray)
		} catch (e: JSONException) {
			e.printStackTrace()
			null
		}
	}

	private fun convertLiveTracksInfoToJson(): JSONArray? {
		return try {
			JSONArray().apply {
				liveTracksInfo.forEach { liveTrackInfo ->
					val obj = JSONObject()
					obj.put(LiveTrackInfo.USER_ID, liveTrackInfo.userId)
					obj.put(LiveTrackInfo.CHAT_ID, liveTrackInfo.chatId)
					obj.put(LiveTrackInfo.DEVICE_NAME, liveTrackInfo.deviceName)
					obj.put(LiveTrackInfo.COLOR_INDEX, liveTrackInfo.colorIndex)
					put(obj)
				}
			}
		} catch (e: JSONException) {
			log.error(e)
			null
		}
	}

	private fun convertProxyPrefToJson(): JSONObject? {
		return try {
			val proxyPref = currentProxyPref
			JSONObject().apply {
				put(ProxyPref.PROXY_ID, proxyPref.id)
				put(ProxyPref.TYPE_ID, proxyPref.type)
				put(ProxyPref.SERVER_ID, proxyPref.server)
				put(ProxyPref.PORT_ID, proxyPref.port)
				if (proxyPref is ProxyMTProtoPref) {
					put(ProxyMTProtoPref.KEY_ID, proxyPref.key)
				} else if (proxyPref is ProxySOCKS5Pref) {
					put(ProxySOCKS5Pref.LOGIN_ID, proxyPref.login)
					put(ProxySOCKS5Pref.PASSWORD_ID, proxyPref.password)
				}
			}
		} catch (e: JSONException) {
			e.printStackTrace()
			null
		}
	}

	private fun convertShareChatsInfoToJson(): JSONArray? {
		return try {
			val jArray = JSONArray()
			shareChatsInfo.forEach { (chatId, chatInfo) ->
				val obj = JSONObject()
				obj.put(ShareChatInfo.CHAT_ID_KEY, chatId)
				obj.put(ShareChatInfo.USER_ID_KEY, chatInfo.userId)
				obj.put(ShareChatInfo.START_KEY, chatInfo.start)
				obj.put(ShareChatInfo.LIVE_PERIOD_KEY, chatInfo.livePeriod)
				obj.put(ShareChatInfo.LIMIT_KEY, chatInfo.currentMessageLimit)
				obj.put(ShareChatInfo.UPDATE_TEXT_MESSAGE_ID_KEY, chatInfo.updateTextMessageId)
				obj.put(ShareChatInfo.CURRENT_MAP_MESSAGE_ID_KEY, chatInfo.currentMapMessageId)
				obj.put(ShareChatInfo.CURRENT_TEXT_MESSAGE_ID_KEY, chatInfo.currentTextMessageId)
				obj.put(ShareChatInfo.USER_SET_LIVE_PERIOD_KEY, chatInfo.userSetLivePeriod)
				obj.put(ShareChatInfo.USER_SET_LIVE_PERIOD_START_KEY, chatInfo.userSetLivePeriodStart)
				obj.put(ShareChatInfo.LAST_TEXT_SUCCESSFUL_SEND_TIME_KEY, chatInfo.lastTextSuccessfulSendTime)
				obj.put(ShareChatInfo.LAST_MAP_SUCCESSFUL_SEND_TIME_KEY, chatInfo.lastMapSuccessfulSendTime)
				obj.put(ShareChatInfo.LAST_SEND_MAP_TIME_KEY, chatInfo.lastSendMapMessageTime)
				obj.put(ShareChatInfo.LAST_SEND_TEXT_TIME_KEY, chatInfo.lastSendTextMessageTime)
				obj.put(ShareChatInfo.PENDING_TEXT_MESSAGE_KEY, chatInfo.pendingTextMessage)
				obj.put(ShareChatInfo.PENDING_MAP_MESSAGE_KEY, chatInfo.pendingMapMessage)
				obj.put(ShareChatInfo.SENT_MESSAGES_KEY, chatInfo.sentMessages)
				jArray.put(obj)
			}
			jArray
		} catch (e: JSONException) {
			log.error(e)
			null
		}
	}

	private fun convertLastChatsInfoToJson(): JSONArray? {
		return try {
			val jArray = JSONArray()
			lastChatsInfo.forEach { (chatId, lastInfo) ->
				val obj = JSONObject()
				obj.put(LastChatInfo.CHAT_ID_KEY, chatId)
				obj.put(LastChatInfo.LIVE_PERIOD_KEY, lastInfo.livePeriod)
				obj.put(LastChatInfo.PERIODS_KEY, convertPeriodsToJson(lastInfo.periods))
				log.info("Periods to put: ${lastInfo.periods}")
				jArray.put(obj)
			}
			jArray
		} catch (e: JSONException) {
			log.error(e)
			null
		}
	}

	private fun convertPeriodsToJson(periods: LinkedList<Long>): JSONArray? {
		return try {
			val jArray = JSONArray()
			for (i in 0 until periods.count()) {
				val obj = JSONObject()
				obj.put(i.toString(), periods[i])
				jArray.put(obj)
			}
			log.info("Json array periods: $jArray")
			jArray
		} catch (e: JSONException) {
			log.error(e)
			null
		}
	}

	private fun parseShareChatsInfo(json: JSONArray) {
		for (i in 0 until json.length()) {
			val obj = json.getJSONObject(i)
			val shareInfo = ShareChatInfo().apply {
				chatId = obj.optLong(ShareChatInfo.CHAT_ID_KEY)
				userId = obj.optInt(ShareChatInfo.USER_ID_KEY)
				start = obj.optLong(ShareChatInfo.START_KEY)
				livePeriod = obj.optLong(ShareChatInfo.LIVE_PERIOD_KEY)
				currentMessageLimit = obj.optLong(ShareChatInfo.LIMIT_KEY)
				updateTextMessageId = obj.optInt(ShareChatInfo.UPDATE_TEXT_MESSAGE_ID_KEY)
				currentMapMessageId = obj.optLong(ShareChatInfo.CURRENT_MAP_MESSAGE_ID_KEY)
				currentTextMessageId = obj.optLong(ShareChatInfo.CURRENT_TEXT_MESSAGE_ID_KEY)
				userSetLivePeriod = obj.optLong(ShareChatInfo.USER_SET_LIVE_PERIOD_KEY)
				userSetLivePeriodStart = obj.optLong(ShareChatInfo.USER_SET_LIVE_PERIOD_START_KEY)
				lastTextSuccessfulSendTime = obj.optLong(ShareChatInfo.LAST_TEXT_SUCCESSFUL_SEND_TIME_KEY)
				lastMapSuccessfulSendTime = obj.optLong(ShareChatInfo.LAST_MAP_SUCCESSFUL_SEND_TIME_KEY)
				lastSendMapMessageTime = obj.optInt(ShareChatInfo.LAST_SEND_MAP_TIME_KEY)
				lastSendTextMessageTime = obj.optInt(ShareChatInfo.LAST_SEND_TEXT_TIME_KEY)
				pendingTextMessage = obj.optBoolean(ShareChatInfo.PENDING_TEXT_MESSAGE_KEY)
				pendingMapMessage = obj.optBoolean(ShareChatInfo.PENDING_MAP_MESSAGE_KEY)
				sentMessages = obj.optInt(ShareChatInfo.SENT_MESSAGES_KEY)
			}
			shareChatsInfo[shareInfo.chatId] = shareInfo
		}
	}

	private fun parseProxyPreferences(jsonObject: JSONObject) {
		val proxyId = jsonObject.optInt(ProxyPref.PROXY_ID)
		val typeString = jsonObject.optString(ProxyPref.TYPE_ID)
		val server = jsonObject.optString(ProxyPref.SERVER_ID)
		val port = jsonObject.optInt(ProxyPref.PORT_ID)
		val proxyPref = when {
			ProxyType.valueOf(typeString) == ProxyType.MTPROTO -> {
				val key = jsonObject.optString(ProxyMTProtoPref.KEY_ID)
				ProxyMTProtoPref(proxyId, server, port, key)
			}
			ProxyType.valueOf(typeString) == ProxyType.SOCKS5 -> {
				val login = jsonObject.optString(ProxySOCKS5Pref.LOGIN_ID)
				val password = jsonObject.optString(ProxySOCKS5Pref.PASSWORD_ID)
				ProxySOCKS5Pref(proxyId, server, port, login, password)
			}
			else -> null
		}
		if (proxyPref != null) {
			currentProxyPref = proxyPref
		}
	}

	private fun parseLiveTracks(json: JSONArray) {
		val list = mutableListOf<LiveTrackInfo>()
		for (i in 0 until json.length()) {
			val obj = json.getJSONObject(i)
			val userId = obj.optInt(LiveTrackInfo.USER_ID)
			val chatId = obj.optLong(LiveTrackInfo.CHAT_ID)
			val deviceName = obj.optString(LiveTrackInfo.DEVICE_NAME)
			val colorIndex = obj.optInt(LiveTrackInfo.COLOR_INDEX)

			list.add(LiveTrackInfo(userId, chatId, deviceName, colorIndex))
		}
		liveTracksInfo = list.toList()
	}

	private fun parseShareDevices(json: String) {
		shareDevices = OsmandApiUtils.parseJsonContents(json).toHashSet()
	}

	private fun parseLastChatsInfo(json: JSONArray) {
		for (i in 0 until json.length()) {
			val obj = json.getJSONObject(i)
			val lastInfo = LastChatInfo().apply {
				chatId = obj.optLong(LastChatInfo.CHAT_ID_KEY)
//				livePeriod = obj.optLong(LastChatInfo.LIVE_PERIOD_KEY)
				periods = LinkedList<Long>()
				val jsonArray = obj.getJSONArray(LastChatInfo.PERIODS_KEY)
				log.info("getJson: $jsonArray")
				for (j in 0 until jsonArray.length()) {
					val obj=jsonArray.get(j) as JSONObject

					periods.add(obj.optLong(j.toString()))
				}
				log.info("Periods: $periods")
				livePeriod = calcLivePeriod(periods)
			}
			lastChatsInfo[lastInfo.chatId] = lastInfo
		}
	}

	fun addTimePeriodToLastItem(id: Long, time: Long) {
		if (lastChatsInfo.containsKey(id)) {
			lastChatsInfo[id]?.periods = addTimeToPeriods(lastChatsInfo[id]?.periods, time)
		} else {
			lastChatsInfo[id] = LastChatInfo().apply {
				chatId = id
				livePeriod = time
				periods = LinkedList<Long>().apply {
					addFirst(time)
				}
			}
		}
	}

	private fun addTimeToPeriods(periods: LinkedList<Long>?, time: Long): LinkedList<Long> {
		if (periods?.isNotEmpty() != null) {
			return if (periods.count() < 5) {
				periods.addFirst(time)
				periods
			} else {
				periods.removeLast()
				periods.addFirst(time)
				periods
			}
		}
		return LinkedList<Long>().apply { addFirst(time) }
	}

	private fun calcLivePeriod(periods: LinkedList<Long>): Long {
		periods.sort()
		return if (periods.count() % 2 == 0) {
			(periods[periods.count() / 2] + periods[periods.count() / 2 - 1]) / 2
		} else {
			periods[periods.count() / 2]
		}
	}

	private fun getLiveNowChats() = app.telegramHelper.getMessagesByChatIds(locHistoryTime).keys

	private fun updatePrefs() {
		val prefs = app.getSharedPreferences(SETTINGS_NAME, Context.MODE_PRIVATE)
		val idsInUse = prefs.getBoolean(TITLES_REPLACED_WITH_IDS, false)
		if (!idsInUse) {
			val edit = prefs.edit()

			edit.putStringSet(SHARE_LOCATION_CHATS_KEY, emptySet())
			edit.putBoolean(TITLES_REPLACED_WITH_IDS, true)

			edit.apply()
		}
	}

	inner class SendMyLocPref : ListPreference(
		R.drawable.ic_action_share_location,
		R.string.send_my_location,
		R.string.send_my_location_desc
	) {

		override fun getCurrentValue() =
			OsmandFormatter.getFormattedDuration(app, sendMyLocInterval)

		override fun setCurrentValue(index: Int) {
			sendMyLocInterval = SEND_MY_LOC_VALUES_SEC[index]
			app.updateSendLocationInterval()
		}

		override fun getMenuItems() =
			SEND_MY_LOC_VALUES_SEC.map { OsmandFormatter.getFormattedDuration(app, it) }
	}

	inner class StaleLocPref : ListPreference(
		R.drawable.ic_action_time_span,
		R.string.stale_location,
		R.string.stale_location_desc
	) {

		override fun getCurrentValue() =
			OsmandFormatter.getFormattedDuration(app, staleLocTime)

		override fun setCurrentValue(index: Int) {
			staleLocTime = STALE_LOC_VALUES_SEC[index]
		}

		override fun getMenuItems() =
			STALE_LOC_VALUES_SEC.map { OsmandFormatter.getFormattedDuration(app, it) }
	}

	inner class LocHistoryPref : ListPreference(
		R.drawable.ic_action_location_history,
		R.string.location_history,
		R.string.location_history_desc
	) {

		override fun getCurrentValue() =
			OsmandFormatter.getFormattedDuration(app, locHistoryTime)

		override fun setCurrentValue(index: Int) {
			val value = LOC_HISTORY_VALUES_SEC[index]
			locHistoryTime = value
			app.telegramHelper.messageActiveTimeSec = value
		}

		override fun getMenuItems() =
			LOC_HISTORY_VALUES_SEC.map { OsmandFormatter.getFormattedDuration(app, it) }
	}

	inner class ShareTypePref : ListPreference(
		R.drawable.ic_action_location_history,
		R.string.send_location_as,
		R.string.send_location_as_descr
	) {

		override fun getCurrentValue(): String {
			return getTextValue(shareTypeValue)
		}

		override fun setCurrentValue(index: Int) {
			val newSharingType = SHARE_TYPE_VALUES[index]
			if (shareTypeValue != newSharingType && app.telegramHelper.getCurrentUser()?.id.toString() != currentSharingMode) {
				shareChatsInfo.forEach { (_, shareInfo) ->
					shareInfo.shouldSendViaBotTextMessage = true
					shareInfo.shouldSendViaBotMapMessage = true
				}
			}
			shareTypeValue = newSharingType
		}

		override fun getMenuItems(): List<String> {
			return SHARE_TYPE_VALUES.map { getTextValue(it) }
		}

		private fun getTextValue(shareType: String): String {
			return when (shareType) {
				SHARE_TYPE_MAP -> app.getString(R.string.shared_string_map)
				SHARE_TYPE_TEXT -> app.getString(R.string.shared_string_text)
				SHARE_TYPE_MAP_AND_TEXT -> app.getString(R.string.map_and_text)
				else -> ""
			}
		}
	}

	inner class MinLocationDistance :
		ListPreference(0, R.string.min_logging_distance, R.string.min_logging_distance_descr) {

		override fun getCurrentValue() = getFormattedValue(minLocationDistance)

		override fun setCurrentValue(index: Int) {
			minLocationDistance = MIN_LOCATION_DISTANCE[index]
		}

		override fun getMenuItems() = MIN_LOCATION_DISTANCE.map { getFormattedValue(it) }

		private fun getFormattedValue(value: Float): String {
			return if (value == 0f) app.getString(R.string.shared_string_select)
			else OsmandFormatter.getFormattedDistance(value, app)
		}
	}

	inner class MinLocationAccuracy :
		ListPreference(0, R.string.min_logging_accuracy, R.string.min_logging_accuracy_descr) {

		override fun getCurrentValue() = getFormattedValue(minLocationAccuracy)

		override fun setCurrentValue(index: Int) {
			minLocationAccuracy = MIN_LOCATION_ACCURACY[index]
		}

		override fun getMenuItems() = MIN_LOCATION_ACCURACY.map { getFormattedValue(it) }

		private fun getFormattedValue(value: Float): String {
			return if (value == 0f) app.getString(R.string.shared_string_select)
			else OsmandFormatter.getFormattedDistance(value, app)
		}
	}

	inner class MinLocationSpeed :
		ListPreference(0, R.string.min_logging_speed, R.string.min_logging_speed_descr) {

		override fun getCurrentValue() = getFormattedValue(minLocationSpeed)

		override fun setCurrentValue(index: Int) {
			minLocationSpeed = MIN_LOCATION_SPEED[index]
		}

		override fun getMenuItems() = MIN_LOCATION_SPEED.map { getFormattedValue(it) }

		private fun getFormattedValue(value: Float): String {
			return when (value) {
				MIN_LOCATION_SPEED[0] -> app.getString(R.string.shared_string_select)
				MIN_LOCATION_SPEED[1] -> "> 0"
				else -> OsmandFormatter.getFormattedSpeed(value, app)
			}
		}
	}

	inner class UnitsOfSpeed : ListPreference(
		R.drawable.ic_action_speed,
		R.string.unit_of_speed_system,
		R.string.unit_of_speed_system_descr
	) {

		override fun getCurrentValue() = speedConstants.toShortString(app)

		override fun setCurrentValue(index: Int) {
			speedConstants = SpeedConstants.values()[index]
		}

		override fun getMenuItems() = SpeedConstants.values().map { it.toShortString(app) }
	}

	inner class UnitsOfLength : ListPreference(
		R.drawable.ic_action_ruler_unit, R.string.unit_of_length,
		R.string.unit_of_length_descr
	) {

		override fun getCurrentValue() = metricsConstants.toHumanString(app)

		override fun setCurrentValue(index: Int) {
			metricsConstants = MetricsConstants.values()[index]
		}

		override fun getMenuItems() = MetricsConstants.values().map { it.toHumanString(app) }
	}

	inner class UtcOffset : ListPreference(
		R.drawable.ic_world_globe_dark, R.string.time_zone,
		R.string.time_zone_descr
	) {
		private val formattedUtcOffsets = DataConstants.utcOffsets.keys.toList()

		override fun getCurrentValue() = utcOffset

		override fun setCurrentValue(index: Int) {
			utcOffset = formattedUtcOffsets[index]
		}

		override fun getMenuItems() = formattedUtcOffsets
	}

	abstract inner class ListPreference(
		@DrawableRes val iconId: Int,
		@StringRes val titleId: Int,
		@StringRes val descriptionId: Int
	) {

		abstract fun getCurrentValue(): String

		abstract fun setCurrentValue(index: Int)

		abstract fun getMenuItems(): List<String>
	}

	enum class AppConnect(
		@DrawableRes val iconId: Int,
		@DrawableRes val whiteIconId: Int,
		val title: String,
		val appPackage: String,
		val showOnlyInstalled: Boolean
	) {
		OSMAND_PLUS(
			R.drawable.ic_logo_osmand_plus,
			R.drawable.ic_action_osmand_plus,
			"OsmAnd+",
			OsmandAidlHelper.OSMAND_PLUS_PACKAGE_NAME,
			false
		),
		OSMAND_FREE(
			R.drawable.ic_logo_osmand_free,
			R.drawable.ic_action_osmand_free,
			"OsmAnd",
			OsmandAidlHelper.OSMAND_FREE_PACKAGE_NAME,
			false
		),
		OSMAND_NIGHTLY(
			R.drawable.ic_logo_osmand_nightly,
			R.drawable.ic_action_osmand_free,
			"OsmAnd Nightly",
			OsmandAidlHelper.OSMAND_NIGHTLY_PACKAGE_NAME,
			true
		);

		companion object {

			@DrawableRes
			fun getWhiteIconId(appPackage: String): Int {
				for (item in values()) {
					if (item.appPackage == appPackage) {
						return item.whiteIconId
					}
				}
				return 0
			}

			@DrawableRes
			fun getIconId(appPackage: String): Int {
				for (item in values()) {
					if (item.appPackage == appPackage) {
						return item.iconId
					}
				}
				return 0
			}

			fun getInstalledApps(context: Context) =
				values().filter { AndroidUtils.isAppInstalled(context, it.appPackage) }
		}
	}

	enum class LiveNowSortType(
		@DrawableRes val iconId: Int,
		@StringRes val titleId: Int,
		@StringRes val shortTitleId: Int
	) {
		SORT_BY_GROUP(
			R.drawable.ic_action_sort_by_group,
			R.string.shared_string_group,
			R.string.by_group
		),
		SORT_BY_NAME(
			R.drawable.ic_action_sort_by_name,
			R.string.shared_string_name,
			R.string.by_name
		),
		SORT_BY_DISTANCE(
			R.drawable.ic_action_sort_by_distance,
			R.string.shared_string_distance,
			R.string.by_distance
		);

		fun isSortByGroup() = this == SORT_BY_GROUP
	}

	enum class SharingStatusType(
		@DrawableRes val iconId: Int,
		@ColorRes val iconColorRes: Int,
		val canResendLocation: Boolean
	) {
		NO_INTERNET(
			R.drawable.ic_action_wifi_off,
			R.color.sharing_status_icon_error,
			true
		),
		SENDING(
			R.drawable.ic_action_share_location,
			R.color.sharing_status_icon_success,
			false
		),
		NOT_POSSIBLE_TO_SENT_TO_CHATS(
			R.drawable.ic_action_message_send_error,
			R.color.sharing_status_icon_error,
			true
		),
		NO_GPS(
			R.drawable.ic_action_location_off,
			R.color.sharing_status_icon_error,
			false
		),
		INITIALIZING(
			R.drawable.ic_action_connect,
			R.color.sharing_status_icon_error,
			false
		);
	}

	class DeviceBot {
		var id: Long = -1
		var userId: Long = -1
		var chatId: Long = -1
		var deviceName: String = ""
		var externalId: String = ""
		var data: String = ""

		companion object {

			internal const val DEVICE_ID = "id"
			internal const val USER_ID = "userId"
			internal const val CHAT_ID = "chatId"
			internal const val DEVICE_NAME = "deviceName"
			internal const val EXTERNAL_ID = "externalId"
			internal const val DATA = "data"
		}
	}

	data class LiveTrackInfo(val userId: Int, val chatId: Long, val deviceName: String, val colorIndex: Int) {
		companion object {

			internal const val USER_ID = "userId"
			internal const val CHAT_ID = "chatId"
			internal const val DEVICE_NAME = "deviceName"
			internal const val COLOR_INDEX = "colorIndex"
		}
	}

	enum class ProxyType {
		MTPROTO, SOCKS5
	}

	abstract class ProxyPref(
		var id: Int,
		var type: ProxyType,
		open var server: String,
		open var port: Int
	) {
		companion object {
			internal const val PROXY_ID = "proxyId"
			internal const val TYPE_ID = "type"
			internal const val SERVER_ID = "serverId"
			internal const val PORT_ID = "portId"
		}
	}

	class ProxyMTProtoPref(id: Int, server: String, port: Int, var key: String) :
		ProxyPref(id, ProxyType.MTPROTO, server, port) {
		companion object {
			internal const val KEY_ID = "key"
		}
	}

	class ProxySOCKS5Pref(
		id: Int,
		server: String,
		port: Int,
		var login: String,
		var password: String
	) :
		ProxyPref(id, ProxyType.SOCKS5, server, port) {
		companion object {
			internal const val LOGIN_ID = "login"
			internal const val PASSWORD_ID = "password"
		}
	}

	class SharingStatus {

		var title: String = ""
		var description: String = ""
		var locationTime: Long = -1
		var statusChangeTime: Long = -1
		var chatsIds: MutableList<Long> = mutableListOf()

		lateinit var statusType: SharingStatusType

		fun getTitle(app: TelegramApplication): CharSequence {
			return if (statusType != SharingStatusType.NOT_POSSIBLE_TO_SENT_TO_CHATS || chatsIds.isEmpty()) {
				title
			} else {
				val spannableString = SpannableStringBuilder(title)
				val iterator = chatsIds.iterator()
				while (iterator.hasNext()) {
					val chatId = iterator.next()
					val chatTitle = app.telegramHelper.getChat(chatId)?.title
					if (chatTitle != null) {
						val start = spannableString.length
						val newSpannable = if (iterator.hasNext()) " @$chatTitle," else " @$chatTitle."
						spannableString.append(newSpannable)
						spannableString.setSpan(ForegroundColorSpan(app.uiUtils.getActiveColor()), start, spannableString.length - 1, 0)
					}
				}
				spannableString
			}
		}
	}

	class ShareChatInfo {

		var chatId = -1L
		var userId = -1
		var start = -1L
		var livePeriod = -1L
		var updateTextMessageId = 1
		var currentMessageLimit = -1L
		var currentMapMessageId = -1L
		var oldMapMessageId = -1L
		var currentTextMessageId = -1L
		var oldTextMessageId = -1L
		var userSetLivePeriod = -1L
		var userSetLivePeriodStart = -1L
		var lastTextSuccessfulSendTime = -1L
		var lastMapSuccessfulSendTime = -1L
		var lastSendTextMessageTime = -1
		var lastSendMapMessageTime = -1
		var sentMessages = 0
		var pendingTdLibText = 0
		var pendingTdLibMap = 0
		var pendingTextMessage = false
		var pendingMapMessage = false
		var shouldSendViaBotTextMessage = false
		var shouldSendViaBotMapMessage = false
		var hasSharingError = false
		var additionalActiveTime = ADDITIONAL_ACTIVE_TIME_VALUES_SEC[0]

		fun getNextAdditionalActiveTime(): Long {
			var index = ADDITIONAL_ACTIVE_TIME_VALUES_SEC.indexOf(additionalActiveTime)
			return if (ADDITIONAL_ACTIVE_TIME_VALUES_SEC.lastIndex > index) {
				ADDITIONAL_ACTIVE_TIME_VALUES_SEC[++index]
			} else {
				ADDITIONAL_ACTIVE_TIME_VALUES_SEC[index]
			}
		}

		fun getChatLiveMessageExpireTime(): Long {
			return userSetLivePeriod - ((System.currentTimeMillis() / 1000) - start)
		}

		companion object {

			internal const val CHAT_ID_KEY = "chatId"
			internal const val USER_ID_KEY = "userId"
			internal const val START_KEY = "start"
			internal const val LIVE_PERIOD_KEY = "livePeriod"
			internal const val LIMIT_KEY = "limit"
			internal const val UPDATE_TEXT_MESSAGE_ID_KEY = "updateTextMessageId"
			internal const val CURRENT_MAP_MESSAGE_ID_KEY = "currentMapMessageId"
			internal const val CURRENT_TEXT_MESSAGE_ID_KEY = "currentTextMessageId"
			internal const val USER_SET_LIVE_PERIOD_KEY = "userSetLivePeriod"
			internal const val USER_SET_LIVE_PERIOD_START_KEY = "userSetLivePeriodStart"
			internal const val LAST_MAP_SUCCESSFUL_SEND_TIME_KEY = "lastMapSuccessfulSendTime"
			internal const val LAST_TEXT_SUCCESSFUL_SEND_TIME_KEY = "lastTextSuccessfulSendTime"
			internal const val LAST_SEND_MAP_TIME_KEY = "lastSendMapMessageTime"
			internal const val LAST_SEND_TEXT_TIME_KEY = "lastSendTextMessageTime"
			internal const val PENDING_TEXT_MESSAGE_KEY = "pendingTextMessage"
			internal const val PENDING_MAP_MESSAGE_KEY = "pendingMapMessage"
			internal const val SENT_MESSAGES_KEY = "sentMessages"
		}
	}

	class LastChatInfo {

		var chatId = -1L
		var livePeriod = -1L
		var periods = LinkedList<Long>()

		companion object {
			internal const val CHAT_ID_KEY = "chatId"
			internal const val LIVE_PERIOD_KEY = "livePeriod"
			internal const val PERIODS_KEY = "periods"
		}
	}
}