using BeWo.ServiceProxy;
using BeWo.Services;
using BeWo.ViewModel.ListViewModel;
using BeWo.ViewModel.View.Administration;
using BS.Shared;
using BS.Shared.DataContracts.Compact;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions.CustomInterfaces;
using DevExpress.Mvvm;
using DevExpress.Mvvm.POCO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Input;
using MessageBox = System.Windows.MessageBox;

namespace BeWo.ViewModel.View.AI
{
	public class AiPromptbausteinSelectionComplexViewModel : DialogViewModel
	{
		public event EventHandler<AiPromptbausteinPromptVM> PromptAccepted;
		public event EventHandler VMListReloaded;

		private AiPromptbausteinFolderVM _SelectedFolder;
		private AiPromptbausteinPromptVM _SelectedPrompt;

		private IBeWoWindowService WindowService { 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 bool CanEditPromptbausteine { get; set; }
		public bool HasCopiedFolder => CopiedFolder is object;
		public bool HasCopiedPrompt => CopiedPrompt is object;
		public CompactEmployeeDC CurrentEmployee => BeWoApp.CompactLoggedOnEmployee;

		public AiPromptbausteinSelectionComplexViewModel()
		{
			SendCommand = new DelegateCommand(Send, CanSend, true);

			if (BeWoApp.IsInDesignMode)
			{
				Folders = new AiPromptbausteinFolderListVM();
			}
		}
		public AiPromptbausteinSelectionComplexViewModel(AiActionType aiActionType) : this()
		{
			AiActionType = aiActionType;
			WindowService = BeWoApp.MainControl.WindowService;
			InitCommands();
		}
		public AiPromptbausteinSelectionComplexViewModel(AiActionType aiActionType, AiPromptbausteinFolderListVM viewModel, bool isFavorite = false) : this(aiActionType)
		{
			LoadedActionType = aiActionType;
			Folders = viewModel;
			IsFavorite = isFavorite;
		}

		private void InitCommands()
		{
			OpenAddFolderDialogCommand = new DelegateCommand(OpenAddFolderDialog, canOpenAddFolderDialog, false);
			OpenEditFolderDialogCommand = new DelegateCommand(OpenEditFolderDialog, canOpenEditFolderDialog, false);
			DeleteFolderCommand = new DelegateCommand(DeleteFolder, canDeleteFolder, false);

			OpenAddPromptDialogCommand = new DelegateCommand(OpenAddPromptDialog, canOpenAddPromptDialog, false);
			OpenEditPromptDialogCommand = new DelegateCommand(OpenEditPromptDialog, canOpenEditPromptDialog, false);
			DeletePromptCommand = new DelegateCommand(OpenDeletePromptDialog, canOpenDeletePromptDialog, false);
			ChangeFavoritenStatePromptCommand = new DelegateCommand(ChangeFavoritenStatePrompt, canChangeFavoritenStatePrompt, false);

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

		public bool IsFavorite { get; set; }

		public DelegateCommand SendCommand { get; set; }

		public AiActionType AiActionType { get; set; }

		public AiPromptbausteinFolderVM SelectedFolder
		{
			get => _SelectedFolder;
			set
			{
				if (value == _SelectedFolder)
					return;

				_SelectedFolder = value;
				FirePropertyChanged(nameof(SelectedFolder));

				if (SelectedPrompt is object)
				{
					SelectedPrompt.IsSelected = false;
					SelectedPrompt = null;
				}
			}
		}
		public AiPromptbausteinPromptVM SelectedPrompt
		{
			get => _SelectedPrompt;
			set
			{
				_SelectedPrompt = value;
				FirePropertyChanged(nameof(SelectedPrompt));
				SendCommand.RaiseCanExecuteChanged();
			}
		}
		public AiPromptbausteinFolderListVM Folders { get; private set; }
		public AiActionType LoadedActionType { get; set; }

		public bool HasFavoriten
		{
			get
			{
#if DEBUG
				if (BeWoApp.IsInDesignMode)
					return true;
#endif

				return Folders.Count > 3 && Folders.VMList[0].Prompts.Count > 0;
			}
		}

		public void ResetSelection()
		{
			SelectedFolder = null;

			if (IsFavorite)
				SelectedFolder = Folders.VMList[0];
		}
		public void Send()
		{
			var selected_prompt = SelectedPrompt;

			CloseDialogCommand.Execute(null);

			PromptAccepted?.Invoke(this, selected_prompt);
		}
		public bool CanSend()
		{
			return SelectedPrompt is object;
		}
		public void InitVMList()
		{
			if (Folders is object && LoadedActionType == AiActionType)
				return;

			LoadedActionType = AiActionType;

			VMFactory.CreateAiPromptbausteinFolderListVMAsync(AiActionType, UpdateVMList);
		}
		public void ReloadVMList(bool notify = true)
		{
			VMFactory.CreateAiPromptbausteinFolderListVMAsync(AiActionType, UpdateVMList);

			if(notify)
				VMListReloaded?.Invoke(this, EventArgs.Empty);
		}
		private void UpdateVMList(AiPromptbausteinFolderListVM new_list)
		{
			Folders = new_list;

			FirePropertyChanged(nameof(Folders));

			if (Folders.VMList.Count > 0 && Folders.VMList[0].DataContract.Oid == -5)
			{
				Favoriten = Folders.VMList[0];

				if (IsFavorite)
					SelectedFolder = Favoriten;
			}

			FirePropertyChanged(nameof(HasFavoriten));
		}

		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();
		}

		// --- Folder Commands ---

		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) =>
			{
				var new_dc = new_vm.CommitToDataContract();

				ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.InsertAiPromptbausteinFolder(new List<AiPromptbausteinFolderDC> { new_dc }),
					(new_dcs) => ReloadVMList());
			};

			Close();

			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.Accept_Button_Clicked += (s, e) =>
			{
				var edit_dc = edit_vm.CommitToDataContract();

				ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinFolder(new List<AiPromptbausteinFolderDC> { edit_dc }),
					(update_dc) => ReloadVMList());
			};

			Close();

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

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

			var oid2version = new Dictionary<long, long>()
			{
				{sel_folder.DataContract.Oid.Value, sel_folder.DataContract.Version.Value}
			};

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinFolder(oid2version),
				() => ReloadVMList());
		}

		bool canOpenAddFolderDialog() => CanEditPromptbausteine && (SelectedFolder?.CanAddFolder ?? true);
		bool canOpenEditFolderDialog() => CanEditPromptbausteine && (SelectedFolder?.CanEdit ?? false);
		bool canDeleteFolder() => CanEditPromptbausteine && (SelectedFolder?.CanEdit ?? false);

		// --- Prompt Commands ---

		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, true);

			vm.Accept_Button_Clicked += (s, e) =>
			{
				var new_dc = new_vm.CommitToDataContract();

				ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.InsertAiPromptbausteinPrompt(new List<AiPromptbausteinPromptDC> { new_dc }),
					(new_dcs) => ReloadVMList());
			};

			Close();

			WindowService.Show(vm);
		}
		void OpenEditPromptDialog()
		{
			var sel_prompt = SelectedPrompt;
			var sel_dc = sel_prompt.CopyToEmptyDataContract();
			sel_dc.CanEdit = SelectedPrompt.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, false);

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

				ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinPrompt(new List<AiPromptbausteinPromptDC> { edit_dc }),
					(update_dc) => ReloadVMList());
			};

			Close();

			WindowService.Show(vm);
		}
		void OpenDeletePromptDialog()
		{
			var sel_prompt = SelectedPrompt;
			var folder = SelectedFolder;

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

			var oid2version = new Dictionary<long, long>()
			{
				{sel_prompt.DataContract.Oid.Value, sel_prompt.DataContract.Version.Value}
			};

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.DeleteAiPromptbausteinPrompt(oid2version),
				() => ReloadVMList());
		}
		void ChangeFavoritenStatePrompt()
		{
			var sel_prompt = SelectedPrompt;
			sel_prompt.IsFavorite = !sel_prompt.IsFavorite;
			var edit_dc = sel_prompt.CommitToDataContract();

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiPromptbausteinPrompt(new List<AiPromptbausteinPromptDC> { edit_dc }),
				(update_dc) => ReloadVMList());
		}

		bool canOpenAddPromptDialog() => CanEditPromptbausteine && (SelectedFolder?.CanAddPrompt ?? false);
		bool canOpenEditPromptDialog() => SelectedPrompt is object;
		bool canOpenDeletePromptDialog() => CanEditPromptbausteine && (SelectedPrompt?.CanEdit ?? false);
		bool canChangeFavoritenStatePrompt() => SelectedPrompt is object;
	}
}