using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using System.IO;
using System.Diagnostics;
using System.Web;

using Microsoft.Win32;

using Newtonsoft.Json;

using FasdDesktopUi.Basics;
using FasdDesktopUi.Basics.Models;
using FasdDesktopUi.Basics.Helper;
using FasdDesktopUi.Pages.CustomMessageBox;
using FasdDesktopUi.Pages.DetailsPage.Models;
using FasdDesktopUi.Pages.SplashScreenView;
using FasdDesktopUi.Pages.M42AuthenticationPage;
using FasdDesktopUi.Pages.SearchPage;

using C4IT.FASD.Base;
using C4IT.FASD.Cockpit.Communication;
using C4IT.Logging;
using C4IT.MultiLanguage;
using C4IT.F4SD.TAPI;

using static C4IT.Logging.cLogManager;


namespace FasdDesktopUi
{
    public class cAppStartUp
    {
        public const string constUrlProtocol = "F4SDSEND";
        public const string constUrlCommand = "sendurl";
        private static bool AreAppComponentsInitialized = false;

        private static SplashScreenView splashScreen;

        public static async Task<bool> StartAsync(string[] startArguments)
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
#if isDemo
                cFasdCockpitCommunicationBase.Instance = new cFasdCockpitCommunicationDemo();
#else
                cFasdCockpitCommunicationBase.Instance = new cFasdCockpitCommunicationWeb();
#endif

                if (!startArguments.Contains("SilentStart", StringComparer.InvariantCultureIgnoreCase))
                {
                    splashScreen = new SplashScreenView();
                    splashScreen?.Show();
                }

                var searchPageView = SearchPageView.Instance;
                var settingsPageView = FasdDesktopUi.Pages.SettingsPage.SettingsPageView.Create();

                splashScreen?.SetStatusText(cMultiLanguageSupport.GetItem("StartUp.SplashScreen.CheckServerConnection"));
                if (!await InitializeCommunicationAsync())
                {
                    LogEntry("Error when initializing communication components.", LogLevels.Fatal);
                    CustomMessageBox.Show("Error when initializing communication components.", "Fatal Error", enumHealthCardStateLevel.Error);
                    Application.Current.Shutdown();
                }

                if (cConnectionStatusHelper.Instance.ApiConnectionStatus >= cConnectionStatusHelper.enumOnlineStatus.illegalConfig)
                {
                    splashScreen?.SetStatusText(cMultiLanguageSupport.GetItem("StartUp.SplashScreen.InitAppComponents"));
                    if (!await InitializeUiElementsAsync())
                        return false;
                }
                cConnectionStatusHelper.ApiConnectionStatusChanged += ApiConnectionStatusChanged;

                // Aufruf der neuen Prominenteren Suche (work in progress)
                //var advancedPaged = new AdvancedSearchPage();
                //advancedPaged.Show();

                return true;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                splashScreen?.Hide();
                LogMethodEnd(CM);
            }

            return false;
        }

        public static bool ProcessCommandLine(string[] Args)
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                if (DefaultLogger.IsDebug)
                {
                    var _msg = new List<string>() { "command line arguments:" };
                    foreach (var _entry in Args)
                        _msg.Add(_entry);
                    DefaultLogger.LogList(LogLevels.Debug, _msg);
                }

                var Command = Args[0].ToLowerInvariant();
                bool shouldShutdown = true;

                switch (Command)
                {
                    case "search":
                        if (Args.Length < 2)
                        {
                            LogEntry($"Missing search value on command line for command {Command}.", LogLevels.Error);
                            break;
                        }
                        var Search = Args[1];
                        cAppStartUp.SendSearchValue(Search);
                        break;
                    case "phonesearch":
                        try
                        {
                            if (Args.Length < 2)
                            {
                                LogEntry($"Missing search value on command line for command {Command}.", LogLevels.Error);
                                break;
                            }

                            var searchInfo = new cPhoneSearchParameters
                            {
                                phone = Args[1]
                            };
                            if (Args.Length >= 3)
                                searchInfo.name = Args[2];
                            SendPhoneSearchValues(searchInfo);
                        }
                        catch (Exception E)
                        {
                            LogException(E);
                        }
                        break;
                    case "computerdomainsearch":
                        try
                        {
                            if (Args.Length < 2)
                            {
                                LogEntry($"Missing a search value on command line for command {Command}.", LogLevels.Error);
                                break;
                            }

                            var searchInfo = new cComputerDomainSearchParameters()
                            {
                                name = Args[1],
                                domain = ""
                            };
                            if (Args.Length >= 3)
                                searchInfo.domain = Args[2];
                            cAppStartUp.SendComputerDomainSearchValues(searchInfo);
                        }
                        catch (Exception E)
                        {
                            LogException(E);
                        }

                        break;
                    case "usersidsearch":
                        try
                        {
                            if (Args.Length < 2)
                            {
                                LogEntry($"Missing a search value on command line for command {Command}.", LogLevels.Error);
                                break;
                            }

                            var searchInfo = new cUserSidSearchParameters()
                            {
                                name = Args[1],
                                sids = ""
                            };
                            if (Args.Length >= 3)
                                searchInfo.sids = Args[2];
                            cAppStartUp.SendUserSidSearchValues(searchInfo);
                        }
                        catch (Exception E)
                        {
                            LogException(E);
                        }

                        break;
                    case "ticketsearch":
                        try
                        {
                            if (Args.Length < 4)
                            {
                                LogEntry($"Missing a search value on command line for command {Command}.", LogLevels.Error);
                                break;
                            }

                            var searchInfo = new cTicketSearchParameters()
                            {
                                ticketName = Args[1],
                                ticketId = Args[2],
                                userName = Args[3],
                                sids = ""
                            };
                            if (Args.Length >= 5)
                                searchInfo.sids = Args[4];
                            cAppStartUp.SendTicketSearchValues(searchInfo);
                        }
                        catch (Exception E)
                        {
                            LogException(E);
                        }

                        break;
                    case constUrlCommand:
                        if (Args.Length < 2)
                        {
                            LogEntry("Missing url on command line.", LogLevels.Error);
                            break;
                        }
                        var Url = Args[1];
                        cAppStartUp.ProcessMessageUrl(Url);
                        break;
                    default:
                        shouldShutdown = false;
                        LogEntry($"Unknown command on commandline: {Command}", LogLevels.Warning);
                        break;
                }

                return shouldShutdown;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }

            return false;
        }

        public static void ProcessMessageUrl(string url)
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                if (url.Length <= constUrlProtocol.Length + 3)
                {
                    LogEntry($"No valid {constUrlProtocol} message.", LogLevels.Warning);
                    return;
                }

                var urlPrefix = url.Substring(0, constUrlProtocol.Length + 3).ToLowerInvariant();
                if (urlPrefix != constUrlProtocol.ToLowerInvariant() + "://")
                {
                    LogEntry($"Unknown protocol prefix {urlPrefix}. Should be {constUrlProtocol}://", LogLevels.Warning);
                    return;
                }

                var arr1 = url.Split('?');

                if (arr1.Length < 2)
                {
                    LogEntry("No valid url parameters.", LogLevels.Warning);
                    return;
                }

                var arrParams = arr1[1].Split('&');
                var dicParams = new Dictionary<string, string>();

                foreach (var param in arrParams)
                {
                    var arr2 = param.Split('=');
                    if (arr2.Length != 2)
                    {
                        LogEntry($"Invalid url parameter: {param}", LogLevels.Warning);
                        continue;
                    }

                    var name = HttpUtility.UrlDecode(arr2[0]).Trim().ToLowerInvariant();
                    var value = HttpUtility.UrlDecode(arr2[1]).Trim();
                    dicParams[name] = value;
                }

                if (!dicParams.TryGetValue("command", out var commandType))
                {
                    LogEntry("Missing command parameter in url.", LogLevels.Warning);
                    return;
                }

                switch (commandType.ToLowerInvariant())
                {
                    case "search":
                        if (!dicParams.TryGetValue("value", out var searchValue))
                        {
                            LogEntry("Missing value parameter in url.", LogLevels.Warning);
                            return;
                        }
                        SendSearchValue(searchValue);
                        break;
                    case "phonesearch":
                        {
                            if (!dicParams.TryGetValue("phone", out var searchPhone))
                            {
                                LogEntry("Missing phone parameter in url.", LogLevels.Warning);
                                return;
                            }
                            if (!dicParams.TryGetValue("name", out var searchName))
                                searchName = null;
                            var searchInfo = new cPhoneSearchParameters() { phone = searchPhone, name = searchName };
                            SendPhoneSearchValues(searchInfo);
                        }
                        break;
                    case "usersidsearch":
                        {
                            if (!dicParams.TryGetValue("name", out var searchName))
                            {
                                LogEntry("Missing name parameter in url.", LogLevels.Warning);
                                return;
                            }
                            if (!dicParams.TryGetValue("sids", out var searchSids))
                                searchSids = null;
                            var searchInfo = new cUserSidSearchParameters() { name = searchName, sids = searchSids };
                            SendUserSidSearchValues(searchInfo);
                        }
                        break;
                    case "computerdomainsearch":
                        {
                            if (!dicParams.TryGetValue("name", out var searchName))
                            {
                                LogEntry("Missing name parameter in url.", LogLevels.Warning);
                                return;
                            }
                            if (!dicParams.TryGetValue("domain", out var searchDomain))
                                searchDomain = null;
                            var searchInfo = new cComputerDomainSearchParameters() { name = searchName, domain = searchDomain };
                            SendComputerDomainSearchValues(searchInfo);
                        }
                        break;
                    case "ticketsearch":
                        {
                            if (!dicParams.TryGetValue("tname", out var _tname))
                            {
                                LogEntry("Missing ticket name parameter in url.", LogLevels.Warning);
                                return;
                            }
                            if (!dicParams.TryGetValue("tid", out var _tid))
                            {
                                LogEntry("Missing ticket id parameter in url.", LogLevels.Warning);
                                return;
                            }
                            if (!dicParams.TryGetValue("uname", out var _uname))
                            {
                                LogEntry("Missing ticket id parameter in url.", LogLevels.Warning);
                                return;
                            }

                            var searchInfo = new cTicketSearchParameters()
                            {
                                ticketName = _tname,
                                ticketId = _tid,
                                userName = _uname
                            };
                            if (dicParams.TryGetValue("sids", out var _sids))
                                searchInfo.sids = _sids;
                            SendTicketSearchValues(searchInfo);
                        }
                        break;
                    default:
                        LogEntry($"Unknown url command parameter: {commandType}.", LogLevels.Warning);
                        break;
                }
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        public static void SendSearchValue(string searchValue)
        {
            cF4sdPipeClient.Send("search:" + searchValue, App.PipeName);
        }

        public static void SendPhoneSearchValues(cPhoneSearchParameters search)
        {
            var jsonSearch = JsonConvert.SerializeObject(search);
            cF4sdPipeClient.Send("phonesearch:" + jsonSearch, App.PipeName);
        }

        public static void SendComputerDomainSearchValues(cComputerDomainSearchParameters search)
        {
            var jsonSearch = JsonConvert.SerializeObject(search);
            cF4sdPipeClient.Send("computerdomainsearch:" + jsonSearch, App.PipeName);
        }

        public static void SendUserSidSearchValues(cUserSidSearchParameters search)
        {
            var jsonSearch = JsonConvert.SerializeObject(search);
            cF4sdPipeClient.Send("usersidsearch:" + jsonSearch, App.PipeName);
        }

        public static void SendTicketSearchValues(cTicketSearchParameters search)
        {
            var jsonSearch = JsonConvert.SerializeObject(search);
            cF4sdPipeClient.Send("ticketsearch:" + jsonSearch, App.PipeName);
        }

        private static async Task<bool> InitializeCommunicationAsync()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                if (!cFasdCockpitCommunicationBase.Instance.CheckConnectionInfo())
                {
                    CustomMessageBox.Show("No valid server URL found in registry.", "First Aid Service Desk", enumHealthCardStateLevel.Error);
                    LogEntry("No valid server URL found in registry.");
                    return false;
                }

                var _csh = new cConnectionStatusHelper();
                _csh.M42FormBasedAuthentication += F4sdM42FormsAuthentication.M42FormBasedAuthenticationDelegate;
                cConnectionStatusHelper.Instance = _csh;

                await cConnectionStatusHelper.Instance.RunConnectionStatusCheckAsync(splashScreen);
                cConnectionStatusHelper.Instance.OnApiConnectionStatusChanged();

                return true;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }

            return false;
        }

        private static async void ApiConnectionStatusChanged(cConnectionStatusHelper.enumOnlineStatus? Status)
        {
            try
            {
                if (AreAppComponentsInitialized || Status != cConnectionStatusHelper.enumOnlineStatus.online)
                    return;

                await InitializeUiElementsAsync();
            }
            catch (Exception E)
            {
                LogException(E);
            }
        }

        private static bool CheckSwyxIt()
        {
            try
            {
                var regObj = Registry.GetValue("HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{F8E552F8-4C00-11D3-80BC-00105A653379}\\VersionIndependentProgID", null, null);
                if ((regObj is string strObj) && (strObj.ToLowerInvariant() == "clmgr.clientlinemgr"))
                    return true;
                regObj = Registry.GetValue("HKEY_CLASSES_ROOT\\CLSID\\{F8E552F8-4C00-11D3-80BC-00105A653379}\\VersionIndependentProgID", null, null);
                if ((regObj is string strObj2) && (strObj2.ToLowerInvariant() == "clmgr.clientlinemgr"))
                    return true;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            return false;
        }

        private static void TapiMessageHandler(C4TapiHelper.C4TapiLineInfo lineInfo)
        {
            try
            {
                if (lineInfo.eventType == C4TapiHelper.eTapiEventType.connected)
                {

                    var CM = MethodBase.GetCurrentMethod();
                    LogMethodBegin(CM);
                    try
                    {
                        if (lineInfo.IsOutbound && !cFasdCockpitConfig.Instance.PhoneSupport.SignalOutgoingCalls)
                        {
                            LogEntry("An outgoing call is signaled but signaling outgoing calls is not enabled.");
                            return;
                        }

                        var phone = lineInfo.participantPhoneNumber;
                        var phone2 = phone.Trim();
                        if (!string.IsNullOrEmpty(cFasdCockpitConfig.Instance.PhoneSupport.ExternalCallPrefix) && phone2.StartsWith(cFasdCockpitConfig.Instance.PhoneSupport.ExternalCallPrefix))
                            phone2 = phone2.Remove(0, cFasdCockpitConfig.Instance.PhoneSupport.ExternalCallPrefix.Length);

                        if (phone2.StartsWith("+"))
                        {
                            var _r = Math.Min(phone2.Length, 3);
                            phone2 = phone2.Remove(0, _r);
                        }
                        else if (phone2.StartsWith("00"))
                        {
                            var _r = Math.Min(phone2.Length, 4);
                            phone2 = phone2.Remove(0, _r);
                        }
                        if (phone2.StartsWith("0"))
                            phone2 = phone2.Remove(0, 1);

                        var phone3 = "";
                        foreach (var C in phone2)
                            if ((C >= '0') && (C <= '9'))
                                phone3 += C;

                        var phoneSearch = new cPhoneSearchParameters()
                        {
                            phone = phone3,
                            name = lineInfo.participantName.Trim()
                        };
                        SendPhoneSearchValues(phoneSearch);
                    }
                    catch (Exception E)
                    {
                        LogException(E);
                    }
                    finally
                    {
                        LogMethodEnd(CM);
                    }
                }
            }
            catch (Exception E)
            {
                LogException(E);
            }
        }

        private static void StartPhoneCallMonitoring()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);

            // check phone support disabled
            if (cFasdCockpitConfig.Instance.PhoneSupport.DisablePhoneSupport)
                return;

            var disposeTapi = false;
            try
            {
                // get the TAPI lines
                lock (C4TapiHelper.InstanceLock)
                {
                    C4TapiHelper.Instance = new C4TapiHelper();
                    disposeTapi = true;
                    C4TapiHelper.Instance.Initialize(TapiMessageHandler);
                    C4TapiHelper.Instance.GetLines();
                }


                // check prefer swyxit
                if (cFasdCockpitConfig.Instance.PhoneSupport.PreferSwyxitNative && CheckSwyxIt())
                {
                    if (StartPhoneMonitorExternal("SwyxItNative"))
                        return;
                }

                // check if we autoconnect TAPI
                lock (C4TapiHelper.InstanceLock)
                {
                    string _tapiLine = null;
                    if (C4TapiHelper.Lines != null && !string.IsNullOrEmpty(cFasdCockpitConfig.Instance.PhoneSupport.PreferedTapiLine) && C4TapiHelper.Lines.Contains(cFasdCockpitConfig.Instance.PhoneSupport.PreferedTapiLine))
                        _tapiLine = cFasdCockpitConfig.Instance.PhoneSupport.PreferedTapiLine;
                    else if (C4TapiHelper.Lines != null && C4TapiHelper.Lines.Count == 1)
                        _tapiLine = C4TapiHelper.Lines[0];

                    if (_tapiLine != null)
                    {
                        if (cFasdCockpitConfig.Instance.PhoneSupport.UseTapi32Bit)
                        {
                            if (StartPhoneMonitorExternal(_tapiLine))
                                return;
                        }

                        if (C4TapiHelper.Instance.ConnectLine(C4TapiHelper.Lines[0]))
                            disposeTapi = false;
                    }
                }
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                lock (C4TapiHelper.InstanceLock)
                {
                    if (disposeTapi)
                    {
                        C4TapiHelper.Instance.Dispose();
                        C4TapiHelper.Instance = null;
                    }
                }
                LogMethodEnd(CM);
            }

        }

        private static bool StartPhoneMonitorExternal(string Line)
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                var ass = Assembly.GetEntryAssembly();
                var path = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(ass.Location)), "F4SD-PhoneMonitor.exe");
                if (File.Exists(path))
                {
                    var preFix = cFasdCockpitConfig.Instance.PhoneSupport.ExternalCallPrefix ?? "";
                    var signalExtern = cFasdCockpitConfig.Instance.PhoneSupport.SignalOutgoingCalls ? "1" : "0";
                    var _cmd = "\"" + App.PipeName + "\" \"" + App.PhoneMonitorPipeName + "\" \"" + Line + "\" \"" + preFix + "\" \"" + signalExtern + "\"";
                    var pr = Process.Start(path, _cmd);
                    return true;
                }
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }

            return false;
        }

        private static async Task<bool> InitializeUiElementsAsync()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                splashScreen?.SetStatusText(cMultiLanguageSupport.GetItem("StartUp.SplashScreen.LoadAppViews"));

                CheckHealthCardAvailability();
                UpdateRegistryGeometryBasedOnFirstDataOfDataProvider();

                // adjust notify icon menu
                cF4sdUserInfo userInfo;
                lock (cFasdCockpitCommunicationBase.CockpitUserInfoLock)
                {
                    userInfo = cFasdCockpitCommunicationBase.CockpitUserInfo;
                }
                if (!string.IsNullOrEmpty(cCockpitConfiguration.Instance?.m42ServerConfiguration?.Server))
                    if (userInfo?.possibleLogons != null)
                    {
                        if (userInfo.possibleLogons.Contains(enumAdditionalAuthentication.M42WinLogon))
                        {
                            if (App.M42OptionMenuItem != null)
                            {
                                App.M42OptionMenuItem.Visible = true;
                            }
                        }
                    }

                await InitializeViewsAsync();

                AreAppComponentsInitialized = true;

                var PhoneThread = new Thread(StartPhoneCallMonitoring);
                PhoneThread.Start();

                return true;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }

            return false;
        }

        private static void CheckHealthCardAvailability()
        {
            try
            {
                if (!cHealthCardDataHelper.HasAvailableHealthCard(new List<enumFasdInformationClass>() { enumFasdInformationClass.Ticket }))
                    LogEntry("No available Health Card for Tickets was found.", LogLevels.Info);

                if (!cHealthCardDataHelper.HasAvailableHealthCard(new List<enumFasdInformationClass>() { enumFasdInformationClass.Computer }))
                    LogEntry("No available Health Card for computers was found.", LogLevels.Error);

                if (!cHealthCardDataHelper.HasAvailableHealthCard(new List<enumFasdInformationClass>() { enumFasdInformationClass.User }))
                    LogEntry("No available Health Card for users was found.", LogLevels.Error);
            }
            catch (Exception E)
            {
                LogException(E);
            }
        }


        public static void Terminate()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                lock (C4TapiHelper.InstanceLock)
                {
                    if (C4TapiHelper.Instance != null)
                    {
                        C4TapiHelper.Instance.Dispose();
                        C4TapiHelper.Instance = null;
                    }
                }

            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        #region Views & Geometry

        private static void UpdateRegistryGeometryBasedOnFirstDataOfDataProvider()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                //Get old geometry from registry
                DetailsPageGeometry lastGeometry = !string.IsNullOrEmpty(cFasdCockpitConfig.Instance.DetailsPageMaxGeometry) ?
                    JsonConvert.DeserializeObject<DetailsPageGeometry>(cFasdCockpitConfig.Instance.DetailsPageMaxGeometry) :
                    new DetailsPageGeometry()
                    {
                        DetailsCollectionGeometry = new DetailsPageDataHistoryCollectionGeometryModel() { SubtitleCount = new List<int>() },
                        WidgetGeometryList = new List<DetailsPageWidgetGeometryModel>()
                    };

                //Get new geometry from DataList
                cHealthCard firstHealthCard = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.HealthCards.FirstOrDefault(healthCard => healthCard.Value.InformationClasses.Contains(enumFasdInformationClass.Computer)).Value;


                DetailsPageGeometry newGeometry = new DetailsPageGeometry()
                {
                    DetailsCollectionGeometry = new DetailsPageDataHistoryCollectionGeometryModel() { SubtitleCount = new List<int>() },
                    WidgetGeometryList = new List<DetailsPageWidgetGeometryModel>()
                };

                foreach (var widgetData in firstHealthCard.CategoriesStatic.StateCategories)
                {
                    if (widgetData.IsHidden)
                        continue;
                    newGeometry.WidgetGeometryList.Add(new DetailsPageWidgetGeometryModel() { WidgetTitleCount = widgetData.States.Count, WidgetDetailCount = widgetData.States.Count });
                }

                newGeometry.DetailsCollectionGeometry.ColumnCount = firstHealthCard.MaxAgeInDays;
                foreach (var detailsData in firstHealthCard.CategoriesHistory.StateCategories)
                {
                    if (detailsData.IsHidden)
                        continue;
                    var stateCount = detailsData.States.Count;
                    foreach (var state in detailsData.States)
                    {
                        if (state.IsHidden)
                            continue;
                        if (state is cHealthCardStateAggregation aggregationState)
                            stateCount += aggregationState.States.Count;
                    }

                    newGeometry.DetailsCollectionGeometry.SubtitleCount.Add(stateCount);
                }

                //Update new geometry
                var lastGeometryWidgetEnumerator = lastGeometry.WidgetGeometryList.GetEnumerator();
                foreach (var widgetGeometry in newGeometry.WidgetGeometryList)
                {
                    if (lastGeometryWidgetEnumerator.MoveNext())
                    {
                        var lastWidgetGeometry = lastGeometryWidgetEnumerator.Current;
                        widgetGeometry.WidgetTitleCount = cUtility.SmoothedInt(lastWidgetGeometry.WidgetTitleCount, widgetGeometry.WidgetTitleCount);
                        widgetGeometry.WidgetDetailCount = cUtility.SmoothedInt(lastWidgetGeometry.WidgetDetailCount, widgetGeometry.WidgetDetailCount);
                    }
                }

                newGeometry.DetailsCollectionGeometry.ColumnCount = cUtility.SmoothedInt(lastGeometry.DetailsCollectionGeometry.ColumnCount, newGeometry.DetailsCollectionGeometry.ColumnCount);

                var lastGeometryDetailsSubtitleEnumerator = lastGeometry.DetailsCollectionGeometry.SubtitleCount.GetEnumerator();

                for (int i = 0; i < newGeometry.DetailsCollectionGeometry.SubtitleCount.Count; i++)
                {
                    if (lastGeometryDetailsSubtitleEnumerator.MoveNext())
                    {
                        int tempSubtitleCountValue = newGeometry.DetailsCollectionGeometry.SubtitleCount[i];
                        int newSubtitleCountValue = cUtility.SmoothedInt(lastGeometryDetailsSubtitleEnumerator.Current, tempSubtitleCountValue);
                        newGeometry.DetailsCollectionGeometry.SubtitleCount[i] = newSubtitleCountValue;
                    }
                }

                //Save new Geometry
                cFasdCockpitConfig.Instance.DetailsPageMaxGeometry = JsonConvert.SerializeObject(newGeometry);
                cFasdCockpitConfig.Instance.Save("DetailsPageMaxGeometry");
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private static DetailsPageGeometry BaseDetailsPageGeometry()
        {
            try
            {
                string registryGeometryString = cFasdCockpitConfig.Instance.DetailsPageMaxGeometry;

                DetailsPageGeometry output = !string.IsNullOrEmpty(registryGeometryString) ?
                    JsonConvert.DeserializeObject<DetailsPageGeometry>(registryGeometryString) :
                    new DetailsPageGeometry() { DetailsCollectionGeometry = new DetailsPageDataHistoryCollectionGeometryModel() { SubtitleCount = new List<int>() }, WidgetGeometryList = new List<DetailsPageWidgetGeometryModel>() };

                return output;
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
            }
            return null;
        }

        private static async Task InitializeViewsAsync()
        {
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                var _arrTasks = new List<Task>
                {
                    Application.Current.Dispatcher.BeginInvoke((Action)delegate { cSupportCaseDataProvider.slimPage = new Pages.SlimPage.SlimPageView(); }, DispatcherPriority.Normal).Task,
                    Application.Current.Dispatcher.BeginInvoke((Action)delegate { cSupportCaseDataProvider.detailsPage = new Pages.DetailsPage.DetailsPageView(); }, DispatcherPriority.Normal).Task
                };
                await Task.WhenAll(_arrTasks);
                _arrTasks = new List<Task>
                {
                    Application.Current.Dispatcher.BeginInvoke((Action)delegate { cSupportCaseDataProvider.detailsPage.SetGeometryValues(BaseDetailsPageGeometry()); }, DispatcherPriority.Normal).Task,
                    Application.Current.Dispatcher.BeginInvoke((Action)delegate { cSupportCaseDataProvider.slimPage.SetZoomValue(cFasdCockpitConfig.Instance.SlimPageZoom); }, DispatcherPriority.Normal).Task,
                    Application.Current.Dispatcher.BeginInvoke((Action)delegate { cSupportCaseDataProvider.detailsPage.SetZoomValue(cFasdCockpitConfig.Instance.DetailsPageZoom); }, DispatcherPriority.Normal).Task
                };
                await Task.WhenAll(_arrTasks);
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        #endregion
    }
}