using TINK.Model.Bike;
using System.Collections.Specialized;
using System.ComponentModel;
using TINK.Model.User;
using System.Threading.Tasks;
using TINK.Model.Connector;
using TINK.Settings;
using System;
using Serilog;
using System.Threading;
using TINK.Model;
using TINK.View;
using Xamarin.Forms;
using System.Linq;
using TINK.Model.Bike.BluetoothLock;
using System.Collections.Generic;
using TINK.Services.BluetoothLock;
using TINK.Model.Services.Geolocation;
using TINK.ViewModel.Bikes;
using TINK.Services.BluetoothLock.Tdo;
using Plugin.BLE.Abstractions.Contracts;
using TINK.MultilingualResources;
using TINK.Services.Permissions;
using TINK.Model.Station;
using TINK.Model.Device;

namespace TINK.ViewModel.BikesAtStation
{
    /// <summary>
    /// Manages one or more bikes which are located at a single station.
    /// </summary>
    public class BikesAtStationPageViewModel : BikesViewModel, INotifyCollectionChanged, INotifyPropertyChanged
    {
        /// <summary>
        /// Holds the selected station;
        /// </summary>
        private readonly IStation m_oStation;

        /// <summary> Holds a reference to the external trigger service. </summary>
        private Action<string> OpenUrlInExternalBrowser { get; }

        /// <summary>
        /// Constructs bike collection view model.
        /// </summary>
        /// <param name="user">Mail address of active user.</param>
        /// <param name="isReportLevelVerbose">True if report level is verbose, false if not.</param>
        /// <param name="permissions">Holds object to query location permisions.</param>
        /// <param name="bluetoothLE">Holds object to query bluetooth state.</param>
        /// <param name="runtimPlatform">Specifies on which platform code is run.</param>
        /// <param name="isConnectedDelegate">Returns if mobile is connected to web or not.</param>
        /// <param name="p_oConnector">Connects system to copri.</param>
        /// <param name="lockService">Service to control lock retrieve info.</param>
        /// <param name="polling"> Holds whether to poll or not and the periode leght is polling is on. </param>
        /// <param name="l_oBikesAll">All bikes at given station.</param>
        /// <param name="openUrlInExternalBrowser">Action to open an external browser.</param>
        /// <param name="postAction">Executes actions on GUI thread.</param>
        /// <param name="smartDevice">Provides info about the smart device (phone, tablet, ...).</param>
        /// <param name="viewService">Interface to actuate methodes on GUI.</param>
        public BikesAtStationPageViewModel(
            User user,
            ILocationPermission permissions,
            IBluetoothLE bluetoothLE,
            string runtimPlatform,
            IStation selectedStation,
            Func<bool> isConnectedDelegate,
            Func<bool, IConnector> connectorFactory,
            IGeolocation geolocation,
            ILocksService lockService,
            PollingParameters polling,
            Action<string> openUrlInExternalBrowser,
            Action<SendOrPostCallback, object> postAction,
            ISmartDevice smartDevice,
            IViewService viewService) : base(user, permissions, bluetoothLE, runtimPlatform, isConnectedDelegate, connectorFactory, geolocation, lockService, polling, postAction, smartDevice, viewService, () => new  BikeAtStationInUseStateInfoProvider())
        {
            OpenUrlInExternalBrowser = openUrlInExternalBrowser
                ?? throw new ArgumentException("Can not instantiate login page view model- object. No user external browse service available.");

            m_oStation = selectedStation;

            Title = string.Format(m_oStation?.StationName != null
                ? m_oStation.StationName
                : string.Empty);
            
            StationDetailText = string.Format(m_oStation?.Id != null
                ? string.Format(AppResources.MarkingBikesAtStationStationId, m_oStation.Id)
                : string.Empty); ;

            CollectionChanged += (sender, eventargs) =>
            {
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsNoBikesAtStationVisible)));
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(NoBikesAtStationText)));
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsLoginRequiredHintVisible)));
            };
        }

        /// <summary>
        /// Name of the station which is displayed as title of the page.
        /// </summary>
        public string Title
        {
            get; private set;
        }

        /// <summary>
        /// Informs about need to log in before requesting an bike.
        /// </summary>
        public bool IsLoginRequiredHintVisible
        {
            get
            {
                return Count > 0 
                    && !ActiveUser.IsLoggedIn;
            }
        }

        /// <summary>
        /// Informs about need to log in before requesting an bike.
        /// </summary>
        public string LoginRequiredHintText
            => ActiveUser.IsLoggedIn 
                    ? string.Empty
                    : AppResources.MarkingLoginRequiredToRerserve;

        public string ContactSupportHintText
            => string.Format(AppResources.MarkingContactSupport, m_oStation?.OperatorData?.Name ?? "Operator");

        /// <summary> 
        /// Returns if info about the fact that user did not request or book any bikes is visible or not. 
        /// </summary>
        public bool IsNoBikesAtStationVisible
        {
            get
            {
                return Count <= 0 && IsIdle == true;
            }
        }

        /// <summary> Info about the fact that user did not request or book any bikes. </summary>
        public string NoBikesAtStationText
        {
            get
            {
                return IsNoBikesAtStationVisible
                    ? $"Momentan sind keine Fahrräder an dieser Station verfügbar."
                    : string.Empty;
            }
        }

        /// <summary> Command object to bind login page redirect link to view model.</summary>
        public System.Windows.Input.ICommand ContactSupportClickedCommand
#if USEFLYOUT
                => new Xamarin.Forms.Command(() => OpenSupportPageAsync());
#else
                => new Xamarin.Forms.Command(async () => await OpenLoginPageAsync());
#endif

        /// <summary> Command object to bind login page redirect link to view model.</summary>
        public System.Windows.Input.ICommand LoginRequiredHintClickedCommand
#if USEFLYOUT
                => new Xamarin.Forms.Command(() => OpenLoginPageAsync());
#else
                => new Xamarin.Forms.Command(async () => await OpenLoginPageAsync());
#endif

        /// <summary> Opens login page. </summary>
#if USEFLYOUT
        public void OpenLoginPageAsync()
#else
        public async Task OpenLoginPageAsync()
#endif
        {
            try
            {
                // Switch to map page

#if USEFLYOUT
                ViewService.ShowPage(ViewTypes.LoginPage);
#else
                await ViewService.ShowPage("//LoginPage");
#endif
            }
            catch (Exception p_oException)
            {
                Log.Error("Ein unerwarteter Fehler ist in der Klasse BikesAtStationPageViewModel aufgetreten. Kontext: Klick auf Hinweistext auf Station N- seite ohne Anmeldung. {@Exception}", p_oException);
                return;
            }
        }

        /// <summary> Opens support. </summary>
#if USEFLYOUT
        public void OpenSupportPageAsync()
#else
        public async Task OpenSupportPageAsync()
#endif
        {
            try
            {
                // Switch to map page

#if USEFLYOUT
                ViewService.ShowPage(ViewTypes.ContactPage, AppResources.MarkingFeedbackAndContact);
#else
                await ViewService.ShowPage("//LoginPage");
#endif
            }
            catch (Exception p_oException)
            {
                Log.Error("Ein unerwarteter Fehler ist auf der Seite Kontakt aufgetreten. Kontext: Klick auf Hinweistext auf Station N- seite ohne Anmeldung. {@Exception}", p_oException);
                return;
            }
        }

        /// <summary> Returns detailed info about the station (station id).<summary>
        public string StationDetailText { get; private set; }

        /// <summary>
        /// Invoked when page is shown. 
        /// Starts update process.
        /// </summary>
        public async Task OnAppearing()
        {
            Log.ForContext<BikesAtStationPageViewModel>().Information($"Bikes at station {m_oStation?.StationName} is appearing, either due to tap on a station or to app being shown again.");

            ActionText = "Einen Moment bitte...";

            // Stop polling before getting bikes info.
            await m_oViewUpdateManager.StopUpdatePeridically();

            ActionText = AppResources.ActivityTextBikesAtStationGetBikes;

            var bikesAll = await ConnectorFactory(IsConnected).Query.GetBikesAsync();
            
            Exception = bikesAll.Exception; // Update communication error from query for bikes at station.

            var bikesAtStation = bikesAll.Response.GetAtStation(m_oStation.Id);
            var lockIdList = bikesAtStation
                .GetLockIt()
                .Cast<BikeInfo>()
                .Select(x => x.LockInfo)
                .ToList();

            if (LockService is ILocksServiceFake serviceFake)
            {
                serviceFake.UpdateSimulation(bikesAtStation);
            }

            ActionText = AppResources.ActivityTextSearchBikes;

            // Check location permissions.
            if (bikesAtStation.GetLockIt().Count > 0
                && RuntimePlatform == Device.Android)
            {
                var status = await PermissionsService.CheckStatusAsync();
                if (status != Status.Granted)
                {
                    var permissionResult = await PermissionsService.RequestAsync();

                    if (permissionResult != Status.Granted)
                    {
                        var dialogResult = await ViewService.DisplayAlert(
                            AppResources.MessageTitleHint,
                            AppResources.MessageBikesManagementLocationPermissionOpenDialog,
                            AppResources.MessageAnswerYes,
                            AppResources.MessageAnswerNo);

                        if (!dialogResult)
                        {
                            // User decided not to give access to locations permissions.
                            BikeCollection.Update(bikesAtStation);

                            await OnAppearing(() => UpdateTask());

                            ActionText = "";
                            IsIdle = true;
                            return;
                        }

                        // Open permissions dialog.
                        PermissionsService.OpenAppSettings();
                    }
                }

                if (Geolocation.IsGeolcationEnabled == false)
                {
                    await ViewService.DisplayAlert(
                        AppResources.MessageTitleHint,
                        AppResources.MessageBikesManagementLocationActivation,
                        AppResources.MessageAnswerOk);

                    BikeCollection.Update(bikesAtStation);

                    await OnAppearing(() => UpdateTask());

                    ActionText = "";
                    IsIdle = true;
                    return;
                }

                // Check if bluetooth is activated.
                if (await BluetoothService.GetBluetoothState() != BluetoothState.On)
                {
                    await ViewService.DisplayAlert(
                        AppResources.MessageTitleHint,
                        AppResources.MessageBikesManagementBluetoothActivation,
                        AppResources.MessageAnswerOk);

                    BikeCollection.Update(bikesAtStation);

                    await OnAppearing(() => UpdateTask());

                    ActionText = "";
                    IsIdle = true;
                    return;
                }
            }

            // Connect to bluetooth devices.
            ActionText = AppResources.ActivityTextSearchBikes;
            IEnumerable<LockInfoTdo> locksInfoTdo;
            try
            {
                locksInfoTdo = await LockService.GetLocksStateAsync(
                    lockIdList.Select(x => x.ToLockInfoTdo()).ToList(),
                    LockService.TimeOut.MultiConnect);
            }
            catch (Exception exception)
            {
                Log.ForContext<BikesAtStationPageViewModel>().Error("Getting bluetooth state failed. {Exception}", exception);
                locksInfoTdo = new List<LockInfoTdo>();
            }

            var locksInfo = lockIdList.UpdateById(locksInfoTdo);

            BikeCollection.Update(bikesAtStation.UpdateLockInfo(locksInfo));

            // Backup GUI synchronization context.
            await OnAppearing(() => UpdateTask());

            ActionText = "";
            IsIdle = true;
        }

        /// <summary> Create task which updates my bike view model.</summary>
        private void UpdateTask()
        {
            PostAction(
                unused =>
                {
                    ActionText = AppResources.ActivityTextUpdating;
                    IsConnected = IsConnectedDelegate();
                },
                null);

            var result = ConnectorFactory(IsConnected).Query.GetBikesAsync().Result;

            BikeCollection bikes = result.Response.GetAtStation(m_oStation.Id);

            var exception = result.Exception;
            if (exception != null)
            {
                Log.ForContext<BikesAtStationPageViewModel>().Error("Getting all bikes bikes in polling context failed with exception {Exception}.", exception);
            }

            PostAction(
                unused =>
                {
                    BikeCollection.Update(bikes);
                    Exception = result.Exception;
                    ActionText = string.Empty;
                },
                        null);
        }

        /// <summary>
        /// True if any action can be performed (request and cancel request)
        /// </summary>
        public override bool IsIdle
        {
            get => base.IsIdle;
            set
            {
                if (value == base.IsIdle)
                    return;

                Log.ForContext<BikesViewModel>().Debug($"Switch value of {nameof(IsIdle)} to {value}.");
                base.IsIdle = value;
                base.OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsNoBikesAtStationVisible)));
                base.OnPropertyChanged(new PropertyChangedEventArgs(nameof(NoBikesAtStationText)));
            }
        }

        /// <summary> Opens login page.</summary>
        /// <param name="url">Url to open.</param>
        private void RegisterRequest(string url)
        {
            try
            {
                OpenUrlInExternalBrowser(url);
            }
            catch (Exception p_oException)
            {
                Log.Error("Ein unerwarteter Fehler ist auf der Login Seite beim Öffnen eines Browsers, Seite {url}, aufgetreten. {@Exception}", url, p_oException);
                return;
            }
        }
    }
}