using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TINK.Model.Bikes;
using TINK.Model.Services.CopriApi;
using TINK.Model.Stations;
using TINK.Model.Stations.StationNS;
using BikeInfo = TINK.Model.Bikes.BikeInfoNS.BC.BikeInfo;

namespace TINK.Model.Connector
{
	/// <summary> Filters connector responses.</summary>
	public class NullFilterConnector : IFilteredConnector
	{
		/// <summary> Constructs a filter object. </summary>
		/// <param name="p_oGroup">Filter group.</param>
		/// <param name="connector">Connector object.</param>
		public NullFilterConnector(
			IConnector connector)
		{
			Connector = connector;

			if (Connector == null)
			{
				throw new ArgumentException("Can not construct filter object. Connector- and command objects must not be null.");
			}

			Query = new QueryProvider(Connector.Query);
		}

		/// <summary> Inner connector object.</summary>
		public IConnector Connector { get; }

		/// <summary> Command object. </summary>
		public ICommand Command => Connector.Command;

		/// <summary> Object to query information. </summary>
		public IQuery Query { get; }

		/// <summary> True if connector has access to copri server, false if cached values are used. </summary>
		public bool IsConnected => Connector.IsConnected;

		/// <summary> Object to perform filtered queries.</summary>
		private class QueryProvider : IQuery
		{
			/// <summary> Holds the reference to object which performs copri queries.</summary>
			private IQuery m_oInnerQuery;

			/// <summary> Constructs a query object.</summary>
			/// <param name="p_oInnerQuery"></param>
			/// <param name="p_oFilter"></param>
			public QueryProvider(IQuery p_oInnerQuery)
			{
				m_oInnerQuery = p_oInnerQuery;
			}

			/// <summary> Gets bikes either bikes available if no user is logged in or bikes available and bikes occupied if a user is logged in. </summary>
			public async Task<Result<BikeCollection>> GetBikesAsync()
			{
				var result = await m_oInnerQuery.GetBikesAsync();
				return new Result<BikeCollection>(
					result.Source,
					new BikeCollection(result.Response.ToDictionary(x => x.Id)),
					result.GeneralData,
					result.Exception);
			}

			/// <summary> Gets bikes occupied if a user is logged in. </summary>
			public async Task<Result<BikeCollection>> GetBikesOccupiedAsync()
			{
				var result = await m_oInnerQuery.GetBikesOccupiedAsync();
				return new Result<BikeCollection>(
					result.Source,
					new BikeCollection(result.Response.ToDictionary(x => x.Id)),
					result.GeneralData,
					result.Exception);
			}

			/// <summary> Gets all station applying filter rules. </summary>
			/// <returns></returns>
			public async Task<Result<StationsAndBikesContainer>> GetBikesAndStationsAsync()
			{
				var result = await m_oInnerQuery.GetBikesAndStationsAsync();

				return new Result<StationsAndBikesContainer>(
					result.Source,
					new StationsAndBikesContainer(
						new StationDictionary(
							result.Response.StationsAll.CopriVersion,
							result.Response.StationsAll.ToDictionary(x => x.Id)),
						new BikeCollection(
							result.Response.BikesOccupied?.ToDictionary(x => x.Id) ?? new Dictionary<string, BikeInfo>())),
					result.GeneralData,
					result.Exception);
			}

			/// <summary> Filter bikes by group. </summary>
			/// <param name="bikes">Bikes to filter.</param>
			/// <returns>Filtered bikes.</returns>
			public static Dictionary<string, BikeInfo> DoFilter(BikeCollection bikes, IEnumerable<string> filter)
			{
				return bikes.Where(x => x.Group.Intersect(filter).Count() > 0).ToDictionary(x => x.Id);
			}

			/// <summary> Filter stations by group. </summary>
			/// <returns></returns>
			public static Dictionary<string, IStation> DoFilter(StationDictionary stations, IEnumerable<string> p_oFilter)
			{
				return stations.Where(x => x.Group.Intersect(p_oFilter).Count() > 0).ToDictionary(x => x.Id);
			}
		}
	}
}