using AutoMapper;
using AutoMapper.QueryableExtensions;
using Hydrogen.Framework.Infrastructure;
using Hydrogen.Vault.Model;
using Hydrogen.Vault.Server;
using HydrogenUI.Infrastructure.Helpers;
using HydrogenUI.Services.Base;
using HydrogenVault.ViewModels.Safe;
using HydrogenVault.ViewModels.StoredItem;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace HydrogenVault.Services
{
	public class VaultWebService : BaseWebService
	{
		private VaultFacade vaultFacade;

		public VaultWebService(VaultFacade vaultFacade)
			: base(vaultFacade)
		{
			this.vaultFacade = vaultFacade;
		}

		//public override IList<T> GetCollection<T>(Expression<Func<T, bool>> filter = null, List<OrderByModel<T>> orderByList = null, uint? skip = null, uint? take = null)
		//{
		//	List<T> returnList = base.GetCollection<T>(filter, orderByList, skip, take).ToList();

		//	if (typeof(T) == typeof(SafeDisplayViewModel))
		//	{
		//		returnList.ForEach(safe =>
		//		{
		//			var allItemsThatHavePasswordToThisSafe = GetItemsByTargetSafeId(safe.Id);

		//			PopulateSafesThatHavePasswordToThisSafe(safe as SafeDisplayViewModel, allItemsThatHavePasswordToThisSafe, returnList.Select(x => x as SafeDisplayViewModel));
		//		});
		//	}

		//	return returnList;
		//}


		//public IQueryable<SafeDisplayViewModel> GetAllSafeDisplayModels()
		//      {
		//	var allSafes = base.GetCollection<SafeDisplayViewModel>().ToList();

		//	allSafes.ForEach(safe =>
		//	{
		//		var allItemsThatHavePasswordToThisSafe = GetItemsByTargetSafeId(safe.Id);

		//		PopulateSafesThatHavePasswordToThisSafe(safe, allItemsThatHavePasswordToThisSafe, allSafes);
		//	});

		//	return allSafes.AsQueryable();
		//      }

		//private void PopulateSafesThatHavePasswordToThisSafe(SafeDisplayViewModel theSafe, IQueryable<ItemDisplayViewModel> itemsThatHavePasswordToThisSafe,
		//	IEnumerable<SafeDisplayViewModel> allSafes)
		//{
		//	theSafe.CanOpenWithSafes = string.Empty;

		//	if (itemsThatHavePasswordToThisSafe.Count() > 0)
		//	{
		//		foreach (var itemToThisSafe in itemsThatHavePasswordToThisSafe)
		//		{
		//			theSafe.CanOpenWithSafes += allSafes.Where(safe => safe.Id == itemToThisSafe.SafeId).First().Name;
		//			theSafe.CanOpenWithSafes += ", ";
		//		}

		//		if (theSafe.CanOpenWithSafes.Length > 0)
		//		{
		//			theSafe.CanOpenWithSafesCanOpenWithSafes = theSafe.CanOpenWithSafes.Substring(0, theSafe.CanOpenWithSafes.Length - 2);
		//		}
		//	}
		//}

		public void DeleteSafe(int id)
		{
			var dbModel = this.vaultFacade.GetSafe(id);
			this.vaultFacade.DeleteSafe(dbModel);
		}

		public bool IsCorrectSafePassword(int safeId, string password)
		{
			return this.vaultFacade.IsCorrectSafePassword(safeId, password);
		}

		public void Save(SafeEditViewModel model)
		{
			var dbModel = model.Id > 0 ? this.vaultFacade.GetSafe(model.Id) : new Safe();
			Mapper.Map(model, dbModel);
			this.vaultFacade.SaveSafe(dbModel);
		}

		public SafeEditViewModel GetSafeById(int id)
		{
			var dbModel = this.vaultFacade.GetSafe(id);
			var model = Mapper.Map<SafeEditViewModel>(dbModel);
			return model;
		}

		public void ChangeSafePassword(string oldPassword, string newPassword, int safeId, int userId)
		{
			this.vaultFacade.ChangeSafePassword(oldPassword, newPassword, safeId, userId);
		}

		public IQueryable<ItemDisplayViewModel> GetAllItemDisplayModels(int safeId)
		{
			return this.vaultFacade.GetItemDisplaysBySafeIdAllData(safeId)
				   .AsQueryable()
				   .Project().To<ItemDisplayViewModel>()
				   .OrderBy(c => c.Id);
		}

		public void DeleteItem(int id)
		{
			var dbModel = this.vaultFacade.GetItem(id);
			this.vaultFacade.DeleteItem(dbModel);
		}

		public string GetPlainTextItemById(int id, string password)
		{
			var dbModel = this.vaultFacade.GetItem(id);
			var model = Mapper.Map<PlainTextItemPostedDataViewModel>(dbModel);
			return this.vaultFacade.GetPlainTextFromItem(dbModel, password); ;
		}

		//public void Save(PlainTextItemPostedDataViewModel model, string password)
		//{
		//    var dbModel = new Item();
		//    if (model.Id != 0)
		//    {
		//        dbModel = this.vaultFacade.GetItem(model.Id);
		//    }

		//    Mapper.Map(model, dbModel);

		//    this.vaultFacade.SavePlainTextItem(dbModel, model.PlainText, password);
		//}

		//public FileItemPostedDataViewModel GetFileItemById(int id, string password)
		//{
		//    var dbModel = this.vaultFacade.GetItem(id);
		//    var model = Mapper.Map<FileItemPostedDataViewModel>(dbModel);

		//    model.FileName = this.vaultFacade.GetFileNameFromItem(dbModel, password);
		//    return model;
		//}

		//public void Save(FileItemPostedDataViewModel model, string password)
		//      {
		//          var dbModel = new Item();
		//          if (model.Id != 0)
		//          {
		//              dbModel = this.vaultFacade.GetItem(model.Id);
		//          }

		//          Mapper.Map(model, dbModel);
		//          if (model.File == null)
		//          {
		//              this.vaultFacade.SaveFileItem(dbModel);
		//          }
		//          else
		//          {
		//              byte[] data = UploadHelper.GetBytes(model.File);
		//              dbModel.ItemData = data;
		//              this.vaultFacade.SaveFileItem(dbModel, model.File.FileName, data, password);
		//          }
		//      }

		//public void Save(SafePasswordItemPostedDataViewModel model, string password)
		//{
		//	var dbModel = new Item();
		//	if (model.Id != 0)
		//	{
		//		dbModel = this.vaultFacade.GetItem(model.Id);
		//	}

		//	Mapper.Map(model, dbModel);
		//	this.vaultFacade.SaveSafePasswordItem(dbModel, model.TargetSafePassword, password);
		//}

		public byte[] EncryptFileItem(string fileName = null, byte[] fileData = null, string safeUserPassword = null)
		{
			return vaultFacade.EncryptFileItem(fileName, fileData, safeUserPassword);
		}

		public byte[] EncryptPlainText(string text, string thePassword)
		{
			return vaultFacade.EncryptPlainText(text, thePassword);
		}

		public DownloadFileViewModel GetFileForDownload(int id, string password)
		{
			var dbModel = this.vaultFacade.GetItem(id);
			var model = new DownloadFileViewModel()
			{
				FileBytes = this.vaultFacade.GetFileFromItem(dbModel, password),
				FileName = this.vaultFacade.GetFileNameFromItem(dbModel, password)
			};

			return model;
		}

		public bool PasswordExpired(int id)
		{
			var item = this.vaultFacade.GetSafe(id);
			return this.vaultFacade.PasswordExpirationChecker(item.PasswordChangedDate, item.PasswordExpirationPeriod);
		}

		public bool UserHasVaultRecords(int userId)
		{
			bool result;

			int itemsCount = this.vaultFacade.GetItems()
				.Where(item => item.CreatedById == userId
				|| item.ModifiedById == userId)
				.Count();

			int safesCount = this.vaultFacade.GetSafes()
				.Where(safe => safe.CreatedById == userId
				|| safe.ModifiedById == userId)
				.Count();

			result = (itemsCount > 0) || (safesCount > 0) ? true : false;

			return result;
		}

		public SafePasswordItemPostedDataViewModel GetSafePasswordItemById(int id, string password)
		{
			var dbModel = this.vaultFacade.GetItem(id);
			var model = Mapper.Map<SafePasswordItemPostedDataViewModel>(dbModel);
			model.TargetSafePassword = this.vaultFacade.GetPlainTextFromItem(dbModel, password);
			return model;
		}

		public IQueryable<ItemDisplayViewModel> GetItemsByTargetSafeId(int targetSafeId)
		{
			return this.vaultFacade.GetItemsByTargetSafeId(targetSafeId)
				.AsQueryable()
				.Project().To<ItemDisplayViewModel>()
				.OrderBy(c => c.Id);
		}

		public IList<ItemDisplayViewModel> GetItemDisplaysByNameAndDetailsContains(string searchKey)
		{
			return this.vaultFacade.GetItemDisplaysByNameAndDetailsContains(searchKey)
				.AsQueryable()
				.Project().To<ItemDisplayViewModel>()
				.OrderBy(c => c.Id)
				.ToList();
		}

		public ItemDisplayViewModel GetItem(int id)
		{
			var dbModel = this.vaultFacade.GetItem(id);
			var model = Mapper.Map<ItemDisplayViewModel>(dbModel);

			return model;
		}

		public byte[] EncryptItemData(byte[] theData, string thePassword)
		{
			return vaultFacade.EncryptItemData(theData, thePassword);
		}
	}
}