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 DevExpress.DataProcessing;
using DevExpress.Mvvm;
using DevExpress.Utils.Extensions;
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;
using static DevExpress.Utils.Drawing.Helpers.NativeMethods;

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

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

		public AiPromptbausteinFolderListVM Folders { get; set; }
		public AiPromptbausteinFolderVM Favoriten { 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 DelegateCommand ChangeFavoritenStatePromptCommand { get; private set; }

		public DelegateCommand OpenAddRoutineDialogCommand { get; private set; }
		public DelegateCommand OpenEditRoutineDialogCommand { get; private set; }
		public DelegateCommand DeleteRoutineCommand { get; private set; }
		public DelegateCommand ChangeFavoritenStateRoutineCommand { get; private set; }

		public DelegateCommand OpenEditItemDialogCommand { get; private set; }
		public DelegateCommand DeleteItemCommand { get; private set; }
		public DelegateCommand ChangeFavoritenStateItemCommand { get; private set; }

		public bool CanEditPromptbausteine { get; set; }

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

				if (SelectedItem is AiPromptbausteinPromptVM vm)
				{
					SelectedItem = null;
				}

				if (!success)
					return;

				UpdateFolderCommands();
				UpdatePromptCommands();
			}
		}

		public AbstractBaseVM SelectedItem
		{
			get => _SelectedItem;
			set {
				var success = SetProperty(ref _SelectedItem, value, nameof(SelectedItem));

				if (!success)
					return;

				UpdateItemCommands();
			}
		}

		public AiPromptbausteinComplexTreeViewModel() : this(null, AiActionType.ServiceRecordConversation)
		{
			if (BeWoApp.IsInDesignMode)
			{
				//ReloadVMList();
				InitDesigner();
				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);
			ChangeFavoritenStatePromptCommand = new DelegateCommand(ChangeFavoritenStatePrompt, canChangeFavoritenStatePrompt, false);

			OpenAddRoutineDialogCommand = new DelegateCommand(OpenAddRoutineDialog, canOpenAddRoutineDialog, false);
			OpenEditRoutineDialogCommand = new DelegateCommand(OpenEditRoutineDialog, canOpenEditRoutineDialog, false);
			DeleteRoutineCommand = new DelegateCommand(OpenDeleteRoutineDialog, canOpenDeleteRoutineDialog, false);
			ChangeFavoritenStateRoutineCommand = new DelegateCommand(ChangeFavoritenStateRoutine, canChangeFavoritenStateRoutine, false);

			Action executeEditItem = () => ExecuteItem(OpenEditPromptDialog, OpenEditRoutineDialog);
			Func<bool> canExecuteEditItem = () => canExecuteItem(canOpenEditPromptDialog, canOpenEditRoutineDialog);
			OpenEditItemDialogCommand = new DelegateCommand(executeEditItem, canExecuteEditItem, true);

			Action executeDeleteItem = () => ExecuteItem(OpenDeletePromptDialog, OpenDeleteRoutineDialog);
			Func<bool> canExecuteDeleteItem = () => canExecuteItem(canOpenDeletePromptDialog, canOpenDeleteRoutineDialog);
			DeleteItemCommand = new DelegateCommand(executeDeleteItem, canExecuteDeleteItem, true);

			Action executeFavoriteItem = () => ExecuteItem(ChangeFavoritenStatePrompt, ChangeFavoritenStateRoutine);
			Func<bool> canExecuteFavoriteItem = () => canExecuteItem(canChangeFavoritenStatePrompt, canChangeFavoritenStateRoutine);
			ChangeFavoritenStateItemCommand = new DelegateCommand(executeFavoriteItem, canExecuteFavoriteItem, true);

			CanEditPromptbausteine = BeWoApp.HasLoggedOnUserRight(UserRightType.AiModulePromptbausteineEdit);
		}

		public override bool IsDirty
		{
			get
			{
				return 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();
			ChangeFavoritenStatePromptCommand.RaiseCanExecuteChanged();
			OpenAddRoutineDialogCommand.RaiseCanExecuteChanged();
			OpenEditRoutineDialogCommand.RaiseCanExecuteChanged();
			DeleteRoutineCommand.RaiseCanExecuteChanged();
			ChangeFavoritenStateRoutineCommand.RaiseCanExecuteChanged();			
		}
		public void UpdateItemCommands()
		{
			OpenEditItemDialogCommand.RaiseCanExecuteChanged();
			DeleteItemCommand.RaiseCanExecuteChanged();
			ChangeFavoritenStateItemCommand.RaiseCanExecuteChanged();
		}

		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 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.DataSaved += (s, new_dc) =>
			{
				new_vm.UpdateByDataContract(new_dc);
				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();
			sel_dc.CanEdit = SelectedFolder.CanEdit;
			sel_dc.Oid = sel_folder.DataContract.Oid;
			sel_dc.Version = sel_folder.DataContract.Version;
			var edit_vm = new AiPromptbausteinFolderVM(sel_dc);

			var vm = new AiPromptbausteinFolderViewModel(edit_vm, false);

			vm.DataSaved += (s, new_dc) =>
			{
				sel_folder.UpdateByDataContract(new_dc);
			};

			WindowService.Show(vm);
		}
		void CopyFolder()
		{
			throw new NotImplementedException();
		}
		void PasteFolder()
		{
			throw new NotImplementedException();
		}
		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;

			var delete_dc = sel_folder.CommitToDataContract();
			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinFolder(delete_dc),
				() => parent.SubFolders.VMList.Remove(sel_folder));
		}

		bool canOpenAddFolderDialog()
		{
			return CanEditPromptbausteine && (SelectedFolder?.CanAddFolder ?? false);
		}
		bool canOpenEditFolderDialog()
		{
			return CanEditPromptbausteine && (SelectedFolder?.CanEdit ?? false);
		}
		bool canCopyFolder()
		{
			return false;
			//return SelectedFolder.CanEdit;
		}
		bool canPasteFolder()
		{
			return false;
			//return HasCopiedFolder && SelectedFolder.CanAdd;
		}
		bool canDeleteFolder()
		{
			return CanEditPromptbausteine && (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;
			new_vm.ActionType = AiActionType;

			var vm = new AiPromptbausteinPromptViewModel(new_vm);

			vm.DataSaved += (s, new_dc) =>
			{
				new_vm.UpdateByDataContract(new_dc);
				sel_folder.SubPrompts.VMList.Add(new_vm);
				SelectedItem = new_vm;
			};

			WindowService.Show(vm);
		}
		void OpenEditPromptDialog()
		{
			var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;

			if (SelectedItem is null)
				throw new Exception("invalid operation");

			var sel_dc = sel_prompt.CopyToEmptyDataContract();
			sel_dc.CanEdit = sel_prompt.CanEdit;
			sel_dc.Oid = sel_prompt.DataContract.Oid;
			sel_dc.Version = sel_prompt.DataContract.Version;
			var edit_vm = new AiPromptbausteinPromptVM(sel_dc);

			var vm = new AiPromptbausteinPromptViewModel(edit_vm);

			vm.DataSaved += (s, new_dc) =>
			{
				sel_prompt.UpdateByDataContract(new_dc);
				UpdateSelectedPromptFavorite(sel_prompt);
			};

			WindowService.Show(vm);
		}

		private void UpdateSelectedPromptFavorite(AiPromptbausteinPromptVM sel_prompt = null)
		{
			if (sel_prompt is null)
				sel_prompt = SelectedItem as AiPromptbausteinPromptVM;

			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.SubRoutines.Count == 0 && Favoriten.SubPrompts.Count == 0)
				{
					var selected_folder = SelectedFolder;
					SelectedFolder = null;
					SelectedFolder = selected_folder;
				}
			}
		}

		private void UpdateSelectedRoutineFavorite(AiPromptbausteinRoutineVM sel_routine = null)
		{
			if (sel_routine is null)
				sel_routine = SelectedItem as AiPromptbausteinRoutineVM;

			if (sel_routine.IsFavorite && !Favoriten.SubRoutines.VMList.Contains(sel_routine))
				Favoriten.SubRoutines.VMList.Add(sel_routine);
			else if (!sel_routine.IsFavorite && Favoriten.SubRoutines.VMList.Contains(sel_routine))
			{
				Favoriten.SubRoutines.VMList.Remove(sel_routine);

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

		void CopyPrompt()
		{
			CopiedPrompt = SelectedItem as AiPromptbausteinPromptVM;
		}
		void PastePrompt()
		{
			var copied_dc = CopiedPrompt.CommitToDataContract();
			copied_dc.Creator = CurrentEmployee;
			copied_dc.CanEdit = true;
			copied_dc.IsPublic = false;
			copied_dc.IsFavorite = false;
			copied_dc.Oid = null;
			copied_dc.Version = null;
			copied_dc.ParentFolderOid = SelectedFolder.DataContract.Oid;
			copied_dc.ActionType = AiActionType;
			copied_dc.PromptId = null;
			copied_dc.ShowPrompt = true;
			copied_dc.ShowPromptByTenant = true;
			copied_dc.IsOwnsoftPrompt = false;

			var copied_vm = new AiPromptbausteinPromptVM(copied_dc);

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.InsertAiPromptbausteinPrompt(copied_dc),
					new_dc =>
					{
						copied_vm.UpdateByDataContract(new_dc);
						SelectedFolder.SubPrompts.VMList.Add(copied_vm);
						SelectedItem = copied_vm;
					});
		}
		void OpenDeletePromptDialog()
		{
			var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;
			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;

			if (sel_prompt.IsFavorite)
			{
				sel_prompt.IsFavorite = false;
				UpdateSelectedPromptFavorite();
			}

			var delete_dc = sel_prompt.CommitToDataContract();
			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinPrompt(delete_dc),
				() =>
				{
					if (folder.SubPrompts.VMList.Contains(sel_prompt))
					{
						folder.SubPrompts.VMList.Remove(sel_prompt);
					}
					else
					{
						ReloadVMList();
					}
				});
		}

		void ChangeFavoritenStatePrompt()
		{
			var sel_prompt = SelectedItem as AiPromptbausteinPromptVM;

			sel_prompt.IsFavorite = !sel_prompt.IsFavorite;

			var edit_dc = sel_prompt.CommitToDataContract();

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinPrompt(edit_dc),
				new_dc =>
				{
					sel_prompt.UpdateByDataContract(new_dc);
					UpdateSelectedPromptFavorite(sel_prompt);
				});
		}

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

		bool canChangeFavoritenStatePrompt()
		{
			return SelectedItem as AiPromptbausteinPromptVM is object;
		}

		// --- Routine Commands

		void OpenAddRoutineDialog()
		{
			var sel_folder = SelectedFolder;
			var new_vm = sel_folder.SubRoutines.CreateNewVM();

			new_vm.Creator = CurrentEmployee;
			new_vm.ParentFolderOid = sel_folder.DataContract.Oid;
			new_vm.CanEdit = true;
			new_vm.ActionType = AiActionType;

			var vm = new AiPromptbausteinRoutineViewModel(new_vm, Folders);

			vm.DataSaved += (s, new_dc) =>
			{
				new_vm.UpdateByDataContract(new_dc);
				sel_folder.SubRoutines.VMList.Add(new_vm);
				SelectedItem = new_vm;
			};

			WindowService.Show(vm);
		}
		void OpenEditRoutineDialog()
		{
			var sel_prompt = SelectedItem as AiPromptbausteinRoutineVM;

			if (SelectedItem is null)
				throw new Exception("invalid operation");

			var sel_dc = sel_prompt.CopyToEmptyDataContract();
			sel_dc.CanEdit = sel_prompt.CanEdit;
			sel_dc.Oid = sel_prompt.DataContract.Oid;
			sel_dc.Version = sel_prompt.DataContract.Version;
			var edit_vm = new AiPromptbausteinRoutineVM(sel_dc);

			var vm = new AiPromptbausteinRoutineViewModel(edit_vm, Folders);

			vm.DataSaved += (s, new_dc) =>
			{
				sel_prompt.UpdateByDataContract(new_dc);
				UpdateSelectedRoutineFavorite(sel_prompt);
			};

			WindowService.Show(vm);
		}
		void OpenDeleteRoutineDialog()
		{
			var sel_prompt = SelectedItem as AiPromptbausteinRoutineVM;
			var folder = SelectedFolder;

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

			if (result != MessageBoxResult.OK)
				return;

			if (sel_prompt.IsFavorite)
			{
				sel_prompt.IsFavorite = false;
				UpdateSelectedRoutineFavorite();
			}

			var delete_dc = sel_prompt.CommitToDataContract();
			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinRoutine(delete_dc),
				() =>
				{
					if (folder.SubRoutines.VMList.Contains(sel_prompt))
					{
						folder.SubRoutines.VMList.Remove(sel_prompt);
					}
					else
					{
						ReloadVMList();
					}
				});
		}
		void ChangeFavoritenStateRoutine()
		{
			var sel_routine = SelectedItem as AiPromptbausteinRoutineVM;

			sel_routine.IsFavorite = !sel_routine.IsFavorite;

			var edit_dc = sel_routine.CommitToDataContract();

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinRoutine(edit_dc),
				new_dc =>
				{
					sel_routine.UpdateByDataContract(new_dc);
					UpdateSelectedRoutineFavorite(sel_routine);
				});
		}

		bool canOpenAddRoutineDialog() => CanEditPromptbausteine && (SelectedFolder?.CanAddPrompt ?? false);
		bool canOpenEditRoutineDialog() => SelectedItem is AiPromptbausteinRoutineVM;
		bool canOpenDeleteRoutineDialog() => CanEditPromptbausteine && ((SelectedItem as AiPromptbausteinRoutineVM)?.CanEdit ?? false);
		bool canChangeFavoritenStateRoutine() => SelectedItem is AiPromptbausteinRoutineVM;

		void ExecuteItem(Action prompt_action, Action routine_action)
		{
			if (SelectedItem is AiPromptbausteinPromptVM)
				prompt_action();
			else if (SelectedItem is AiPromptbausteinRoutineVM)
				routine_action();
			else
				throw new NotImplementedException("item is not AiPromptbausteinPromptVM or AiPromptbausteinRoutineVM");
		}
		bool canExecuteItem(Func<bool> prompt_func, Func<bool> routine_func)
		{
			if (SelectedItem is AiPromptbausteinPromptVM)
				return prompt_func();
			else if (SelectedItem is AiPromptbausteinRoutineVM)
				return routine_func();

			return false;
		}

		void InitDesigner()
		{
			var root = PredefinedAiPromptbausteinFolders.CreateSubTree(AiActionType.ServiceRecordConversation);

			var root_vm = new AiPromptbausteinFolderListVM(root);

			Folders = root_vm;
		}
	}
}