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)
{
await MachineProvider.MachineOperator.CompleteWasteReplacement(vm.DialogResult);
}
});
}
#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)
{
IsScreenSaverOn = true;
}
}
#endregion
}
}
