using Serilog.Events;
using System;
using TINK.Model.Services.Geolocation;
using TINK.Services.BluetoothLock;
using TINK.Services.CopriApi.ServerUris;
using TINK.Settings;
using TINK.ViewModel.Map;
using TINK.ViewModel.Settings;


namespace TINK.Model.Settings
{
    /// <summary> Holds settings which are persisted.</summary>
    public class Settings
    {
        public const LogEventLevel DEFAULTLOGGINLEVEL = LogEventLevel.Error;

        // Default value of the expires after entry. Controls the expiration time of the cache values.
        private TimeSpan DEFAULTEXPIRESAFTER = TimeSpan.FromSeconds(1);

        /// <summary> Constructs settings object. </summary>
        /// <param name="groupFilterMapPage">filter which is applied on the map view. Either TINK or Konrad stations are displayed.</param>
        /// <param name="groupFilterSettings"></param>
        /// <param name="activeUri"></param>
        /// <param name="pollingParameters"></param>
        /// <param name="minimumLogEventLevel">Minimum logging level to be applied.</param>
        /// <param name="expiresAfter">Holds the expires after value.</param>
        /// <param name="activeLockService">Gets the name of the lock service to use.</param>
        /// <param name="connectTimeout">Timeout to apply when connecting to bluetooth lock</param>
        /// <param name="activeTheme">Full class name of active app theme.</param>
        public Settings(
            IGroupFilterMapPage groupFilterMapPage = null,
            IGroupFilterSettings groupFilterSettings = null,
            Uri activeUri = null,
            PollingParameters pollingParameters = null,
            LogEventLevel? minimumLogEventLevel = null,
            TimeSpan? expiresAfter = null,
            string activeLockService = null,
            TimeSpan? connectTimeout = null,
            string activeGeolocationService = null,
            bool? centerMapToCurrentLocation = null,
            bool? logToExternalFolder = null,
            bool? isSiteCachingOn = null,
            string activeTheme = null)
        {
            GroupFilterMapPage = groupFilterMapPage ?? GroupFilterHelper.GetMapPageFilterDefaults;
            GroupFilterSettings = groupFilterSettings ?? GroupFilterHelper.GetSettingsFilterDefaults;
            ActiveUri = GetActiveUri(activeUri);
            PollingParameters = pollingParameters ?? PollingParameters.Default;
            MinimumLogEventLevel = minimumLogEventLevel ?? DEFAULTLOGGINLEVEL;
            ExpiresAfter = expiresAfter ?? DEFAULTEXPIRESAFTER;
            ActiveLockService = activeLockService ?? LocksServicesContainerMutable.DefaultLocksservice;
            ConnectTimeout = connectTimeout ?? new TimeSpan(0, 0, TimeOutProvider.DEFAULT_BLUETOOTHCONNECT_TIMEOUTSECONDS); // Try one sec. to connect. 
            ActiveGeolocationService = activeGeolocationService ?? typeof(LastKnownGeolocationService).Name;
            CenterMapToCurrentLocation = centerMapToCurrentLocation ?? GetCenterMapToCurrentLocation(activeUri);
            LogToExternalFolder = logToExternalFolder ?? false;
            IsSiteCachingOn = isSiteCachingOn ?? true;
            ActiveTheme = activeTheme ?? typeof(Themes.ShareeBike).FullName;
        }

        /// <summary> Holds the filter which is applied on the map view. Either TINK or Konrad stations are displayed. </summary>
        public IGroupFilterMapPage GroupFilterMapPage { get; }

        /// <summary> Holds the filters loaded from settings. </summary>
        public IGroupFilterSettings GroupFilterSettings { get; }

        /// <summary> Holds the uri to connect to. </summary>
        public Uri ActiveUri { get; }

        /// <summary> Holds the polling parameters. </summary>
        public PollingParameters PollingParameters { get; }

        /// <summary> Gets the minimum logging level. </summary>
        public LogEventLevel MinimumLogEventLevel { get; }

        /// <summary> Gets the expires after value.</summary>
        public TimeSpan ExpiresAfter { get; }

        /// <summary> Gets the lock service to use.</summary>
        public string ActiveLockService { get; private set; }

        /// <summary> Timeout to apply when connecting to bluetooth lock.</summary>
        public TimeSpan ConnectTimeout { get; }

        /// <summary> Gets the geolocation service to use.</summary>
        public string ActiveGeolocationService { get; }

        public bool CenterMapToCurrentLocation { get; }

        public bool LogToExternalFolder { get; }

        public bool IsSiteCachingOn { get; }

        public string ActiveTheme { get; }

        public static Uri GetActiveUri(Uri activeUri) => activeUri ?? Services.CopriApi.ServerUris.CopriServerUriList.DefaultActiveUri;

        public static bool GetCenterMapToCurrentLocation(Uri activeUri)
        {
            // TINK does not require acess to current location. Deactivate center map to current location for this reason. 
            return !GetActiveUri(activeUri).Host.GetIsCopri();
        }
    }
}