using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.IO;
using Sarand.Net.Standard.Base.ItemDocs;
using Sarand.Net.Standard.Dbas.Base;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.Net.Standard.Dbas.ItemDocs
{
	//=======================================================================
	public abstract class SaItemDocConsole_Dbas : SaItemDocConsole
	{
		//-------------------------------------------------------------------
		// Data members.
		private SaItemDocMgr_Dbas itemDocMgr = null;
		private readonly List<TypeCodeDesc> categories = new List<TypeCodeDesc>();
		private readonly List<String> favouriteFolders = new List<string>();
		private readonly List<String> recentFolders = new List<string>();

		//-------------------------------------------------------------------
		// Static initialisation.
		static SaItemDocConsole_Dbas ()
		{
		}

		//-------------------------------------------------------------------
		// Construction.
		protected SaItemDocConsole_Dbas (ISacsDatabase database)
		{
			Database = database;
			itemDocMgr = new SaItemDocMgr_Dbas(this);
		}

		//-------------------------------------------------------------------
		// Properties.
		internal ISacsDatabase Database { get; set; }
		public override bool DatabaseIsValid { get { return itemDocMgr.DatabaseIsValid; } }
		public override bool CanUpdateDatabase { get { return itemDocMgr.CanUpdateDatabase; } }

		//-------------------------------------------------------------------
		//                         I t e m   D o c s
		//-------------------------------------------------------------------
		// Category codes.
		public override List<TypeCodeDesc> GetCategoryCodes ()
		{
			if (categories.Count < 1)
			{
				categories.Add(Category.Folder, "FLD", "Folder");
				categories.Add(Category.Document, "DOC", "Document");
				categories.Add(Category.Image, "IMG", "Image");
				categories.Add(Category.FileSpec, "FSP", "File spec (generic)", "Allows wildcards");
			}
			return categories;
		}
		/// <summary>eg. for 'Image' documents.</summary>
		public override List<CodeDesc> GetCategoryTypeCodes (Category category)
		{
			return new List<CodeDesc>();
		}

		//-------------------------------------------------------------------
		// 'Recent' and 'Favourite' folders - to populate drop-down list when selecting folder:
		/// <summary>How many recent foldes to retain? [default:5]</summary>
		public override int GetMaxRecentFolderCount ()
		{
			return 5;
		}
		/// <summary>List of favourites to always include in dropdown.</summary>
		public override void SetFavouriteFolders (List<String> folders)
		{
			favouriteFolders.Clear();
			favouriteFolders.AddRange(folders);
		}
		/// <summary>Mix of recent and favourites.</summary>
		public override List<String> GetSuggestedFolders ()
		{
			List<String> folders = new List<string>();
			folders.AddRange(favouriteFolders);
			folders.AddRange(recentFolders);
			folders.RemoveBlanks();
			folders.RemoveDuplicatesCI();
			return folders;
		}

		//-------------------------------------------------------------------
		// Retrieve list of docs that match the specified params.
		public override bool ItemDocsExist (SaItemDoc.Params prmItemDoc)
		{
			ClearErrorState();
			return (itemDocMgr.GetItemDocCount(prmItemDoc) > 0);
		}
		public override List<SaItemDoc> GetItemDocs (SaItemDoc.Params prmItemDoc)
		{
			ClearErrorState();
			return itemDocMgr.GetItemDocList(prmItemDoc);
		}

		//-------------------------------------------------------------------
		// Create a new document.
		public override SaItemDoc CreateItemDoc (ItemId itemId, Category category)
		{
			ClearErrorState();
			return itemDocMgr.CreateItemDoc(itemId, category);
		}

		//-------------------------------------------------------------------
		// Store documents:
		public override bool StoreItemDoc (SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!SysId.IsValid(itemDoc.Id))
			{
				if (!itemDocMgr.InsertItemDoc(itemDoc, dbUpdateInfo))
					return SetErrorState(itemDocMgr.ErrorStateMessage);
			}
			else
			{
				if (!itemDocMgr.UpdateItemDoc(itemDoc, dbUpdateInfo))
					return SetErrorState(itemDocMgr.ErrorStateMessage);
			}
			if (!StringUtil.IsEmpty(itemDoc.Folder))
			{
				// Update recent folder list.
				recentFolders.RemoveAllCI(itemDoc.Folder);
				recentFolders.Insert(0, itemDoc.Folder);
				while (recentFolders.Count > GetMaxRecentFolderCount())
					recentFolders.RemoveAt(recentFolders.Count - 1);
			}
			return !HasErrorState();
		}
		public override bool StoreItemDocs (List<SaItemDoc> itemDocs, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			foreach (SaItemDoc itemDoc in itemDocs)
			{
				if (!StoreItemDoc(itemDoc, dbUpdateInfo)) return false;
			}
			return true;
		}
		public override bool RemoveItemDoc (SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!itemDocMgr.DeleteItemDoc(itemDoc, dbUpdateInfo))
				return SetErrorState(itemDocMgr.ErrorStateMessage);
			return !HasErrorState();
		}
		public override bool ClearItemDocs (ItemId itemId, Category category, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState("Item must be specified");
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.IncludedItemIds.Add(itemId);
			prmItemDoc.Category = category;
			foreach (SaItemDoc itemDoc in itemDocMgr.GetItemDocList(prmItemDoc))
			{
				if (!itemDocMgr.DeleteItemDoc(itemDoc, dbUpdateInfo))
					return SetErrorState(itemDocMgr.ErrorStateMessage);
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Auto-assign documents.
		// The master items define 'auto-assign' docs for the item's type.
		// The 'File part' defines the filename excluding the extension.
		// If the extension list is empty, any extension is matched.
		public override bool AutoAssignDocs (ItemId itemId, List<ItemId> masterItemIds, String filePart, List<String> extension, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState("Item must be specified");
			if (masterItemIds.Count < 1) return SetErrorState("Master items must be specified");

			// Retrieve docs for this item:
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.IncludedItemIds.Add(itemId);
			prmItemDoc.StatusCat = SaItemDoc.StatusCat.NotDeleted;
			List<SaItemDoc> itemDocs = GetItemDocs(prmItemDoc);

			// Retrieve 'auto-assign' docs for the master items:
			SaItemDoc.Params prmMaster = new SaItemDoc.Params();
			prmMaster.IncludedItemIds.AddRange(masterItemIds);
			prmMaster.ItemTypeAutoAssign = itemId.Type;
			List<SaItemDoc> masterDocs = GetItemDocs(prmMaster);

			// Identify the folders defined for 'Auto-Assign':
			List<String> folders = new List<string>();
			foreach (SaItemDoc masterDoc in masterDocs)
			{
				if (masterDoc.ItemTypeAutoAssign == itemId.Type && masterDoc.Category == Category.Folder && !StringUtil.IsEmpty(masterDoc.Folder))
				{
					if (!folders.ContainsCI(masterDoc.Folder))
						folders.Add(masterDoc.Folder);
				}
			}

			// Locate relevant files in the specified folders:
			List<String> filePaths = new List<string>();
			foreach (String folder in folders)
			{
				filePaths.AddRange(FileUtil.LocateFiles(folder, filePart, extension, 2));
			}

			// Check whether any of these files are already logged as documents against the item:
			filePaths.RemoveDuplicatesCI();
			foreach (String filePath in filePaths)
			{
				String folder = FileUtil.GetParentDirectory(filePath);
				String filename = Path.GetFileName(filePath);
				// Check if file is already assigned.
				if (itemDocs.Any(item => item.Folder.EqualsCI(folder) && item.Filename.EqualsCI(filename)))
					continue;
				// Assign the item document.
				SaItemDoc itemDoc = CreateItemDoc(itemId,Category.Document);
				itemDoc.DescBrief = filename;
				itemDoc.Folder = folder;
				itemDoc.Filename = filename;
				itemDoc.AutoAssigned = true;
				itemDoc.Notes = "Auto-assigned.";
				itemDocs.Add(itemDoc);
				if (!StoreItemDoc(itemDoc, dbUpdateInfo)) return false;
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}