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.Services.CopriApi;
using TINK.Model.Stations.StationNS;
using TINK.Model.User;
using TINK.MultilingualResources;
using TINK.Repository.Exception;
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 TINK.ViewModel.Map;
using Xamarin.Forms;
using Command = Xamarin.Forms.Command;

namespace TINK.ViewModel.SelectBike
{
	public class SelectBikePageViewModel : 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(BikeIdUserInput)));
				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<SelectBikePageViewModel>().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 > 1 && BikeIdUserInput.Any(x => char.IsLetter(x)) && BikeIdUserInput.Any(x => char.IsDigit(x));

		/// <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> Reference on the tink app instance. </summary>
		private ITinkApp TinkApp { 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; }
		public Command ShowFilterBikeTypeInfoCommand { get; private set; }

		/// <summary>
		/// Constructs bike collection view model in case information about occupied bikes is available.
		/// </summary>
		/// <param name="user">Mail address of active user.</param>
		/// <param name="tinkApp"> Reference to tink app model.</param>
		/// <param name="isReportLevelVerbose">True if report level is verbose, false if not.</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="stations">Stations to get station name from station id.</param>
		/// <param name="polling"> Holds whether to poll or not and the period length 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 methods on GUI.</param>
		/// <param name="openUrlInBrowser">Delegate to open browser.</param>
		public SelectBikePageViewModel(
			User user,
			ITinkApp tinkApp,
			ILocationPermission permissions,
			IBluetoothLE bluetoothLE,
			string runtimPlatform,
			Func<bool> isConnectedDelegate,
			Func<bool, IConnector> connectorFactory,
			IGeolocationService geolocation,
			ILocksService lockService,
			IEnumerable<IStation> stations,
			PollingParameters polling,
			Action<SendOrPostCallback, object> postAction,
			ISmartDevice smartDevice,
			IViewService viewService,
			Action<string> openUrlInBrowser) : base(user, new ViewContext(PageContext.SelectBike), 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));

			TinkApp = tinkApp
				?? throw new ArgumentException("Can not instantiate settings page view model- object. No tink app object available.");

			RefreshCommand = new Command(async () => {

				IsRefreshing = false;
				await SelectBike();

			});

			ShowFilterBikeTypeInfoCommand = new Xamarin.Forms.Command(async () => {

				await ViewService.DisplayAlert(
						AppResources.MessageBikeTypeInfoTitle,
						AppResources.MessageBikeTypeInfoText,
						AppResources.MessageAnswerOk);

			});
		}

		/// <summary>
		/// Invoked when page is shown. 
		/// Starts update process.
		/// </summary>
		public async Task OnAppearingOrRefresh()
		{
			IsIdle = false;

			Log.ForContext<SelectBikePageViewModel>().Information("User request to show page SelectBike- page re-appearing");

			IsConnected = IsConnectedDelegate();

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

			if (string.IsNullOrEmpty(BikeIdUserInput) /* Find bike page flyout was taped */
				&& BikeCollection.Count > 0 /* Bike was successfully selected */)
			{
				// Find bike page flyout was taped and page was already opened before and bike has been selected.
				// Clear bike collection to allow user to enter bike id and search for bike.
				BikeCollection.Clear();
			}

			if (BikeCollection.Count > 0)
			{
				// Page is appearing not because page flyout was taped.
				// Bike has already been selected.
				// Restart update.
				await StartUpdateTask(() => UpdateTask());

				ActionText = string.Empty;
				IsIdle = true;
				return;
			}

			// Get Active Filtered BikeType
			ActiveFilteredBikeType = GetActiveFilteredBikeType(GroupFilterMapPage);

			ActionText = string.Empty;
			IsIdle = true;
		}

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

		/// <summary> Select a bike by ID</summary>
		public async Task SelectBike()
		{
			if (!IsSelectBikeEnabled)
			{
				await ViewService.DisplayAlert(
					String.Empty,
					AppResources.ErrorSelectBikeInputNotSufficent,
					AppResources.MessageAnswerOk);
				return;
			}
			else
			{

				// Get List of bike to be able to connect to.
				ActionText = AppResources.ActivityTextSelectBikeLoadingBikes;
				IsIdle = false;

				IsConnected = IsConnectedDelegate();

				Result<BikeCollection> bikes = null;
				try
				{
					bikes = await ConnectorFactory(IsConnected).Query.GetBikesAsync(bikeId: BikeIdUserInput.Trim());
				}
				catch (Exception exception)
				{
					if (exception is WebConnectFailureException)
					{
						// Copri server is not reachable.
						Log.ForContext<SelectBikePageViewModel>().Information("Getting bikes failed (Copri server not reachable).");

						await ViewService.DisplayAlert(
							AppResources.ErrorSelectBikeTitle,
							AppResources.ErrorNoWeb,
							AppResources.MessageAnswerOk);
					}
					else
					{
						Log.ForContext<SelectBikePageViewModel>().Error("Getting bikes failed. {Exception}", exception);

						await ViewService.DisplayAlert(
							AppResources.ErrorSelectBikeTitle,
							exception.Message,
							AppResources.MessageAnswerOk);
					}

					ActionText = string.Empty;
					IsIdle = true;
					return;
				}
				finally
				{
					Exception = bikes?.Exception ?? null; // Update communication error from query for bikes occupied.
					Bikes = bikes.Response;
				}

				try
				{
					var selectedBike = bikes.Response.FirstOrDefault();

					if (selectedBike == null)
					{
						await ViewService.DisplayAlert(
							AppResources.ErrorSelectBikeTitle,
							TinkApp.Flavor == AppFlavor.MeinKonrad
							? $"{string.Format(AppResources.ErrorSelectBikeNoBikeFound, BikeIdUserInput)}\r\n\r\n{string.Format(AppResources.ErrorSelectBikeNoBikeFoundBikeTypeHint, ActiveFilteredBikeType)}"
							: string.Format(AppResources.ErrorSelectBikeNoBikeFound, BikeIdUserInput),
							AppResources.MessageAnswerOk);

						ActionText = string.Empty;
						IsIdle = true;
						return;
					}

					var bikeCollection = new BikeCollection(new Dictionary<string, Model.Bikes.BikeInfoNS.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)
						{
							if (RuntimePlatform == Device.Android)
							{
								var permissionResult = await PermissionsService.RequestAsync();

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

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

										await StartUpdateTask(() => UpdateTask());

										ActionText = string.Empty;
										IsIdle = true;
										return;
									}

									// Open permissions dialog.
									PermissionsService.OpenAppSettings();
								}
							}
							else
							{
								var dialogResult = await ViewService.DisplayAlert(
									AppResources.MessageHintTitle,
									AppResources.MessageBikesManagementLocationPermissionOpenDialog,
									AppResources.MessageAnswerYes,
									AppResources.MessageAnswerNo);

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

									await StartUpdateTask(() => UpdateTask());

									ActionText = string.Empty;
									IsIdle = true;
									return;
								}

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

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

							BikeCollection.Update(bikeCollection, Stations);

							await StartUpdateTask(() => UpdateTask());

							ActionText = string.Empty;
							IsIdle = true;
							return;
						}

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

							BikeCollection.Update(bikeCollection, Stations);

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

					var locksInfo = lockIdList.UpdateById(locksInfoTdo);

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

					await StartUpdateTask(() => UpdateTask());

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

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

					ActionText = string.Empty;
					IsIdle = true;
					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<SelectBikePageViewModel>().Error("Getting bikes 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.Bikes.BikeInfoNS.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);
		}

		/// <summary>
		/// Selected Bike Type in MapFilter shown as label in View. Default empty.
		/// </summary>
		private string activeFilteredBikeType = string.Empty;
		/// <summary>
		/// Selected Bike Type in MapFilter shown as label in View. If empty, label is not shown = no wrong info.
		/// </summary>
		public string ActiveFilteredBikeType
		{
			get { return activeFilteredBikeType; }
			set
			{
				if (value == activeFilteredBikeType)
				{
					return;
				}
				activeFilteredBikeType = value;
				OnPropertyChanged(new PropertyChangedEventArgs(nameof(ActiveFilteredBikeType)));
			}
		}

		/// <summary>Gets the group filter from map page. </summary>
		private IGroupFilterMapPage GroupFilterMapPage => TinkApp.GroupFilterMapPage;

		/// <summary>
		/// Get Selected Bike Type in MapFilter
		/// </summary>
		public static string GetActiveFilteredBikeType(IGroupFilterMapPage filter)
		{
			Log.ForContext<SelectBikePageViewModel>().Debug($"Bike type of active filter is extracted.");
			List<string> currentFilteredBikeType = filter.Where(x => x.Value == FilterState.On).Select(x => x.Key).ToList();
			string filteredBikeType = currentFilteredBikeType.Count == 1 ? currentFilteredBikeType[0] : string.Empty;
			if (filteredBikeType == FilterHelper.CARGOBIKE)
			{
				return AppResources.MarkingCargoBike;
			}else if (filteredBikeType == FilterHelper.CITYBIKE)
			{
				return AppResources.MarkingCityBike;
			}
			else
			{
				return string.Empty;
			}
		}
	}
}