using BeWo.ServiceProxy;
using BS.Shared;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Feature.AI;
using BS.Shared.Extensions;
using ChatController.Utilities.Extensions;
using DevExpress.Mvvm;
using DevExpress.XtraPrinting.Native;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Markup;
using System.Windows.Threading;

namespace BeWo.ViewModel.ListViewModel
{
	public class AiConversationListVM : AbstractDCListMapperVM<AiConversationDC, AiConversationVM>
	{
		private string _MessageInput;
		private string _ContextInput;

		private AiModelDC _SelectedModel;
		private AiConfigVM _Config;

		public AiConversationListVM() : this(null) 
		{
			if (BeWoApp.IsInDesignMode)
			{
				InitDesigner();
			}
		}

		public AiConversationListVM(List<AiConversationDC> pDCs) : base(pDCs)
		{
			Models = new ObservableSortCollection<AiModelDC>();

			SendNewMessageCommand = new DelegateCommand(SendNewMessage, CanSendNewMessage);
			RequestNewConversationCommand = new DelegateCommand(RequestNewConversation);
			TestCommand = new DelegateCommand(Test);

			ReloadConfigCommand = new DelegateCommand(ReloadConfig);
			ReloadConversationsCommand = new DelegateCommand(ReloadConversations);
			ReloadModelsCommand = new DelegateCommand(ReloadModels);
		}

		public DelegateCommand SendNewMessageCommand { get; set; }
		public DelegateCommand RequestNewConversationCommand { get; set; }
		public DelegateCommand TestCommand { get; set; }
		public DelegateCommand ReloadConfigCommand { get; set; }
		public DelegateCommand ReloadConversationsCommand { get; set; }
		public DelegateCommand ReloadModelsCommand { get; set; }

		public ObservableCollection<AiModelDC> Models { get; set; }
		public AiModelDC SelectedModel
		{
			get { return _SelectedModel; }
			set
			{
				if (_SelectedModel == value)
					return;

				_SelectedModel = value;
				FirePropertyChanged(nameof(SelectedModel));
			}
		}
		public AiConfigVM Config
		{
			get { return _Config; }
			set
			{
				if (Config == value)
					return;

				_Config = value;
				FirePropertyChanged(nameof(Config));
			}
		}

		public string MessageInput
		{
			get { return _MessageInput; }
			set
			{
				if (MessageInput == value)
					return;

				_MessageInput = value;
				FirePropertyChanged(nameof(MessageInput));
			}
		}

		public string ContextInput
		{
			get { return _ContextInput; }
			set
			{
				if (ContextInput == value)
					return;

				_ContextInput = value;
				FirePropertyChanged(nameof(ContextInput));
			}
		}

		public int UIContext{ get; set; }
		public Dictionary<TableID, long[]> ContextBeWoObjects { get; set; }

		public void RequestNewConversation()
		{
			var conv = new AiConversationDC();

			conv.UIContext = UIContext;
			conv.ContextBeWoObjects = ContextBeWoObjects;

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.CreateAiConversation(conv, Config.SelectedModel.Oid.Value), dc => {
				var vm = new AiConversationVM(dc);
				VMList.Insert(0, vm);
				SelectedVM = vm;
			}, true, null);
		}
		public void SendNewMessage()
		{
			var conv = SelectedVM;

			var msg_dc = new AiConversationMessageDC();

			msg_dc.Message = MessageInput;
			msg_dc.Role = BS.Shared.AiConversationMessageRole.User;
			msg_dc.Created = DateTime.Now;

			var msg_vm = new AiConversationMessageVM(msg_dc);

			conv.Messages.VMList.Add(msg_vm);

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.SendNewMessage(conv.DataContract.Oid.Value, MessageInput), (messages) => 
			{
				if (messages.Count != 2)
					throw new InvalidOperationException("message count: " + messages.Count);

				msg_vm.DataContract = messages[0];

				conv.Messages.VMList.Add(new AiConversationMessageVM(messages[1]));
			});
		}
		public void Test()
		{
			throw new NotImplementedException();

			//var limit = 5;

			//var models = ServiceFacade.DoOperationsEnhancedServiceSnyc(x => x.GetAiModels());
			//Models.MakeEqualTo(models);

			//VMList.Clear();

			//foreach (var vm in Models)
			//{
			//	var dc = new AiConversationDC();

			//	dc.Created = DateTime.Now;
			//	dc.Displayname = "Example";
			//	dc.Modell = vm.ToString();

			//	var pvm = new AiConversationVM(dc);

			//	VMList.Add(pvm);
			//}

			//var msg = "Wie alt ist Frau Müller?";
			//var context = "Frau Müller wurde am 1.1.1950 geboren. Aktuelle haben wir folgende Universalzeit: " + DateTime.Now.ToUniversalTime();

			//for (var i = 0; i < limit; i++) 
			//{
			//	foreach (var vm in VMList)
			//	{
			//		ServiceFacade.DoOperationsEnhancedServiceAsnyc(x => x.SendNewMessage(vm.CommitToDataContract(), context, msg), (message) =>
			//		{
			//			vm.Messages.VMList.Add(new AiConversationMessageVM(message));
			//		});
			//	}				
			//}
		}

		private void ReloadConfig()
		{
			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiConfig(), (x) =>
			{
				if (Config is null)
					Config = new AiConfigVM(x);
				else
					Config.Update(x);
			});
		}
		public void UpdateConfig()
		{
			if (!Config.IsDirty)
				return;

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.UpdateAiConfig(Config.CommitToDataContract()), (x) =>
			{
				Config.Update(x);
			});
		}

		private void ReloadModels()
		{
			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiModels(), (x) =>
			{
				Models.MakeEqualTo(x);

				if (Config.SelectedModel is null && Models.Any())
					Config.SelectedModel = Models.First();
			});
		}
		private void ReloadConversations()
		{
			var ui_context = UIContext;

			ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.GetAiConversations(ui_context), (x) =>
			{
				x.Reverse();
				var vms = new AiConversationListVM(x);
				VMList.MakeEqualTo(vms.VMList);
			});
		}

		private bool CanSendNewMessage()
		{
			return SelectedVM is object;
		}

		#region Designer
		private void InitDesigner()
		{
			var model = new AiModelDC()
			{
				ModelName = "N llama3.2"
			};

			var message_dc = new AiConversationMessageDC()
			{
				Created = DateTime.Now,
				Message = "Nu bist eine intelligente Einheit mit ganz ganz vielen Eingaben: value1, value2, value3, value4\r\nTest",
				Role = BS.Shared.AiConversationMessageRole.System
			};

			var message_dc2 = new AiConversationMessageDC()
			{
				Created = DateTime.Now,
				Message = "N. Dies ist eine Design Frage: Du sollst ganz viele Sachen machen. Dabei sollst du auf ganz viele Sachen achten: Zum Beispiel:\r\nSache 1\r\nSchritt 2",
				Role = BS.Shared.AiConversationMessageRole.User
			};

			var message_dc3 = new AiConversationMessageDC()
			{
				Created = DateTime.Now,
				Message = "N. Deine Antwort. Dies ist eine Design Antwort. Du hast ganz viele Sachen angefragt. Dabei soll ich auf ganz viele Sachen achten. Wie Test, test, tEst und tesT.\r\nTest\r\nTest\r\nTest",
				Role = BS.Shared.AiConversationMessageRole.Assistent,
				ModelName = model.ModelName,
				Duration = 10,
			};

			var messages_dc = new List<AiConversationMessageDC>()
				{
					message_dc,
					message_dc2,
					message_dc3,
					message_dc2,
					message_dc3,
					message_dc2,
					message_dc3,
					message_dc2,
					message_dc3,
				};
				
			var conversation_dc = new AiConversationDC()
			{
				Created = DateTime.Now,
				Displayname = "Displayname Megamegalange Deluxe Op 3000",
				Messages = messages_dc,
				Modell = model,
				UIContext = 19,
				Updated = DateTime.Now,
			};

			var conversation_vm = new AiConversationVM(conversation_dc);

			VMList.Add(conversation_vm);

			InitDummyConversations(10);

			SelectedVM = conversation_vm;
		}
		private void InitDummyConversations(int count)
		{
			var model = new AiModelDC()
			{
				ModelName = "llama3.2"
			};

			for (int i = 0; i < count; i++)
			{
				var conversation_dc2 = new AiConversationDC()
				{
					Created = DateTime.Now,
					Displayname = "Dummy Num " + i.ToString(),
					Modell = model,
					UIContext = 19,
					Updated = DateTime.Now,
				};

				var conversation_vm2 = new AiConversationVM(conversation_dc2);

				VMList.Add(conversation_vm2);
			}
		}
		#endregion
	}
}