using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;

namespace Tango.MachineStudio.Statistics.Converters
{
    public class StringToFirstLetterConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value != null && value.ToString().Length > 1)
            {
                if(value.ToString().Contains("Light"))
                {
                    var tetst = value.ToString().Substring(5);
                    return "L" + value.ToString().Substring(5).First().ToString().ToUpper();
                }
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.Core.DI;
using Tango.Integration.ExternalBridge;
using Tango.Integration.Operation;
using Tango.PPC.Common;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.Authentication;
using Tango.PPC.Common.ExternalBridge;
using Tango.PPC.Common.Modules;
using Tango.PPC.Common.Navigation;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.WatchDog;
using Tango.PPC.UI.Dialogs;
using Tango.SharedUI;
using System.Data.Entity;
using Tango.PPC.UI.AppBarItems;
using Tango.PPC.Common.Notifications.NotificationItems;
using Tango.Core.Commands;
using System.Timers;

namespace Tango.PPC.UI.ViewModels
{
    /// <summary>
    /// Represents the PPC main view model.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private DispatcherTimer _date_timer;
        private bool _isPowerUpDialogShown;
        private bool _isThreadLoadingShown;
        private PowerUpAppBarItem _powerUpAppBar;
        private bool _started;
        private MessageNotificationItem _headTypeNotification;
        private Timer _screenSaverTimer;

        private DateTime _currentDateTime;
        /// <summary>
        /// Gets or sets the current date time.
        /// </summary>
        public DateTime CurrentDateTime
        {
            get { return _currentDateTime; }
            set { _currentDateTime = value; RaisePropertyChangedAuto(); }
        }

        private bool _isScreenSaverOn;
        public bool IsScreenSaverOn
        {
            get { return _isScreenSaverOn; }
            set { _isScreenSaverOn = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand ScreenSaverExitCommand { get; set; }

        public MainViewVM()
        {
            _date_timer = new DispatcherTimer();
            _date_timer.Interval = TimeSpan.FromSeconds(1);
            _date_timer.Tick += _date_timer_Tick;
            _date_timer.Start();

            _headTypeNotification = new MessageNotificationItem();
            _headTypeNotification.CanClose = false;
            _headTypeNotification.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Error;
            _headTypeNotification.Priority = NotificationItem.NotificationPriority.Critical;
            _headTypeNotification.Message = "Machine head type mismatch.";

            ScreenSaverExitCommand = new RelayCommand(ResetScreenSaverTimer);
            _screenSaverTimer = new Timer(TimeSpan.FromMinutes(Settings.ScreenSaverStartDuration).TotalMilliseconds);
        }

        /// <summary>
        /// Called when the application has been started.
        /// </summary>
        public override void OnApplicationStarted()
        {

        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();
            MachineProvider.MachineOperator.CartridgeValidationRequestReceived += MachineOperator_CartridgeValidationRequestReceived;
            //MachineProvider.MachineOperator.FirmwareStarted += MachineOperator_FirmwareStarted;
            MachineProvider.MachineOperator.ThreadLoadingStatusChanged += MachineOperator_ThreadLoadingStatusChanged;
            MachineProvider.MachineOperator.ThreadLoadingConfirmationRequired += MachineOperator_ThreadLoadingConfirmationRequired;

            MachineProvider.MachineOperator.PowerUpStarted += MachineOperator_PowerUpStarted;
            MachineProvider.MachineOperator.PowerUpProgress += MachineOperator_PowerUpProgress;
            MachineProvider.MachineOperator.PowerUpEnded += MachineOperator_PowerUpEnded;

            MachineProvider.MachineConnected += MachineProvider_MachineConnected;

            MachineProvider.MachineOperator.WasteReplacementRequired += MachineOperator_WasteReplacementRequired;

            _screenSaverTimer.Elapsed += _screenSaverTimer_Elapsed;
            _screenSaverTimer.Start();
        }

        #region Waste Replacement

        private void MachineOperator_WasteReplacementRequired(object sender, EventArgs e)
        {
            InvokeUI(async () => 
            {
                var vm = await NotificationProvider.ShowDialog<WasteReplacementViewVM>();
                
                if (MachineProvider.IsConnected)
                {
                    try
                    {
                        await MachineProvider.MachineOperator.CompleteWasteReplacement(vm.DialogResult);
                    }
                    catch (Exception ex)
                    {
                        await NotificationProvider.ShowError($"Could not complete the process correctly.\n{ex.Message}");
                    }
                }
            });
        }

        #endregion

        #region Power Up

        private void MachineOperator_PowerUpEnded(object sender, EventArgs e)
        {
            _started = false;
            _powerUpAppBar?.Close();
            _powerUpAppBar = null;
        }

        private void MachineOperator_PowerUpProgress(object sender, PMR.Power.StartPowerUpResponse status)
        {
            if (_powerUpAppBar != null)
            {
                _powerUpAppBar.Status = status;
            }
        }

        private void MachineOperator_PowerUpStarted(object sender, PMR.Power.StartPowerUpResponse e)
        {
            _started = true;

            InvokeUI(() =>
            {
                if (_powerUpAppBar != null)
                {
                    _powerUpAppBar.Close();
                }

                if (_started)
                {
                    _powerUpAppBar = NotificationProvider.PushAppBarItem<PowerUpAppBarItem>();
                    _powerUpAppBar.Priority = AppBarPriority.Low;
                }
            });
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the Tick event of the _date_timer.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void _date_timer_Tick(object sender, EventArgs e)
        {
            CurrentDateTime = DateTime.Now;
        }

        private void MachineOperator_CartridgeValidationRequestReceived(object sender, CartridgeValidationEventArgs e)
        {
            InvokeUI(async () =>
            {
                var vm = await NotificationProvider.ShowDialog<CartridgeValidationViewVM>(new CartridgeValidationViewVM()
                {
                    IDSPacks = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.ToList(),
                });

                if (vm.DialogResult)
                {
                    e.Approve(vm.SelectedIDSPack.PackIndex);
                }
                else
                {
                    e.Decline();
                }
            });
        }

        private async void MachineOperator_FirmwareStarted(object sender, EventArgs e)
        {
            if (_isPowerUpDialogShown)
            {
                LogManager.Log("Power up detected but power up dialog is already shown. Skipping...");
                return;
            }

            LogManager.Log("Power up detected, showing power up screen...");

            if (!Settings.DisplayPowerUpScreen)
            {
                LogManager.Log("Power up screen disabled. skipping...");
                return;
            }

            PowerUpViewVM vm;

            try
            {
                LogManager.Log("Loading site rmls...");

                List<Rml> rmls = new List<Rml>();

                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    rmls = (await new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).BuildListAsync()).OrderBy(x => x.FinalName).ToList();
                }

                var selectedRml = rmls.SingleOrDefault(x => x.Guid == Settings.LoadedRmlGuid);

                vm = new PowerUpViewVM();
                vm.Rmls = rmls;
                vm.SelectedRml = selectedRml != null ? selectedRml : rmls.FirstOrDefault();
                vm.IsSelectedRml = selectedRml != null;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error initializing power up screen.");
                return;
            }

            InvokeUI(async () =>
            {
                _isPowerUpDialogShown = true;
                await NotificationProvider.ShowDialog<PowerUpViewVM>(vm);
                _isPowerUpDialogShown = false;

                await Task.Factory.StartNew(() =>
                {
                    LogManager.Log("Power up screen closed.");

                    try
                    {
                        using (ObservablesContext db = ObservablesContext.CreateDefault())
                        {
                            List<ProcessParametersTable> processTables = new List<ProcessParametersTable>();

                            if (vm.IsSelectedRml)
                            {
                                LogManager.Log($"Selected rml '{vm.SelectedRml.Name}'...");
                                processTables = new RmlBuilder(db).Set(vm.SelectedRml.Guid).WithActiveParametersGroup().Build().GetActiveProcessGroup().ProcessParametersTables.ToList();
                            }
                            else
                            {
                                LogManager.Log("Selected minimal temperature...");
                                var rmlsToAvg = new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).WithActiveParametersGroup().Build();
                                processTables = rmlsToAvg.Select(x => x.GetActiveProcessGroup()).SelectMany(x => x.ProcessParametersTables).ToList();
                            }

                            var processToLoad = processTables.OrderBy(x => x.GetAverageTemperature()).First();

                            LogManager.Log($"Selected process parameters:\nRML: {processToLoad.ProcessParametersTablesGroup.Rml.Name}\nGroup: {processToLoad.ProcessParametersTablesGroup.Name}\nProcess Table: {processToLoad.Name}");
                            LogManager.Log("Uploading process parameters...");
                            var r = MachineProvider.MachineOperator.UploadProcessParameters(processToLoad).Result;

                            Settings.LoadedRmlGuid = vm.IsSelectedRml ? vm.SelectedRml.Guid : null;
                            Settings.Save();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error occurred while trying to get and upload the proper process parameters after power screen closed.");
                    }
                });
            });
        }

        private void MachineOperator_ThreadLoadingStatusChanged(object sender, PMR.ThreadLoading.StartThreadLoadingResponse e)
        {
            //if (e.State == PMR.ThreadLoading.ThreadLoadingState.Preparing)
            //{
            //    DisplayThreadLoading();
            //}
        }

        private void MachineOperator_ThreadLoadingConfirmationRequired(object sender, ThreadLoadingConfirmationRequiredEventArgs e)
        {
//            DisplayThreadLoading(e);
        }
        #endregion

        #region Head Type Check

        private void MachineProvider_MachineConnected(object sender, EventArgs e)
        {
            ResetScreenSaverTimer();

            NotificationProvider.PopNotification(_headTypeNotification);

            if (MachineProvider.MachineOperator.DeviceInformation != null && !MachineProvider.Machine.IsDemo)
            {
                if (MachineProvider.Machine.HeadType != (int)MachineProvider.MachineOperator.DeviceInformation.HeadType)
                {
                    _headTypeNotification.ExpandedMessage = $"Machine configuration reports head type '{MachineProvider.Machine.MachineHeadType}' while firmware device reports '{MachineProvider.MachineOperator.DeviceInformation.HeadType}'.";
                    NotificationProvider.PushNotification(_headTypeNotification);
                }
            }
        }

        #endregion

        #region Screen Saver

        public void ResetScreenSaverTimer()
        {
            _screenSaverTimer.Stop();
            _screenSaverTimer.Start();
            IsScreenSaverOn = false;
        }

        private void _screenSaverTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            _screenSaverTimer.Interval = TimeSpan.FromMinutes(Settings.ScreenSaverStartDuration).TotalMilliseconds;

            if (Settings.EnableScreenSaver && !MachineProvider.IsConnected && !BuildProvider.IsEureka)
            {
                IsScreenSaverOn = true;
            }
        }
        
        #endregion
    }
}