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

namespace TINK.ViewModel.FindBike
{
    public class FindBikePageViewModel : BikesViewModel, INotifyCollectionChanged, INotifyPropertyChanged
    {
        private string bikeIdUserInput = string.Empty;

        /// <summary> Text entered by user to specify a bike.</summary>
        public string BikeIdUserInput 
        {
            get => bikeIdUserInput;
            set
            {
                if (value == bikeIdUserInput)
                {
                    return;
                }

                bikeIdUserInput = value;
                base.OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsSelectBikeEnabled)));
            }
        }

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

                Log.ForContext<FindBikePageViewModel>().Debug($"Switch value of {nameof(IsIdle)} to {value}.");
                base.IsIdle = value;
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsSelectBikeEnabled))); // Enable select bike button.
            }
        }

        /// <summary> Holds all bikes available.</summary>
        public BikeCollection Bikes { get; set; }

        /// <summary> Do not allow to select bike if id is not set.</summary>
        public bool IsSelectBikeEnabled => IsIdle && BikeIdUserInput != null && BikeIdUserInput.Length > 0;
        
        /// <summary> Hide id input fields as soon as bike is found.</summary>
        public bool IsSelectBikeVisible => BikeCollection != null && BikeCollection.Count == 0;

        /// <summary> Holds the stations to get station names form station ids. </summary>
        private IEnumerable<IStation> Stations { get; }

        /// <summary>
        /// Constructs bike collection view model in case information about occupied bikes is available.
        /// </summary>
        /// <param name="p_oUser">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="connectorFactory">Connects system to copri.</param>
        /// <param name="lockService">Service to control lock retrieve info.</param>
        /// <param name="stations">Stations to get station name from station id.</param>
        /// <param name="polling"> Holds whether to poll or not and the periode leght is polling is on. </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>
        /// <param name="openUrlInBrowser">Delegate to open browser.</param>
        public FindBikePageViewModel(
            User p_oUser,
            ILocationPermission permissions,
            IBluetoothLE bluetoothLE,
            string runtimPlatform,
            Func<bool> isConnectedDelegate,
            Func<bool, IConnector> connectorFactory,
            IGeolocation geolocation,
            ILocksService lockService,
            IEnumerable<IStation> stations,
            PollingParameters polling,
            Action<SendOrPostCallback, object> postAction,
            ISmartDevice smartDevice,
            IViewService viewService,
            Action<string> openUrlInBrowser) : base(p_oUser, permissions, bluetoothLE, runtimPlatform, isConnectedDelegate, connectorFactory, geolocation, lockService, polling, postAction, smartDevice, viewService, openUrlInBrowser, () => new MyBikeInUseStateInfoProvider())
        {
            CollectionChanged += (sender, eventargs) =>
            {
                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsSelectBikeVisible)));
            };

            Stations = stations ?? throw new ArgumentException(nameof(stations));
        }

        /// <summary>
        /// Invoked when page is shown. 
        /// Starts update process.
        /// </summary>
        public async Task OnAppearing()
        {
            Log.ForContext<FindBikePageViewModel>().Information("User request to show page FindBike- page re-appearing");

            ActionText = AppResources.ActivityTextFindBikeLoadingBikes;

            var bikes = await ConnectorFactory(IsConnected).Query.GetBikesAsync();

            Exception = bikes.Exception; // Update communication error from query for bikes occupied.
            Bikes = bikes.Response;
            
            ActionText = "";
            IsIdle = true;
        }

        /// <summary> Command object to bind select bike button to view model. </summary>
        public System.Windows.Input.ICommand OnSelectBikeRequest =>  new Xamarin.Forms.Command(async () => await SelectBike(), () => IsSelectBikeEnabled);

        /// <summary> Select a bike by ID</summary>
        public async Task SelectBike()
        {
            try
            {
                var selectedBike = Bikes.FirstOrDefault(x => x.Id.Equals(BikeIdUserInput.Trim(), StringComparison.OrdinalIgnoreCase));

                if (selectedBike == null)
                {
                    await ViewService.DisplayAlert(
                        AppResources.MessageTitleHint, 
                        string.Format(AppResources.MessageErrorSelectBikeNoBikeFound, BikeIdUserInput), 
                        AppResources.MessageAnswerOk);
                    return;
                }

                var bikeCollection = new BikeCollection(new Dictionary<string, Model.Bike.BC.BikeInfo> { { selectedBike.Id, selectedBike } });

                var lockIdList = bikeCollection
                    .GetLockIt()
                    .Cast<BikeInfo>()
                    .Select(x => x.LockInfo)
                    .ToList();

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

                // Check bluetooth and location permission and states
                ActionText = AppResources.ActivityTextCheckBluetoothState;

                if (bikeCollection.FirstOrDefault(x => x is BikeInfo btBike) != null
                    && RuntimePlatform == Device.Android)
                {
                    // Check location permission
                    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(bikeCollection, Stations);

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

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

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

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

                        BikeCollection.Update(bikeCollection, Stations);

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

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

                    // Bluetooth state
                    if (await BluetoothService.GetBluetoothState() != BluetoothState.On)
                    {
                        await ViewService.DisplayAlert(
                            AppResources.MessageTitleHint,
                            AppResources.MessageBikesManagementBluetoothActivation,
                            AppResources.MessageAnswerOk);

                        BikeCollection.Update(bikeCollection, Stations);

                        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<FindBikePageViewModel>().Error("Getting bluetooth state failed. {Exception}", exception);
                    locksInfoTdo = new List<LockInfoTdo>();
                }

                var locksInfo = lockIdList.UpdateById(locksInfoTdo);

                BikeCollection.Update(bikeCollection.UpdateLockInfo(locksInfo), Stations);

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

                ActionText = "";
                IsIdle = true;
            } catch (Exception exception)
            {
                await ViewService.DisplayAlert(
                    AppResources.MessageErrorSelectBikeTitle, 
                    exception.Message, 
                    AppResources.MessageAnswerOk);

                Log.ForContext<FindBikePageViewModel>().Error("Running command to select bike failed. {Exception}", exception);
                return;
            }
        }

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

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

            var bikes = result.Response;

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

            var selectedBike = bikes.FirstOrDefault(x => x.Id.Equals(BikeIdUserInput.Trim(), StringComparison.OrdinalIgnoreCase));

            bikes = selectedBike != null
                ? new BikeCollection(new Dictionary<string, Model.Bike.BC.BikeInfo> { { selectedBike.Id, selectedBike } })
                : new BikeCollection();

            PostAction(
                unused =>
                {
                    BikeCollection.Update(bikes, Stations); // Updating collection leads to update of GUI.
                    Exception = result.Exception;
                    ActionText = string.Empty;
                },
                null);
        }
    }
}