using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.ServiceModel;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
using BeWo.Multitenancy;
using BeWo.Security;

using BS.Shared;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using DevExpress.CodeParser;
using DevExpress.Export.Xl;

namespace BeWo.ServiceProxy
{
	// Ich verlass mich jetzt mal hierdrauf:
	// http://dotnetslackers.com/WSE/re-51155_WCF_Proxy_Performance_vs_WSE_V3.aspx
	// Man muss also nicht schließen wenn nur eine Instanz vom Proxy gehalten wird
	// und Services PerCall konfiguriert sind...
	public static class ServiceFacade
	{
		public static object _Lock = string.Empty;

		private static string _ServerName;
		private static Dictionary<Type, EndpointAddress> _EndpointAddresses;

		private static readonly Dictionary<Type, object> _ProxyCache;

		private static int _RunningAsyncs;

		// Nur um die EndpointAddresses wegen neuer SiteOfOrigin zu aktualisieren
		public static Dictionary<Type, EndpointAddress> EndpointAddresses
		{
			get { return _EndpointAddresses; }

		}

		public static void UpdateServerAddresses(String siteOfOrigin)
		{
			_ServerName = siteOfOrigin;
			var test = _ServerName.Substring(_ServerName.Length - 1, 1);
			if (_ServerName.Substring(_ServerName.Length - 1, 1) != "/")
				_ServerName += "/";

			_EndpointAddresses = new Dictionary<Type, EndpointAddress>
			{
				{ typeof(IQueryService), new EndpointAddress(_ServerName + "QueryService.svc") },
				{ typeof(IStreamingService), new EndpointAddress(_ServerName + "StreamingService.svc") },
				{ typeof(IEmployeeService), new EndpointAddress(_ServerName + "EmployeeService.svc") },
				{ typeof(ICustomerService), new EndpointAddress(_ServerName + "CustomerService.svc") },
				{ typeof(IUserService), new EndpointAddress(_ServerName + "UserService.svc") },
				{ typeof(IValueListService), new EndpointAddress(_ServerName + "ValueListService.svc") },
				{ typeof(IDownloadService), new EndpointAddress(_ServerName + "DownloadService.svc") },
				{ typeof(IResourceService), new EndpointAddress(_ServerName + "ResourceService.svc") },
				{ typeof(IOperationsService), new EndpointAddress(_ServerName + "OperationsService.svc") },
				{ typeof(IOperationsEnhancedService), new EndpointAddress(_ServerName + "OperationsEnhancedService.svc") },
				{ typeof(IAnalysisService), new EndpointAddress(_ServerName + "AnalysisService.svc") },
				{ typeof(IMailService), new EndpointAddress(_ServerName + "MailService.svc") },
				{ typeof(IAccountingService), new EndpointAddress(_ServerName + "AccountingService.svc") },
				{ typeof(IGkvAccountingService), new EndpointAddress(_ServerName + "GkvAccountingService.svc") },
				{ typeof(IReportService), new EndpointAddress(_ServerName + "ReportService.svc") },
				{ typeof(IAiEnhancedService), new EndpointAddress(_ServerName + "AiEnhancedService.svc") }
			};

		}

		static ServiceFacade()
		{
			_ProxyCache = new Dictionary<Type, object>();
		}

		#region AiEnhancedService
		public static void DoAiEnhancedServiceSnyc(Action<IAiEnhancedService> pAction)
		 => DoSync<AiEnhancedServiceClient, IAiEnhancedService>(pAction);
		public static T DoAiEnhancedServiceSnyc<T>(Func<IAiEnhancedService, T> pFunc)
		 => DoSync<AiEnhancedServiceClient, IAiEnhancedService, T>(pFunc);
		public static void DoAiEnhancedServiceAsnyc(Action<IAiEnhancedService> pAction, Action pCallback = null, bool showWaitDialog = true, UserControl caller = null)
		 => DoAsync<AiEnhancedServiceClient, IAiEnhancedService>(pAction, pCallback, showWaitDialog, caller?.Dispatcher);
		public static void DoAiEnhancedServiceAsnyc<T>(Func<IAiEnhancedService, T> pFunc, Action<T> pCallback = null, bool showWaitDialog = true, UserControl caller = null)
		 => DoAsync<AiEnhancedServiceClient, IAiEnhancedService, T>(pFunc, pCallback, showWaitDialog, caller?.Dispatcher);
		#endregion

		#region OperationsEnhancedService
		public static void DoOperationsEnhancedServiceSnyc(Action<IOperationsEnhancedService> pAction)
		 => DoSync<OperationsEnhancedServiceClient, IOperationsEnhancedService>(pAction);
		public static T DoOperationsEnhancedServiceSnyc<T>(Func<IOperationsEnhancedService, T> pFunc)
		 => DoSync<OperationsEnhancedServiceClient, IOperationsEnhancedService, T>(pFunc);
		public static void DoOperationsEnhancedServiceAsnyc(Action<IOperationsEnhancedService> pAction, Action pCallback = null, bool showWaitDialog = true, UserControl caller = null)
		 => DoAsync<OperationsEnhancedServiceClient, IOperationsEnhancedService>(pAction, pCallback, showWaitDialog, caller?.Dispatcher);
		public static void DoOperationsEnhancedServiceAsnyc<T>(Func<IOperationsEnhancedService, T> pFunc, Action<T> pCallback = null, bool showWaitDialog = true, UserControl caller = null)
		 => DoAsync<OperationsEnhancedServiceClient, IOperationsEnhancedService, T>(pFunc, pCallback, showWaitDialog, caller?.Dispatcher);
		#endregion


		public static void DoAccountingServiceAsync<T>(Func<IAccountingService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<AccountingServiceClient, IAccountingService, T>(pFunc, pCallBack, showWaitDialog);
		}
		public static void DoAccountingServiceAsync<T>(Func<IAccountingService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<AccountingServiceClient, IAccountingService, T>(pFunc, pCallBack, true);
		}
		public static void DoAccountingServiceAsync(Action<IAccountingService> pAction)
		{
			DoAsync<AccountingServiceClient, IAccountingService>(pAction, true);
		}
		public static void DoAccountingServiceAsync(Action<IAccountingService> pAction, Action callback)
		{
			DoAsync<AccountingServiceClient, IAccountingService>(pAction, callback, true);
		}
		public static T DoAccountingServiceSync<T>(Func<IAccountingService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<AccountingServiceClient, IAccountingService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}
		public static void DoAnalysisServiceAsync<T>(Func<IAnalysisService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<AnalysisServiceClient, IAnalysisService, T>(pFunc, pCallBack, true);

		}
		public static void DoAnalysisServiceAsync<T>(Func<IAnalysisService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<AnalysisServiceClient, IAnalysisService, T>(pFunc, pCallBack, showWaitDialog);

		}
		public static void DoAccountingServiceSync(Action<IAccountingService> pAction)
		{
			pAction.Invoke(GetInstance<AccountingServiceClient, IAccountingService>());
		}

		//
		public static void DoAnalysisServiceAsync(Action<IAnalysisService> pAction)
		{
			DoAsync<AnalysisServiceClient, IAnalysisService>(pAction, true);
		}

		public static void DoCustomerServiceAsync<T>(Func<ICustomerService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<CustomerServiceClient, ICustomerService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static void DoCustomerServiceAsync<T>(Func<ICustomerService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<CustomerServiceClient, ICustomerService, T>(pFunc, pCallBack, true);
		}

		public static void DoCustomerServiceAsync(Action<ICustomerService> pAction)
		{
			DoAsync<CustomerServiceClient, ICustomerService>(pAction, true);
		}

		public static void DoCustomerServiceSync(Action<ICustomerService> pAction)
		{
			pAction.Invoke(GetInstance<CustomerServiceClient, ICustomerService>());
		}

		public static T DoCustomerServiceSync<T>(Func<ICustomerService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<CustomerServiceClient, ICustomerService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoDownloadServiceAsync<T>(Func<IDownloadService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<DownloadServiceClient, IDownloadService, T>(pFunc, pCallBack, true);
		}

		public static void DoDownloadServiceAsync(Action<IDownloadService> pAction)
		{
			DoAsync<DownloadServiceClient, IDownloadService>(pAction, true);
		}

		public static void DoDownloadServiceSync(Action<IDownloadService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<DownloadServiceClient, IDownloadService>());
			}
			catch (Exception e)
			{
				// if (HandleServiceProxyException(e))
				// throw e;
				ShowErrorMessage(e);
			}
		}

		public static T DoDownloadServiceSync<T>(Func<IDownloadService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<DownloadServiceClient, IDownloadService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoEmployeeServiceAsync<T>(Func<IEmployeeService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<EmployeeServiceClient, IEmployeeService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static void DoEmployeeServiceAsync<T>(Func<IEmployeeService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<EmployeeServiceClient, IEmployeeService, T>(pFunc, pCallBack, true);
		}

		public static void DoEmployeeServiceAsync(Action<IEmployeeService> pAction)
		{
			DoAsync<EmployeeServiceClient, IEmployeeService>(pAction, true);
		}

		public static void DoEmployeeServiceSync(Action<IEmployeeService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<EmployeeServiceClient, IEmployeeService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}

		public static T DoEmployeeServiceSync<T>(Func<IEmployeeService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<EmployeeServiceClient, IEmployeeService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		#region Wohnheim
		public static void DoWohnheimServiceAsync<T>(Func<ICustomerService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<CustomerServiceClient, ICustomerService, T>(pFunc, pCallBack, showWaitDialog);
		}
		public static void DoWohnheimServiceAsync<T>(Func<ICustomerService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<CustomerServiceClient, ICustomerService, T>(pFunc, pCallBack, true);
		}
		public static void DoWohnheimServiceAsync(Action<ICustomerService> pAction)
		{
			DoAsync<CustomerServiceClient, ICustomerService>(pAction, true);
		}
		public static void DoWohnheimServiceSync(Action<ICustomerService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<CustomerServiceClient, ICustomerService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}
		public static T DoWohnheimServiceSync<T>(Func<ICustomerService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<CustomerServiceClient, ICustomerService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}
		#endregion

		#region GkvAccounting
		public static void DoGkvAccountingServiceAsync<T>(Func<IGkvAccountingService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<GkvAccountingServiceClient, IGkvAccountingService, T>(pFunc, pCallBack, showWaitDialog);
		}
		public static void DoGkvAccountingServiceAsync<T>(Func<IGkvAccountingService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<GkvAccountingServiceClient, IGkvAccountingService, T>(pFunc, pCallBack, true);
		}
		public static void DoGkvAccountingServiceAsyncGUI<T>(Func<IGkvAccountingService, T> pFunc, Action<T> pCallBack, Dispatcher dispatcher)
		{
			DoAsync<GkvAccountingServiceClient, IGkvAccountingService, T>(pFunc, pCallBack, true, dispatcher);
		}

		public static void DoGkvAccountingServiceAsync(Action<IGkvAccountingService> pAction)
		{
			DoAsync<GkvAccountingServiceClient, IGkvAccountingService>(pAction, true);
		}
		public static void DoGkvAccountingServiceSync(Action<IGkvAccountingService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<GkvAccountingServiceClient, IGkvAccountingService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}
		public static T DoGkvAccountingServiceSync<T>(Func<IGkvAccountingService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<GkvAccountingServiceClient, IGkvAccountingService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}
		#endregion


		public static void DoMailServiceAsync<T>(Func<IMailService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<MailServiceClient, IMailService, T>(pFunc, pCallBack, true);
		}

		public static void DoMailServiceAsync(Action<IMailService> pAction)
		{
			DoAsync<MailServiceClient, IMailService>(pAction, true);
		}

		public static T DoMailServiceSync<T>(Func<IMailService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<MailServiceClient, IMailService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoMultipleAccountingServicesAsync(List<Action<IAccountingService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<AccountingServiceClient, IAccountingService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleCustomerServicesAsync(List<Action<ICustomerService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<CustomerServiceClient, ICustomerService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleEmployeeServicesAsync(List<Action<IEmployeeService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<EmployeeServiceClient, IEmployeeService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleEmployeeServicesAsync(List<Action<IEmployeeService>> pActions, Action pAllDoneCallBack, bool showWaitDialog)
		{
			DoMulitpleAsync<EmployeeServiceClient, IEmployeeService>(pActions, pAllDoneCallBack, showWaitDialog);
		}

		public static void DoMultipleMailServicesAsync(List<Action<IMailService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<MailServiceClient, IMailService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleOperationsServicesAsync(List<Action<IOperationsService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<OperationsServiceClient, IOperationsService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleOperationsServicesSync(List<Action<IOperationsService>> pActions)
		{
			DoMulitpleSync<OperationsServiceClient, IOperationsService>(pActions, true);
		}

		public static void DoMultipleResourceServicesAsync(List<Action<IResourceService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<ResourceServiceClient, IResourceService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoMultipleValueListServicesAsync(List<Action<IValueListService>> pActions, Action pAllDoneCallBack)
		{
			DoMulitpleAsync<ValueListServiceClient, IValueListService>(pActions, pAllDoneCallBack, true);
		}

		public static void DoOperationsServiceAsync<T>(Func<IOperationsService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<OperationsServiceClient, IOperationsService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static void DoOperationsServiceAsync<T>(Func<IOperationsService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<OperationsServiceClient, IOperationsService, T>(pFunc, pCallBack, true);
		}

		public static void DoOperationsServiceAsync(Action<IOperationsService> pAction, Action pCallBack)
		{
			DoAsync<OperationsServiceClient, IOperationsService>(pAction, pCallBack, true);
		}

		public static void DoOperationsServiceAsync(Action<IOperationsService> pAction)
		{
			DoAsync<OperationsServiceClient, IOperationsService>(pAction, true);
		}

		public static void DoOperationsServiceSync(Action<IOperationsService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<OperationsServiceClient, IOperationsService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}

		public static void DoOperationsServiceAsyncNoWait<T>(Func<IOperationsService, T> pFunc, Action<T, object> pCallBack, object state)
		{
			DoAsync<OperationsServiceClient, IOperationsService, T>(pFunc, cb => pCallBack(cb, state), false);
		}

		public static T DoOperationsServiceSync<T>(Func<IOperationsService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<OperationsServiceClient, IOperationsService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoQueryServiceAsync<T>(Func<IQueryService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<QueryServiceClient, IQueryService, T>(pFunc, pCallBack, true);
		}

		public static void DoQueryServiceAsync(Action<IQueryService> pAction)
		{
			DoAsync<QueryServiceClient, IQueryService>(pAction, true);
		}

		public static T DoQueryServiceSync<T>(Func<IQueryService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<QueryServiceClient, IQueryService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoResourceServiceSync<T>(Func<IResourceService, T> pFunc)
		{
			try
			{
				pFunc.Invoke(GetInstance<ResourceServiceClient, IResourceService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}

		public static void DoResourceServiceAsync<T>(Func<IResourceService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<ResourceServiceClient, IResourceService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static void DoResourceServiceAsync<T>(Func<IResourceService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<ResourceServiceClient, IResourceService, T>(pFunc, pCallBack, true);
		}

		public static void DoResourceServiceAsync(Action<IResourceService> pAction)
		{
			DoAsync<ResourceServiceClient, IResourceService>(pAction, true);
		}

		public static void DoResourceServiceAsync(Action<IResourceService> pAction, Action pCallback)
		{
			DoAsync<ResourceServiceClient, IResourceService>(pAction, pCallback, true);
		}

		public static void DoStreamingServiceAsync<T>(Func<IStreamingService, T> pFunc, Action<T> pCallBack, Action pErrorCallBack)
		{
			DoAsync<StreamingServiceClient, IStreamingService, T>(pFunc, pCallBack, pErrorCallBack, true);
		}

		public static void DoStreamingServiceAsync(Action<IStreamingService> pAction)
		{
			DoAsync<StreamingServiceClient, IStreamingService>(pAction, true);
		}

		public static void DoUserServiceAsync<T>(Func<IUserService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<UserServiceClient, IUserService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static T DoUserServiceSync<T>(Func<IUserService, T> pFunc)
		{
			return pFunc.Invoke(GetInstance<UserServiceClient, IUserService>());
		}

		public static void DoUserServiceAsync(Action<IUserService> pAction, bool showWaitDialog)
		{
			DoAsync<UserServiceClient, IUserService>(pAction, showWaitDialog);
		}

		public static void DoUserServiceAsync(Action<IUserService> pAction, Action pCallBack, bool showWaitDialog)
		{
			DoAsync<UserServiceClient, IUserService>(pAction, pCallBack, showWaitDialog);
		}

		public static void DoValueListServiceAsync<T>(Func<IValueListService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<ValueListServiceClient, IValueListService, T>(pFunc, pCallBack, true);
		}

		public static void DoValueListServiceSync<T>(Func<IValueListService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<ValueListServiceClient, IValueListService, T>(pFunc, pCallBack, true);
		}

		public static T DoValueListServiceSync<T>(Func<IValueListService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<ValueListServiceClient, IValueListService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void DoValueListServiceAsync(Action<IValueListService> pAction)
		{
			DoAsync<ValueListServiceClient, IValueListService>(pAction, true);
		}

		public static void DoReportServiceAsync<T>(Func<IReportService, T> pFunc, Action<T> pCallBack)
		{
			DoAsync<ReportServiceClient, IReportService, T>(pFunc, pCallBack, true);
		}

		public static void DoReportServiceAsync<T>(Func<IReportService, T> pFunc, Action<T> pCallBack, bool showWaitDialog)
		{
			DoAsync<ReportServiceClient, IReportService, T>(pFunc, pCallBack, showWaitDialog);
		}

		public static void DoReportServiceSync(Action<IReportService> pAction)
		{
			try
			{
				pAction.Invoke(GetInstance<ReportServiceClient, IReportService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}

		public static void DoReportServiceAsync(Action<IReportService> pAction)
		{
			DoAsync<ReportServiceClient, IReportService>(pAction, true);
		}

		public static T DoReportServiceSync<T>(Func<IReportService, T> pFunc)
		{
			try
			{
				return pFunc.Invoke(GetInstance<ReportServiceClient, IReportService>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		public static void GetAll<T>(Action<List<T>> pCallBack)
		{
			if (typeof(T) == typeof(CompactCustomerDC))
			{
				long? oid = null;

				if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ViewAll) && !BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View))
				{
					oid = BeWoApp.LoggedOnUser.Employee.EmployeeOid;
				}

				DoCustomerServiceAsync(
					s => s.GetAllActiveCustomersCompact(false, oid),
					r =>
					{
						List<CompactCustomerDC> list = r;

						if (oid != null)
						{
							list = list.Where(c => c.IsRelatedToEmployee).ToList();
						}

						list.Sort((x, y) => { return (x.LastName + ", " + x.FirstName).CompareTo(y.LastName + ", " + y.FirstName); }); // (Comparison<CompactCustomerDC>)new CustomerSorter().GetComparison("LastName", BeWo.Core.AbstractSorter.SortDirection.Ascending));
						pCallBack(list.Cast<T>().ToList());
					});
			}
			else if (typeof(T) == typeof(CompactEmployeeDC))
			{
				DoEmployeeServiceAsync(s => s.GetAllActiveEmployeesCompact().Cast<T>().ToList(), r => pCallBack(r));
			}
			else if (typeof(T) == typeof(CompactTeamDC))
			{
				DoEmployeeServiceAsync(s => s.GetAllTeamsCompact().Cast<T>().ToList(), r => pCallBack(r));
			}
			else if (typeof(T) == typeof(CompactOrganisationDC))
			{
				DoCustomerServiceAsync(s => s.GetAllActiveOrganisationsCompact().Cast<T>().ToList(), r => pCallBack(r));
			}
			else if (typeof(T) == typeof(CompactPersonDC))
			{
				DoCustomerServiceAsync(s => s.GetAllActivePersonsCompact().Cast<T>().ToList(), r => pCallBack(r));
			}
			else if (typeof(T) == typeof(CompactSupportConceptDC))
			{
				DoCustomerServiceAsync(s => s.GetAllActiveSupportConceptsCompact().Cast<T>().ToList(), r => pCallBack(r));
			}
			else if (typeof(T) == typeof(CompactUserDC))
			{
				DoUserServiceAsync(s => s.GetAllUsersCompact().Cast<T>().ToList(), r => pCallBack(r), true);
			}
			else if (typeof(T) == typeof(ResourceDC))
			{
				DoResourceServiceAsync(s => s.GetAllResources().Cast<T>().ToList(), pCallBack, true);
			}
			else if (typeof(T) == typeof(TextModuleDC))
			{
				DoOperationsServiceAsync(s => s.GetAllTextModules().Cast<T>().ToList(), pCallBack);
			}
			else
			{
				throw new NotImplementedException();
			}
		}

		// returnvalue with callback
		private static void DoAsync<TClient, TInterface, T>(Func<TInterface, T> pFunc, Action<T> pCallback,
			bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			DoAsync<TClient, TInterface, T>(pFunc, pCallback, null, showWaitDialog);
		}

		private static void DoAsync<TClient, TInterface, T>(Func<TInterface, T> pFunc, Action<T> pCallback, bool showWaitDialog, Dispatcher dispatcher)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			
			if(dispatcher is null)
			{
				dispatcher = BeWoApp.Current.Dispatcher;
			}

			Action<T> action = (t) => dispatcher.BeginInvoke(
			DispatcherPriority.Normal,
			(Action)delegate
			{
				pCallback(t);
			});

			DoAsync<TClient, TInterface, T>(pFunc, action, showWaitDialog);
		}

		private static void DoAsync<TClient, TInterface, T>(Func<TInterface, T> pFunc, Action<T> pCallback, Action pErrorCallback, bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			try
			{
				if (showWaitDialog)
				{
					StartWaiting();
				}

				pFunc.BeginInvoke(
					GetInstance<TClient, TInterface>(),
					cb =>
					{
						try
						{
							T lResult = pFunc.EndInvoke(cb);
							if (pCallback != null)
							{
								pCallback(lResult);
							}

							if (showWaitDialog)
							{
								EndWaiting();
							}
						}
						catch (Exception e)
						{
							// bool lThrow = ShowErrorMessage(e);
							// if (showWaitDialog) EndWaiting();
							// if (lThrow)
							// throw e;
							if (showWaitDialog)
							{
								EndWaiting();
							}

							ShowErrorMessage(e);
							if (pErrorCallback != null)
							{
								pErrorCallback();
							}
						}
					},
					null);
			}
			catch (Exception e)
			{
				// bool lThrow = ShowErrorMessage(e);
				// if (showWaitDialog) EndWaiting();
				// if (lThrow)
				// throw e;
				if (showWaitDialog)
				{
					EndWaiting();
				}

				ShowErrorMessage(e);
			}
		}

		// void without callback
		private static void DoAsync<TClient, TInterface>(Action<TInterface> pAction, bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			DoAsync<TClient, TInterface>(pAction, null, showWaitDialog);
		}

		private static void DoAsync<TClient, TInterface>(Action<TInterface> pAction, Action pCallback, bool showWaitDialog, Dispatcher dispatcher)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			Action action = pCallback;

			if (dispatcher != null)
			{
				action = () => dispatcher.BeginInvoke(
				DispatcherPriority.Normal,
				(Action)delegate
				{
					pCallback();
				});
			}

			DoAsync<TClient, TInterface>(pAction, action, showWaitDialog);
		}

		// private static void DoAsync<TClient, TInterface>(Action<TInterface> pAction, Action pCallback, bool )
		// void with callback
		private static void DoAsync<TClient, TInterface>(Action<TInterface> pAction, Action pCallback, bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			try
			{
				if (showWaitDialog)
				{
					StartWaiting();
				}

				pAction.BeginInvoke(
					GetInstance<TClient, TInterface>(),
					cb =>
					{
						try
						{
							pAction.EndInvoke(cb);
							if (pCallback != null)
							{
								pCallback();
							}

							if (showWaitDialog)
							{
								EndWaiting();
							}
						}
						catch (Exception e)
						{
							// bool lThrow = ShowErrorMessage(e);
							// if (showWaitDialog) EndWaiting();
							// if (lThrow)
							// throw e;
							if (showWaitDialog)
							{
								EndWaiting();
							}

							ShowErrorMessage(e);
						}
					},
					null);
			}
			catch (Exception e)
			{
				// bool lThrow = ShowErrorMessage(e);
				// if (showWaitDialog) EndWaiting();
				// if (lThrow)
				// throw e;
				if (showWaitDialog)
				{
					EndWaiting();
				}

				ShowErrorMessage(e);
			}
		}

		private static void DoMulitpleAsync<TClient, TInterface>(List<Action<TInterface>> pActions, Action pAllDoneCallBack, bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			int lCount = pActions.Count;
			if (lCount == 0)
			{
				pAllDoneCallBack();
			}

			foreach (var iAction in pActions)
			{
				DoAsync<TClient, TInterface>(
					iAction,
					delegate
					{
						Monitor.Enter(_Lock);
						lCount--;
						Monitor.Exit(_Lock);
						if (lCount == 0)
						{
							pAllDoneCallBack();
						}
					},
					showWaitDialog);
			}
		}

		private static void DoMulitpleSync<TClient, TInterface>(List<Action<TInterface>> pActions, bool showWaitDialog)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			int lCount = pActions.Count;

			if (showWaitDialog)
			{
				StartWaiting();
			}
			foreach (var iAction in pActions)
			{
				iAction.Invoke(GetInstance<TClient, TInterface>());
			}
			if (showWaitDialog)
			{
				EndWaiting();
			}
		}

		private static void DoSync<TClient, TInterface>(Action<TInterface> pAction)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			try
			{
				pAction.Invoke(GetInstance<TClient, TInterface>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}
		}

		private static T DoSync<TClient, TInterface, T>(Func<TInterface, T> pFunc)
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			try
			{
				return pFunc.Invoke(GetInstance<TClient, TInterface>());
			}
			catch (Exception e)
			{
				ShowErrorMessage(e);
			}

			return default(T);
		}

		private static TInterface GetInstance<TClient, TInterface>()
			where TClient : ClientBase<TInterface>, TInterface, new()
			where TInterface : class
		{
			TClient lClient = null;
			if (_ProxyCache.ContainsKey(typeof(TClient)))
			{
				lClient = (TClient)_ProxyCache[typeof(TClient)];

				if (lClient.State == CommunicationState.Closing || lClient.State == CommunicationState.Closed || lClient.State == CommunicationState.Faulted)
				{
					if (lClient.State == CommunicationState.Faulted)
					{
						lClient.Abort();
					}

					lClient = null;
					_ProxyCache.Remove(typeof(TClient));
				}
			}

			if (lClient != null)
			{// EndpointAddresses aktualisieren
				if (!lClient.Endpoint.Address.Equals(EndpointAddresses[typeof(TInterface)]))
				{
					if (lClient.State == CommunicationState.Opened)
						lClient.Close();

					if (_ProxyCache.ContainsKey(typeof(TClient)))
						_ProxyCache.Remove(typeof(TClient));
					lClient = null;
				}
			}

			if (lClient == null)
			{
				lClient = new TClient();

				if (!_ProxyCache.ContainsKey(lClient.GetType()))
				{
					_ProxyCache.Add(typeof(TClient), lClient);
				}

#if DEBUG
				if (DebugConfig.CurrentConfig is DebugConfig current && current.EnableAutoRemoteDebugging)
				{
					if (lClient.Endpoint.Binding is BasicHttpBinding binding)
					{
						if (_ServerName?.StartsWith("https") ?? true)
						{
							binding.Security.Mode = BasicHttpSecurityMode.Transport;
						}
						else
						{
							binding.Security.Mode = BasicHttpSecurityMode.None;
						}
					}
				}
#endif

				lClient.Endpoint.Behaviors.Add(new SecurityHeaderEndpointBehavior());
				lClient.Endpoint.Behaviors.Add(new MultitenancyEndpointBehavior());

				lClient.Endpoint.Address = EndpointAddresses[typeof(TInterface)];
			}

			return lClient;
		}

		private static void ShowErrorMessage(Exception e)
		{
			BeWoApp.ShowErrorMessage(e);
		}

		private static void StartWaiting()
		{
			Monitor.Enter(_Lock);
			if ((++_RunningAsyncs) == 1 && BeWoApp.MainControl != null)
			{
				if (BeWoApp.MainControl.CurrentAnimatedBeWoWindow is null)
					BeWoApp.MainControl.StartWaiting();
				else
					BeWoApp.MainControl.CurrentAnimatedBeWoWindow.StartWaiting();
			}

			Monitor.Exit(_Lock);
		}

		private static void EndWaiting()
		{
			Monitor.Enter(_Lock);
			if ((--_RunningAsyncs) == 0 && BeWoApp.MainControl != null)
			{
				BeWoApp.MainControl.CurrentAnimatedBeWoWindow?.EndWaiting();
				BeWoApp.MainControl.EndWaiting();
			}

			Monitor.Exit(_Lock);
		}

		public static bool IsWaiting()
		{
			return _RunningAsyncs != 0;
		}

		//public static void WaitUntilAsyncIsFinished(Action<bool> callback = null)
		//{
		//	if (!IsWaiting())
		//	{
		//		callback(true);
		//		return;
		//	}	

		//	try
		//	{
		//		Task.Run(() => WaitUntil(() => !IsWaiting(), callback));
		//	}
		//	catch(Exception)
		//	{
		//		callback(false);
		//	}
		//}
		//private static async Task WaitUntil(Func<bool> condition, Action<bool> callback, int frequency = 25, int timeout = -1)
		//{
		//	var waitTask = Task.Run(async () =>
		//	{
		//		while (!condition()) await Task.Delay(frequency);
		//		callback(true);
		//	});

		//	if (waitTask != await Task.WhenAny(waitTask,
		//			Task.Delay(timeout)))
		//		throw new TimeoutException();
		//}
	}
}