sharee.bike-App/TINKLib/ViewModel/BikesAtStation/BikesAtStationPageViewModel.cs

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

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 IStation Station { get; }

		/// <summary>
		/// True if ListView of Bikes is refreshing after user pulled;
		/// </summary>
		private bool _isRefreshing = false;
		public bool IsRefreshing
		{
			get { return _isRefreshing; }
			set
			{
				_isRefreshing = value;
				OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsRefreshing)));
			}
		}

		/// <summary>
		/// Holds what should be executed on pull to refresh
		/// </summary>
		public Command RefreshCommand { get; }

		/// <summary>
		/// Constructs bike collection view model.
		/// </summary>
		/// <param name="user">Mail address of active user.</param>
		/// <param name="permissions">Holds object to query location permissions.</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="polling"> Holds whether to poll or not and the period length is polling is on. </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 methods on GUI.</param>
		public BikesAtStationPageViewModel(
			User user,
			ILocationPermission permissions,
			IBluetoothLE bluetoothLE,
			string runtimPlatform,
			IStation selectedStation,
			Func<bool> isConnectedDelegate,
			Func<bool, IConnector> connectorFactory,
			IGeolocationService 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, openUrlInExternalBrowser, () => new BikeAtStationInUseStateInfoProvider())
		{
			Station = selectedStation ?? new NullStation();

			Title = Station.StationName;

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

			RefreshCommand = new Command(async () => {

				IsRefreshing = false;
				await OnAppearingOrRefresh();

			});

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

		/// <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(IsIdle ? AppResources.MarkingContactSupport : AppResources.MarkingContactSupportBusy, Station.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
					? AppResources.MarkingBikesAtStationNoBikesAvailable
					: 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 OpenSupportPageAsync());
#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
			{
				if (!IsIdle)
				{
					// Prevent navigation when app is not idle because this might lead to aborting return bike workflow.
					return;
				}

				// Switch to map page

#if USEFLYOUT
                ViewService.ShowPage(ViewTypes.ContactPage, AppResources.MarkingFeedbackAndContact);
#else
				await ViewService.ShowPage("//ContactPage");
#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 OnAppearingOrRefresh()
		{
			IsIdle = false;

			IsConnected = IsConnectedDelegate();

			Log.ForContext<BikesAtStationPageViewModel>().Information($"Bikes at station {Station.StationName} is appearing, either due to tap on a station or to app being shown again.");

			ActionText = AppResources.ActivityTextOneMomentPlease;

			// 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(Station.Id);
			var lockIdList = bikesAtStation
				.GetLockIt()
				.Cast<BikeInfo>()
				.Select(x => x.LockInfo)
				.ToList();

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

			ActionText = AppResources.ActivityTextCheckBluetoothState;

			// Check location permissions.
			if (bikesAtStation.GetLockIt().Count > 0
				&& RuntimePlatform == Device.Android
				)
			{
				var status = await PermissionsService.CheckStatusAsync();
				if (status != 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, new List<IStation> { Station });

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

							ActionText = string.Empty;
							IsIdle = true;
							return;
						}
						else if (dialogResult)
						{
							// Open permissions dialog.
							PermissionsService.OpenAppSettings();
						}
				}

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

					BikeCollection.Update(bikesAtStation, new List<IStation> { Station });

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

					ActionText = string.Empty;
					IsIdle = true;
				}

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

					BikeCollection.Update(bikesAtStation, new List<IStation> { Station });

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

					ActionText = string.Empty;
					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), new List<IStation> { Station });

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

			ActionText = string.Empty;
			IsIdle = true;
		}

		/// <summary> Create task which updates my bike view model.</summary>
		public void UpdateTask()
		{
			PostAction(
				unused =>
				{
					Log.ForContext<BikesAtStationPageViewModel>().Debug("Updating action text...");
					ActionText = AppResources.ActivityTextUpdating;
					IsConnected = IsConnectedDelegate();
				},
				null);

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

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

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

			PostAction(
				unused =>
				{
					Log.ForContext<BikesAtStationPageViewModel>().Debug("Updating bikes at station...");
					BikeCollection.Update(bikes, new List<IStation> { Station });
					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)));
				base.OnPropertyChanged(new PropertyChangedEventArgs(nameof(ContactSupportHintText)));
			}
		}
	}
}