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(); }
        }

        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 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);

            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.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;
            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>();
        }
    }
}