using BeWo.ServiceProxy;
using BeWo.Services;
using BeWo.ViewModel.ListViewModel;
using BS.Shared;
using BS.Shared.DataContracts.Compact;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions.CustomInterfaces;
using DevExpress.Mvvm;
using DevExpress.Xpf.Layout.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace BeWo.ViewModel.View.Administration
{
	public class AiPromptbausteinComplexTreeViewModel : WindowViewModel
	{
		private AiPromptbausteinFolderVM _SelectedFolder;

		private IBeWoWindowService WindowService { get; set; }
		private AiActionType AiActionType { get; set; }

		public AiPromptbausteinFolderListVM Folders { get; set; }
		public AiPromptbausteinFolderVM Favoriten { get; set; }

		public AiPromptbausteinPromptVM SelectedPrompt { get; set; }
		public AiPromptbausteinFolderVM CopiedFolder { get; set; }
		public AiPromptbausteinPromptVM CopiedPrompt { get; set; }

		public DelegateCommand OpenAddFolderDialogCommand { get; private set; }
		public DelegateCommand OpenEditFolderDialogCommand { get; private set; }
		public DelegateCommand CopyFolderCommand { get; private set; }
		public DelegateCommand PasteFolderCommand { get; private set; }
		public DelegateCommand DeleteFolderCommand { get; private set; }

		public DelegateCommand OpenAddPromptDialogCommand { get; private set; }
		public DelegateCommand OpenEditPromptDialogCommand { get; private set; }
		public DelegateCommand CopyPromptCommand { get; private set; }
		public DelegateCommand PastePromptCommand { get; private set; }
		public DelegateCommand DeletePromptCommand { get; private set; }

		public bool IsEditingMode { get; set; }

		public AiPromptbausteinFolderVM SelectedFolder
		{
			get => _SelectedFolder;
			set => SetProperty(ref _SelectedFolder, value, nameof(SelectedFolder));
		}


		public AiPromptbausteinComplexTreeViewModel() : this(null, AiActionType.ServiceRecordConversation)
		{
			if (BeWoApp.IsInDesignMode)
			{
				ReloadVMList();
				SelectedFolder = Folders.VMList.FirstOrDefault();
				return;
			}
		}
		public AiPromptbausteinComplexTreeViewModel(IBeWoWindowService windowService, AiActionType aiActionType)
		{
			WindowService = windowService;
			AiActionType = aiActionType;

			OpenAddFolderDialogCommand = new DelegateCommand(OpenAddFolderDialog, canOpenAddFolderDialog, false);
			OpenEditFolderDialogCommand = new DelegateCommand(OpenEditFolderDialog, canOpenEditFolderDialog, false);
			CopyFolderCommand = new DelegateCommand(CopyFolder, canCopyFolder, false);
			PasteFolderCommand = new DelegateCommand(PasteFolder, canPasteFolder, false);
			DeleteFolderCommand = new DelegateCommand(DeleteFolder, canDeleteFolder, false);

			OpenAddPromptDialogCommand = new DelegateCommand(OpenAddPromptDialog, canOpenAddPromptDialog, false);
			OpenEditPromptDialogCommand = new DelegateCommand(OpenEditPromptDialog, canOpenEditPromptDialog, false);
			CopyPromptCommand = new DelegateCommand(CopyPrompt, canCopyPrompt, false);
			PastePromptCommand = new DelegateCommand(PastePrompt, canPastePrompt, false);
			DeletePromptCommand = new DelegateCommand(OpenDeletePromptDialog, canOpenDeletePromptDialog, false);

			IsEditingMode = true;
		}

		public override bool IsDirty
		{
			get
			{
				return Folders?.ContainsDirtyObject() ?? false;
			}
		}
		public bool HasCopiedFolder => CopiedFolder is object;
		public bool HasCopiedPrompt => CopiedPrompt  is object;
		public CompactEmployeeDC CurrentEmployee => BeWoApp.CompactLoggedOnEmployee;

		public void UpdateFolderCommands()
		{
			OpenAddFolderDialogCommand.RaiseCanExecuteChanged();
			OpenEditFolderDialogCommand.RaiseCanExecuteChanged();
			CopyFolderCommand.RaiseCanExecuteChanged();
			PasteFolderCommand.RaiseCanExecuteChanged();
			DeleteFolderCommand.RaiseCanExecuteChanged();
		}		
		public void UpdatePromptCommands()
		{
			OpenAddPromptDialogCommand.RaiseCanExecuteChanged();
			OpenEditPromptDialogCommand.RaiseCanExecuteChanged();
			CopyPromptCommand.RaiseCanExecuteChanged();
			PastePromptCommand.RaiseCanExecuteChanged();
			DeletePromptCommand.RaiseCanExecuteChanged();
		}

		public void SaveVMList()
		{
			if (!IsDirty)
				return;

			// DFS -> 1. Sobald Knoten gefunden wird mit IsNew=true: Teilbaum als neu markieren
			//		  2. Sobald Knoten gefunden wird mit IsNew=false && IsDirty=true: Knoten als update markieren
			// 3. Checken, welche Knoten gelöscht wurden

			var toadd_folder = new List<AiPromptbausteinFolderVM>();
			var toadd_prompts = new List<AiPromptbausteinPromptDC>();
			var toupdate_folder = new List<AiPromptbausteinFolderVM>();
			var toupdate_prompt = new List<AiPromptbausteinPromptDC>();
			DFS_Search_AddUpdate(Folders, ref toadd_folder, ref toadd_prompts, ref toupdate_folder, ref toupdate_prompt);

			var todelete_folder = new List<AiPromptbausteinFolderDC>();
			var todelete_prompt = new List<AiPromptbausteinPromptDC>();
			DFS_Search_Delete(Folders, ref todelete_folder, ref todelete_prompt);

			var toadd_folder_dcs = toadd_folder.Select(x => x.CommitToDataContract());
			var toupdate_folder_dcs = toupdate_folder.Select(x => x.CommitToDataContract());

			var actions = new List<Action<IAiEnhancedService>>();

			if (toadd_folder.Any())
				actions.Add(x => x.InsertAiPromptbausteinFolder(toadd_folder_dcs.ToList()));

			if (toadd_prompts.Any())
				actions.Add(x => x.InsertAiPromptbausteinPrompt(toadd_prompts.ToList()));

			if (toupdate_folder_dcs.Any())
			{
				foreach (var folder_dc in toupdate_folder_dcs)
				{
					folder_dc.SubPrompts = null;
					folder_dc.SubFolders = null;
				}

				actions.Add(x => x.UpdateAiPromptbausteinFolder(toupdate_folder_dcs.ToList()));
			}
			
			if (toupdate_prompt.Any())
				actions.Add(x => x.UpdateAiPromptbausteinPrompt(toupdate_prompt.ToList()));

			if (todelete_folder.Any())
				actions.Add(x => x.DeleteAiPromptbausteinFolder(todelete_folder.ToDictionary(x1 => x1.Oid.Value, x2 => x2.Version.Value)));

			if (todelete_prompt.Any())
				actions.Add(x => x.DeleteAiPromptbausteinPrompt(todelete_prompt.ToDictionary(x1 => x1.Oid.Value, x2 => x2.Version.Value)));

			ServiceFacade.DoMultipleAiEnhancedServicesAsync(actions, () =>
			{
				ReloadVMList();
			});
		}
		internal void ReloadVMList()
		{
			VMFactory.CreateAiPromptbausteinFolderListVMAsync(
				AiActionType,
				listvm =>
				{
					Folders = listvm;
					if (Folders.VMList.Count > 0 && Folders.VMList[0].DataContract.Oid == -5)
					{
						Favoriten = Folders.VMList[0];
					}
					FirePropertyChanged(nameof(Folders));
				});
		}

		void DFS_Search_AddUpdate(AiPromptbausteinFolderListVM folders, ref List<AiPromptbausteinFolderVM> toadd_Folder, ref List<AiPromptbausteinPromptDC> toadd_Prompts, ref List<AiPromptbausteinFolderVM> toupdate_Folder, ref List<AiPromptbausteinPromptDC> toupdate_Prompt)
		{
			foreach (var node in folders.VMList)
			{
				// Favoriten ignorieren
				if (node.DataContract.Oid is long oid && oid < -4)
					continue;

				// Öffentlich
				if (node.DataContract.Oid is long oid2 && oid2 < -1){
					DFS_Search_UpdatePromptFavorite(node.SubFolders, ref toadd_Folder, ref toadd_Prompts, ref toupdate_Folder, ref toupdate_Prompt);
					if (node.SubPrompts.ChangedCount > 0)
						toupdate_Prompt.AddRange(node.SubPrompts.CommitChanged());
					continue;
				}

				// Eigene
				if (node.IsNew)
				{
					toadd_Folder.Add(node);
				}
				else
				{
					if (node.IsDirty)
						toupdate_Folder.Add(node);

					if (node.HasSubFolders)
						DFS_Search_AddUpdate(node.SubFolders, ref toadd_Folder, ref toadd_Prompts, ref toupdate_Folder, ref toupdate_Prompt);

					if (node.SubPrompts.AddedCount > 0)
						toadd_Prompts.AddRange(node.SubPrompts.CommitAdded());

					if (node.SubPrompts.ChangedCount > 0)
						toupdate_Prompt.AddRange(node.SubPrompts.CommitChanged());
				}
			}
		}
		void DFS_Search_UpdatePromptFavorite(AiPromptbausteinFolderListVM folders, ref List<AiPromptbausteinFolderVM> toadd_Folder, ref List<AiPromptbausteinPromptDC> toadd_Prompts, ref List<AiPromptbausteinFolderVM> toupdate_Folder, ref List<AiPromptbausteinPromptDC> toupdate_Prompt)
		{
			foreach (var node in folders.VMList)
			{
				if (node.HasSubFolders)
					DFS_Search_UpdatePromptFavorite(node.SubFolders, ref toadd_Folder, ref toadd_Prompts, ref toupdate_Folder, ref toupdate_Prompt);

				if (node.SubPrompts.ChangedCount > 0)
					toupdate_Prompt.AddRange(node.SubPrompts.CommitChanged());
			}
		}
		void DFS_Search_Delete(AiPromptbausteinFolderListVM folders, ref List<AiPromptbausteinFolderDC> todelete_Folder, ref List<AiPromptbausteinPromptDC> todelete_Prompt)
		{
			foreach (var node_dc in folders.DCBackup)
			{
				if (node_dc.Oid is long oid && oid < -1)
					continue;

				if (folders.VMList.FirstOrDefault(vm => vm.DataContract == node_dc) is AiPromptbausteinFolderVM node_vm)
				{
					if (node_vm.SubFolders.DCBackup is object && node_vm.SubFolders.DCBackup.Count > 0)
						DFS_Search_Delete(node_vm.SubFolders, ref todelete_Folder, ref todelete_Prompt);

					if (node_vm.SubPrompts.RemovedCount > 0)
						todelete_Prompt.AddRange(node_vm.SubPrompts.GetRemoved());
				}
				else
				{
					todelete_Folder.Add(node_dc);
				}
			}
		}

		void OpenAddFolderDialog()
		{
			var sel_folder = SelectedFolder;
			var new_vm = sel_folder.SubFolders.CreateNewVM();

			new_vm.Creator = CurrentEmployee;
			new_vm.Parent = sel_folder;
			new_vm.ParentFolderOid = sel_folder?.DataContract?.Oid;
			new_vm.CanAddFolder = true;
			new_vm.CanAddPrompt = true;
			new_vm.CanEdit = true;
			new_vm.ActionType = AiActionType;

			var vm = new AiPromptbausteinFolderViewModel(new_vm, true);

			vm.Accept_Button_Clicked += (s, e) =>
			{
				sel_folder.SubFolders.VMList.Add(new_vm);
				sel_folder.IsExpanded = true;
			};

			WindowService.Show(vm);
		}
		void OpenEditFolderDialog()
		{
			var sel_folder = SelectedFolder;
			var sel_dc = sel_folder.CopyToEmptyDataContract();
			var edit_vm = new AiPromptbausteinFolderVM(sel_dc);

			var vm = new AiPromptbausteinFolderViewModel(edit_vm, false);

			vm.Accept_Button_Clicked += (s, e) =>
			{
				var edit_dc = edit_vm.CommitToDataContract();
				sel_folder.UpdateByDataContract(edit_dc);
			};

			WindowService.Show(vm);
		}
		void CopyFolder()
		{

		}
		void PasteFolder()
		{

		}
		void DeleteFolder()
		{
			var sel_folder = SelectedFolder;
			var parent = sel_folder.Parent;

			var txt = "Möchten Sie den ausgewählten Ordner wirklich löschen?";
			var result = MessageBox.Show(txt, "Hinweis", MessageBoxButton.OKCancel);

			if (result != MessageBoxResult.OK)
				return;

			parent.SubFolders.VMList.Remove(sel_folder);
		}

		bool canOpenAddFolderDialog()
		{
			return SelectedFolder?.CanAddFolder ?? true;
		}
		bool canOpenEditFolderDialog()
		{
			return SelectedFolder?.CanEdit ?? false;
		}
		bool canCopyFolder()
		{
			return false;
			//return SelectedFolder.CanEdit;
		}
		bool canPasteFolder()
		{
			return false;
			//return HasCopiedFolder && SelectedFolder.CanAdd;
		}
		bool canDeleteFolder()
		{
			return SelectedFolder?.CanEdit ?? false;
		}

		void OpenAddPromptDialog()
		{
			var sel_folder = SelectedFolder;
			var new_vm = sel_folder.SubPrompts.CreateNewVM();

			new_vm.Creator = CurrentEmployee;
			new_vm.ParentFolderOid = sel_folder.DataContract.Oid;
			new_vm.ShowPrompt = true;
			new_vm.ShowPromptByTenant = true;
			new_vm.CanEdit = true;

			var vm = new AiPromptbausteinPromptViewModel(new_vm, true);

			vm.Accept_Button_Clicked += (s, e) =>
			{
				sel_folder.SubPrompts.VMList.Add(new_vm);
				SelectedPrompt = new_vm;
			};

			WindowService.Show(vm);
		}
		void OpenEditPromptDialog()
		{
			var sel_prompt = SelectedPrompt;
			var sel_dc = sel_prompt.CopyToEmptyDataContract();
			var edit_vm = new AiPromptbausteinPromptVM(sel_dc);

			var vm = new AiPromptbausteinPromptViewModel(edit_vm, false);

			vm.Accept_Button_Clicked += (s, e) =>
			{
				var edit_dc = edit_vm.CommitToDataContract();
				sel_prompt.UpdateByDataContract(edit_dc);

				if (sel_prompt.IsFavorite && !Favoriten.SubPrompts.VMList.Contains(sel_prompt))
					Favoriten.SubPrompts.VMList.Add(sel_prompt);
				else if (!sel_prompt.IsFavorite && Favoriten.SubPrompts.VMList.Contains(sel_prompt))
				{
					Favoriten.SubPrompts.VMList.Remove(sel_prompt);

					if(Favoriten.SubPrompts.Count == 0)
					{
						var selected_folder = SelectedFolder;
						SelectedFolder = null;
						SelectedFolder = selected_folder;
					}
				}
			};

			WindowService.Show(vm);
		}
		void CopyPrompt()
		{
			CopiedPrompt = SelectedPrompt;
		}
		void PastePrompt()
		{
			var copied_dc = CopiedPrompt.CommitToDataContract();
			copied_dc.Creator = CurrentEmployee;
			copied_dc.CanEdit = true;
			copied_dc.IsPublic = false;
			copied_dc.Oid = null;
			copied_dc.Version = 0;
			var copied_vm = new AiPromptbausteinPromptVM(copied_dc);

			SelectedFolder.SubPrompts.VMList.Add(copied_vm);
		}
		void OpenDeletePromptDialog()
		{
			var sel_prompt = SelectedPrompt;
			var folder = SelectedFolder;

			var txt = "Möchten Sie den ausgewählten Prompt wirklich löschen?";
			var result = MessageBox.Show(txt, "Hinweis", MessageBoxButton.OKCancel);

			if (result != MessageBoxResult.OK)
				return;

			folder.SubPrompts.VMList.Remove(SelectedPrompt);
		}

		bool canOpenAddPromptDialog()
		{
			return SelectedFolder?.CanAddPrompt ?? false;
		}
		bool canOpenEditPromptDialog()
		{
			return SelectedPrompt is object;
		}
		bool canCopyPrompt()
		{
			return SelectedPrompt is object;
		}
		bool canPastePrompt()
		{
			return canOpenAddPromptDialog() && HasCopiedPrompt;
		}
		bool canOpenDeletePromptDialog()
		{
			return SelectedPrompt?.CanEdit ?? false;
		}
	}
}