using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace RealTimeGraphX.WPF.Components
{
    /// <summary>
    /// Represents a graph grid lines component.
    /// </summary>
    /// <seealso cref="RealTimeGraphX.GraphSurfaceComponentBase" />
    public class GraphGridLines : GraphSurfaceComponentBase
    {
        /// <summary>
        /// Gets or sets the number of grid rows.
        /// </summary>
        public int Rows
        {
            get { return (int)GetValue(RowsProperty); }
            set { SetValue(RowsProperty, value); }
        }
        public static readonly DependencyProperty RowsProperty =
            DependencyProperty.Register("Rows", typeof(int), pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
using Ionic.Zip;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.Core;
using Tango.Core.Commands;
using Tango.Explorer;
using Tango.Integration.Operation;
using Tango.Logging;
using Tango.PMR.Diagnostics;
using Tango.PMR.IFS;
using Tango.PMR.MachineStatus;
using Tango.PPC.Common;
using Tango.PPC.Maintenance.Commands;
using Tango.PPC.Maintenance.Dialogs;
using Tango.PPC.Maintenance.Helpers;
using Tango.PPC.Maintenance.Models;
using Tango.PPC.Maintenance.Views;
using Tango.PPC.Storage;

namespace Tango.PPC.Maintenance.ViewModels
{
    public class MaintenanceViewVM : PPCViewModel
    {
        public class WasteStateModel : ExtendedObject
        {
            private CartridgeState _state;
            public CartridgeState State
            {
                get { return _state; }
                set { _state = value; RaisePropertyChangedAuto(); }
            }

            public CartridgeSlot Slot { get; set; }
        }

        public ObservableCollection<GuideBase> Guides { get; set; }

        public RelayCommand<GuideBase> OpenGuideCommand { get; set; }

        private List<MidTankLevelModel> _midTankLevels;
        public List<MidTankLevelModel> MidTankLevels
        {
            get { return _midTankLevels; }
            set { _midTankLevels = value; RaisePropertyChangedAuto(); }
        }

        private OverallTemperatureModel _overallTemperature;
        public OverallTemperatureModel OverallTemperature
        {
            get { return _overallTemperature; }
            set { _overallTemperature = value; RaisePropertyChangedAuto(); }
        }

        private String _totalDyeTime;
        public String TotalDyeTime
        {
            get { return _totalDyeTime; }
            set { _totalDyeTime = value; RaisePropertyChangedAuto(); }
        }

        private String _totalDyeMeters;
        public String TotalDyeMeters
        {
            get { return _totalDyeMeters; }
            set { _totalDyeMeters = value; RaisePropertyChangedAuto(); }
        }

        private SpoolState _spoolState;
        public SpoolState SpoolState
        {
            get { return _spoolState; }
            set
            {
                if (_spoolState != value)
                {
                    _spoolState = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        private List<WasteStateModel> _wasteStates;
        public List<WasteStateModel> WasteStates
        {
            get { return _wasteStates; }
            set { _wasteStates = value; RaisePropertyChangedAuto(); }
        }

        private bool _isInkAutoFillingEnabled;
        public bool IsInkAutoFillingEnabled
        {
            get { return _isInkAutoFillingEnabled; }
            set { _isInkAutoFillingEnabled = value; RaisePropertyChangedAuto(); OnInkAutoFillingChanged(); }
        }

        public RelayCommand ExportLogsCommand { get; set; }

        public OpenCloseDyeingHeadCommand OpenCloseDyeingHeadCommand { get; set; }

        public OpenCloseLeftLeadingWheelsCommand OpenCloseLeftLeadingWheelsCommand { get; set; }

        public OpenCloseRightLeadingWheelsCommand OpenCloseRightLeadingWheelsCommand { get; set; }

        public ResetThreadLoadingCommand ResetThreadLoadingCommand { get; set; }

        public RelayCommand HeadCleaningCommand { get; set; }

        public RelayCommand StartThreadLoadingCommand { get; set; }

        public RelayCommand StartThreadBreakCommand { get; set; }

        public RelayCommand DispenseCleanerLiquidCommand { get; set; }

        public RelayCommand ViewBitResultsCommand { get; set; }

        public MaintenanceViewVM()
        {
            Guides = new ObservableCollection<GuideBase>(GuideHelper.CreateAllGuides());
            OverallTemperature = new OverallTemperatureModel();

            OpenGuideCommand = new RelayCommand<GuideBase>(OpenGuide);
            ExportLogsCommand = new RelayCommand(ExportLogsToStorage);

            OpenCloseDyeingHeadCommand = new OpenCloseDyeingHeadCommand();
            OpenCloseLeftLeadingWheelsCommand = new OpenCloseLeftLeadingWheelsCommand();
            OpenCloseRightLeadingWheelsCommand = new OpenCloseRightLeadingWheelsCommand();
            ResetThreadLoadingCommand = new ResetThreadLoadingCommand();
            HeadCleaningCommand = new RelayCommand(PerformHeadCleaning, () => MachineProvider.MachineOperator.CanPrint);
            StartThreadLoadingCommand = new RelayCommand(StartThreadLoadingWizard, () => MachineProvider.MachineOperator.CanPrint);
            StartThreadBreakCommand = new RelayCommand(StartThreadBreakWizard, () => MachineProvider.MachineOperator.CanPrint);
            ViewBitResultsCommand = new RelayCommand(ViewBitResult, () => MachineProvider.MachineOperator.IsConnected);

            WasteStates = new List<WasteStateModel>()
            {
                 new WasteStateModel() { Slot = CartridgeSlot.WasteMiddle, State = CartridgeState.Absent },
                 new WasteStateModel() { Slot = CartridgeSlot.WasteLower, State = CartridgeState.Absent }
            };
        }

        public override void OnApplicationStarted()
        {
            MachineProvider.MachineOperator.InkFillingStatusChanged += MachineOperator_InkFillingStatusChanged;
            MachineProvider.MachineOperator.MachineStatusChanged += MachineOperator_MachineStatusChanged;
            MachineProvider.MachineOperator.MachineEventsStateProvider.EventsChanged += MachineEventsStateProvider_EventsChanged;

            DispenseCleanerLiquidCommand = new RelayCommand(DispenseCleanerLiquid, () =>
            {
                if (MachineProvider.Machine.MachineHeadType == BL.Enumerations.HeadTypes.Arc)
                {
                    return MachineProvider.MachineOperator.MachineEventsStateProvider.Events.Any(x => x.Type == BL.Enumerations.EventTypes.DYEING_HEAD_ARC_LID_IS_OPEN);
                }
                else
                {
                    return MachineProvider.MachineOperator.MachineEventsStateProvider.Events.Any(x => x.Type == BL.Enumerations.EventTypes.DYEING_HEAD_COVER_IS_OPEN);
                }
            });

            RaisePropertyChanged(nameof(DispenseCleanerLiquidCommand));
        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();

            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.HasLevelMeasure).OrderBy(x => x.PackIndex).Select(x => new MidTankLevelModel()
            {
                Max = MachineOperator.MAX_MIDTANK_LITERS,
                IDSPack = x,
            }).OrderBy(y => y.IDSPack.LiquidType.Code).ToList();
        }

        private void MachineEventsStateProvider_EventsChanged(object sender, IEnumerable<BL.Entities.MachinesEvent> e)
        {
            OpenCloseDyeingHeadCommand.IsEnabled = !e.Any(x => x.Type == BL.Enumerations.EventTypes.DRYER_DOOR_OPEN);

            InvokeUI(() =>
            {
                DispenseCleanerLiquidCommand.RaiseCanExecuteChanged();
            });
        }

        private void MachineOperator_MachineStatusChanged(object sender, MachineStatus status)
        {
            UpdateMidTankLevels(status);
            OverallTemperature.Temperature = status.OverallTemperature;
            SpoolState = status.SpoolState;
            _isInkAutoFillingEnabled = status.AutoInkFillingEnabled;
            RaisePropertyChanged(nameof(IsInkAutoFillingEnabled));
            InvalidateRelayCommands();
        }

        private void MachineOperator_InkFillingStatusChanged(object sender, InkFillingStatusChangedEventArgs e)
        {
            foreach (var cartridge in e.Status.CartridgesStatuses.Where(x => x.Cartridge.Slot != CartridgeSlot.Ink))
            {
                var wasteState = WasteStates.SingleOrDefault(x => x.Slot == cartridge.Cartridge.Slot);

                if (wasteState != null)
                {
                    wasteState.State = cartridge.State;
                }
            }
        }

        public async void OpenGuide(GuideBase guide)
        {
            await NavigationManager.NavigateWithObject<MaintenanceModule, GeneralGuideView, GuideBase>(guide);
        }

        private void UpdateMidTankLevels(MachineStatus status)
        {
            if (IsVisible)
            {
                foreach (var item in status.IDSPacksLevels)
                {
                    var model = MidTankLevels.SingleOrDefault(x => x.IDSPack.PackIndex == item.Index);

                    if (model != null)
                    {
                        model.Level = item.MidTankLevel;
                    }
                }
            }
        }

        private async void ExportLogsToStorage()
        {
            var result = await NavigationManager.
                NavigateForResult<StorageModule,
                Storage.Views.MainView, ExplorerFileItem,
                Storage.Models.StorageNavigationRequest>(
                new Storage.Models.StorageNavigationRequest()
                {
                    Intent = Storage.Models.StorageNavigationIntent.SaveFile,
                    DefaultFileName = $"Tango-Logs-{DateTime.Now.ToFileName()}",
                    Filter = "do not display anything",
                    Title = "Export System Logs",
                });

            if (result != null)
            {
                String file = result.Path + ".zip";

                IsFree = false;

                try
                {
                    NotificationProvider.SetGlobalBusyMessage("Exporting system logs...");

                    var appFileLogger = LogManager.RegisteredLoggers.FirstOrDefault(x => x is FileLogger) as FileLogger;

                    await Task.Factory.StartNew(() =>
                    {
                        using (ZipFile zip = new ZipFile(file))
                        {
                            zip.Password = "1Creativity";

                            if (appFileLogger != null)
                            {
                                zip.AddDirectory(appFileLogger.Folder);
                            }

                            zip.ParallelDeflateThreshold = -1;
                            zip.Save();
                        }
                    });

                    NotificationProvider.ReleaseGlobalBusyMessage();

                    await NotificationProvider.ShowSuccess("System logs exported successfully.");
                }
                catch (Exception ex)
                {
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    LogManager.Log(ex, "Error exporting system logs.");
                    await NotificationProvider.ShowError($"An error occurred while trying to export the system logs.\n{ex.FlattenMessage()}");
                }
                finally
                {
                    NotificationProvider.ReleaseGlobalBusyMessage();
                    IsFree = true;
                }
            }
        }

        public async override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            try
            {
                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    var jobRuns = await db.JobRuns.Select(x => new { x.StartDate, x.EndDate, x.EndPosition }).ToListAsync();

                    TotalDyeTime = TimeSpan.FromHours(jobRuns.Select(x => x.EndDate - x.StartDate).Sum(x => x.TotalHours)).ToStringUnlimitedHours();

                    int meters = (int)jobRuns.Select(x => x.EndPosition).Sum();
                    TotalDyeMeters = $"{meters.ToString("N0")} meters";
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading machine counters.");
                TotalDyeTime = "error!";
                TotalDyeMeters = "error!";
            }
        }

        private async void PerformHeadCleaning()
        {
            await NotificationProvider.ShowDialog<HeadCleaningViewVM>();
        }

        private void StartThreadLoadingWizard()
        {
            ThreadLoadingService.StartThreadLoadingWizard();
        }

        private void StartThreadBreakWizard()
        {
            ThreadLoadingService.StartThreadBreakWizard();
        }

        private async void DispenseCleanerLiquid()
        {
            await NotificationProvider.ShowDialog<CleanerDispensingViewVM>();
        }

        private async void OnInkAutoFillingChanged()
        {
            if (IsInkAutoFillingEnabled)
            {
                try
                {
                    NotificationProvider.SetGlobalBusyMessage("Enabling auto ink filling...");
                    await MachineProvider.MachineOperator.SendRequest<SetInkAutoFillingModeRequest, SetInkAutoFillingModeResponse>(new SetInkAutoFillingModeRequest()
                    {
                        Enable = true
                    });
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error enabling auto ink filling.");
                    _isInkAutoFillingEnabled = false;
                    RaisePropertyChanged(nameof(IsInkAutoFillingEnabled));
                    await NotificationProvider.ShowError($"Error enabling auto ink filling.\n{ex.Message}");
                }
                finally
                {
                    NotificationProvider.ReleaseGlobalBusyMessage();
                }
            }
            else
            {
                try
                {
                    NotificationProvider.SetGlobalBusyMessage("Disabling auto ink filling...");
                    await MachineProvider.MachineOperator.SendRequest<SetInkAutoFillingModeRequest, SetInkAutoFillingModeResponse>(new SetInkAutoFillingModeRequest()
                    {
                        Enable = false
                    });
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error disabling auto ink filling.");
                    _isInkAutoFillingEnabled = true;
                    RaisePropertyChanged(nameof(IsInkAutoFillingEnabled));
                    await NotificationProvider.ShowError($"Error disabling auto ink filling.\n{ex.Message}");
                }
                finally
                {
                    NotificationProvider.ReleaseGlobalBusyMessage();
                }
            }
        }

        private async void ViewBitResult()
        {
            await BitManager.ShowBitResultsDialog();
        }
    }
}