using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Organization.Project.Common.Bll;
using Organization.Project.Common.Bll.Geocode;
using Organization.Project.Common.Bll.Geocode.Providers;
using Organization.Project.Common.Dal.Objects;
using Organization.Project.Common.Dal;
using Organization.Project.Common.Enums.Bll;
using Organization.Project.Bll.Managers.Extensions;

namespace Organization.Project.Bll.Managers
{
	/// <summary>
	/// Handles store management activities
	/// </summary>
	public class StoresManager : IStoresManager
	{
		#region User Defined Variables

		private readonly IRepository<IStore> storesRepository;
		private readonly IRepository<ICountryState> countryStateRepository;
		private readonly IGeocodeProvider geocodeProvider;
		private readonly IRepository<ICountry> countryRepository;
		private readonly IErrorLogManager errorLog;

		#endregion

		#region Constructors

		/// <summary>
		/// Contstructor
		/// </summary>
		/// <param name="repositoriesFactory">factory for resolving different repositories</param>
		/// <param name="geocodeProvider">geocode provider for indirect search</param>
		/// <param name="errorLogManager">error log manager</param>
		public StoresManager(IRepositoriesFactory repositoriesFactory, IGeocodeProvider geocodeProvider, IErrorLogManager errorLogManager)
		{
			this.storesRepository = repositoriesFactory.GetStoresRepository();
			this.countryRepository = repositoriesFactory.GetCountriesRepository();
			this.countryStateRepository = repositoriesFactory.GetCountriesStatesRepository();
			this.geocodeProvider = geocodeProvider;
			this.errorLog = errorLogManager;
		}

		#endregion

		#region Public Methods

		/// <summary>
		/// Gets list of stores 
		/// </summary>
		/// <param name="countryId">country id</param>
		/// <param name="stateId">country state id</param>
		/// <param name="zip">country zip code</param>
		/// <param name="searchType">search type</param>
		/// <returns>list of stores</returns>
		public IEnumerable<IStore> GetStores(int countryId, int? stateId, string zip, StoresSearchProductType searchType)
		{
			IEnumerable<IStore> result;
			IEnumerable<string> states = GetStateNames(stateId);
			IEnumerable<IStore> offlineStores = GetOfflineStores(countryId, states, zip, null, searchType);

			if (string.IsNullOrEmpty(zip))
			{
				//search without zip
				IEnumerable<IStore> onlineStores = GetOnlineStores(countryId, searchType);
				result = StoresManagerExtensions.GetMergedStores(offlineStores, onlineStores);
			}
			else
			{
				//search with zip
				IEnumerable<int> excludeId = offlineStores.Select(s => s.Id).ToArray();
				IEnumerable<IStore> indirectStores = GetGeocodeIndirectStores(countryId, states, zip, searchType, excludeId);

				//if there are no direct and indirect results => remove zip term
				if (offlineStores.Count() == 0 && indirectStores.Count() == 0)
				{
					result = GetStores(countryId, stateId, null, searchType);
				}
				else
				{
					//merge direct, online, indirect results
					IEnumerable<IStore> onlineStores = GetOnlineStores(countryId, searchType);
					result = offlineStores.Union(StoresManagerExtensions.GetMergedStores(indirectStores, onlineStores));
				}
			}

			return result;
		}

		#endregion

		#region Private Methods

		/// <summary>
		/// Gets list of online stores 
		/// </summary>
		/// <param name="countryId">country id</param>
		/// <param name="searchType">search type</param>
		/// <returns>list of online stores</returns>
		private IQueryable<IStore> GetOnlineStores(int countryId, StoresSearchProductType searchType)
		{
			return storesRepository.GetAll()
				.Where(s => s.CountryId == countryId && s.IsOnline)
				.ApplySearchTypeFilter(searchType)
				.OrderByDescending(s => s.Weight);
		}

		/// <summary>
		/// Gets list of offline stores
		/// </summary>
		/// <param name="countryId">country id</param>
		/// <param name="states">country state id</param>
		/// <param name="zip">country zip code</param>
		/// <param name="cities">list of cities</param>
		/// <param name="searchType">search type</param>
		/// <returns>list of offline stores</returns>
		private IQueryable<IStore> GetOfflineStores(int countryId, IEnumerable<string> states, string zip, IEnumerable<string> cities, StoresSearchProductType searchType)
		{
			return storesRepository.GetAll()
				.Where(s => s.CountryId == countryId && !s.IsOnline)
				.ApplyZipFilter(zip)
				.ApplyCityFilter(cities)
				.ApplyStatesFilter(states)
				.ApplySearchTypeFilter(searchType)
				.OrderByDescending(s => s.Weight);
		}

		private IEnumerable<IStore> GetGeocodeIndirectStores(int countryId, IEnumerable<string> states, string zip, StoresSearchProductType searchType, IEnumerable<int> excludeId)
		{

			ICountry country = countryRepository.GetAll().SingleOrDefault(c => c.Id == countryId);
			if (country == null) return null;

			IGeocodeSearchResult result = geocodeProvider.GetSearchResult(country.Abbreviation, country.Name, zip);
			if (result.Status == GeocodeSearchStatus.Success)
			{
				//filter by country
				IEnumerable<IGeocodeSearchItem> resultItems = result.SearchItems.Where(si => si.CountryCode.ToLower() == country.Abbreviation.ToLower());

				//if states exists apply state filter
				IEnumerable<string> indirectStates = (states != null) ? resultItems.Select(si => si.AdministrativeArea).ToArray() : null;
				IEnumerable<string> indirectCities = resultItems.Select(si => si.Locality).ToArray();

				//if after filter by country we have empty list -> return empty list
				return (indirectCities.Count() == 0)
						? new IStore[0]
						: (IEnumerable<IStore>)GetOfflineStores(countryId,
																indirectStates,
																null,
																indirectCities,
																searchType)
												.ApplyExcludeIdFilter(excludeId);
			}
			else
			{
				errorLog.LogMessage(string.Format("Geocode search error: {0} - {1}", result.Status, result.StatusCode));
				return new IStore[0];
			}
		}

		/// <summary>
		/// Gets short and long names of state as enumerable sequence
		/// </summary>
		/// <param name="stateId">country state id</param>
		/// <returns>enumerable sequence of state names</returns>
		private IEnumerable<string> GetStateNames(int? stateId)
		{
			if (stateId == null) return null;
			ICountryState state = countryStateRepository.GetAll().Where(s => s.Id == stateId).SingleOrDefault();
			if (state == null) return null;
			return Enumerable.Repeat(state.ShortName.ToLower(), 1).Concat(Enumerable.Repeat(state.LongName.ToLower(), 1));
		}

		#endregion

	}
}