using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;
using Tango.BL;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.MachineManager.Models;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.MachineStudio.Common.Notifications;
using Z.EntityFramework.Plus;
using System.ComponentModel;
using Tango.BL.Enumerations;

namespace Tango.MachineStudio.MachineManager.ViewModels
{
    public class MainViewVM : StudioViewModel
    {
        private INotificationProvider _notification;
        private bool _preventChange;

        private List<MachineModel> _machines;
        public List<MachineModel> Machines
        {
            get { return _machines; }
            set { _machines = value; RaisePropertyChangedAuto(); }
        }

        private String _filter;
        public String Filter
        {
            get { return _filter; }
            set
            {
                if (_filter != value)
                {
                    _filter = value;
                    OnFilterChanged();
                }
            }
        }

        private List<HardwareVersion> _hardwareVersions;
        public List<HardwareVersion> HardwareVersions
        {
            get { return _hardwareVersions; }
            set { _hardwareVersions = value; RaisePropertyChangedAuto(); }
        }

        private HardwareVersion _selectedHardwareVersion;
        public HardwareVersion SelectedHardwareVersion
        {
            get { return _selectedHardwareVersion; }
            set { _selectedHardwareVersion = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool? _enableSoftwareUpdate;
        public bool? EnableSoftwareUpdate
        {
            get { return _enableSoftwareUpdate; }
            set { _enableSoftwareUpdate = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool? _enableFirmwareUpgrade;
        public bool? EnableFirmwareUpgrade
        {
            get { return _enableFirmwareUpgrade; }
            set { _enableFirmwareUpgrade = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private bool? _selectAll;
        public bool? SelectAll
        {
            get { return _selectAll; }
            set { _selectAll = value; RaisePropertyChangedAuto(); OnSelectAllChanged(); InvalidateRelayCommands(); }
        }

        public RelayCommand ApplyCommand { get; set; }

        public MainViewVM(INotificationProvider notificationProvider)
        {
            Machines = new List<MachineModel>();
            _notification = notificationProvider;
            ApplyCommand = new RelayCommand(Apply, CanApply);
        }

        public override void OnApplicationReady()
        {

        }

        private async void OnFilterChanged()
        {
            await LoadMachines();
        }

        private void OnSelectAllChanged()
        {
            if (Machines != null && SelectAll != null)
            {
                _preventChange = true;
                Machines.ForEach(x => x.IsSelected = SelectAll.Value);
                _preventChange = false;
            }
        }

        private async Task LoadMachines()
        {
            try
            {
                using (_notification.PushTaskItem("Loading machines..."))
                {
                    SelectAll = null;

                    foreach (var machine in Machines.ToList())
                    {
                        machine.PropertyChanged -= Machine_PropertyChanged;
                    }

                    using (ObservablesContext db = ObservablesContext.CreateDefault())
                    {
                        var sites = await db.Sites.ToListAsync();

                        var machines = await db.Machines
                            .Include(x => x.Organization.Name)
                            .Include(x => x.Configuration.HardwareVersion.Name)
                            .Include(x => x.Configuration.HardwareVersion.Version)
                            .Include(x => x.Configuration.HardwareVersion.Guid)
                            .Select(x => new
                            {
                                x.Guid,
                                x.SerialNumber,
                                x.Name,
                                x.SuspendVersionUpdate,
                                x.SetupFirmware,
                                x.SetupFpga,
                                x.ConfigurationGuid,
                                HardwareVersionGuid = x.Configuration.HardwareVersion.Guid,
                                HardwareVersionName = x.Configuration.HardwareVersion.Name,
                                HardwareVersionVersion = x.Configuration.HardwareVersion.Version,
                                OrganizationName = x.Organization.Name,
                                x.SiteGuid,
                                x.VersionTag
                            }).ToListAsync();

                        var models = new List<MachineModel>();

                        foreach (var machine in machines)
                        {
                            MachineModel model = new MachineModel();
                            model.Guid = machine.Guid;
                            model.SerialNumber = machine.SerialNumber;
                            model.Name = machine.Name;
                            model.EnableFirmwareUpgrade = machine.SetupFirmware;
                            model.EnableSoftwareUpdate = !machine.SuspendVersionUpdate;
                            model.ConfigurationGuid = machine.ConfigurationGuid;
                            model.HardwareVersionGuid = machine.HardwareVersionGuid;
                            model.HardwareVersionName = machine.HardwareVersionName;
                            model.HardwareVersionVersion = machine.HardwareVersionVersion;
                            model.OrganizationName = machine.OrganizationName;
                            model.VersionTag = machine.VersionTag;
                            model.Site = sites.FirstOrDefault(x => x.Guid == machine.SiteGuid)?.Name;
                            models.Add(model);
                        }

                        if (Filter.IsNotNullOrEmpty())
                        {
                            var filter = Filter.ToLower();

                            models = models.Where(x =>
                            x.SerialNumber.ToLower().StartsWith(filter) ||
                            x.Name.ToLower().StartsWith(filter) ||
                            x.OrganizationName.ToLower().StartsWith(filter) ||
                            x.Site.ToStringOrEmpty().ToLower().StartsWith(filter) ||
                            x.VersionTag.ToStringOrEmpty().ToLower().StartsWith(filter)
                            ).ToList();
                        }

                        foreach (var model in models)
                        {
                            var lastUpdate = await db.TangoUpdates.Where(

                            x => x.MachineGuid == model.Guid &&
                            (x.Status == (int)TangoUpdateStatuses.SetupCompleted ||
                            x.Status == (int)TangoUpdateStatuses.UpdateCompleted ||
                            x.Status == (int)TangoUpdateStatuses.OfflineUpdateCompleted ||
                            x.Status == (int)TangoUpdateStatuses.OfflineFirmwareUpgradeCompleted))
                            .OrderByDescending(x => x.LastUpdated)
                            .Select(x => new
                            {
                                x.ApplicationVersion,
                                x.FirmwareVersion
                            })
                            .FirstOrDefaultAsync();

                            if (lastUpdate != null)
                            {
                                model.ApplicationVersion = lastUpdate.ApplicationVersion;
                                model.FirmwareVersion = lastUpdate.FirmwareVersion;
                            }
                        }

                        HardwareVersions = (await db.HardwareVersions.ToListAsync()).OrderByDescending(x => x.Version).ToList();

                        SelectedHardwareVersion = null;
                        EnableSoftwareUpdate = null;
                        EnableFirmwareUpgrade = null;

                        Machines = models;

                        foreach (var machine in Machines.ToList())
                        {
                            machine.PropertyChanged += Machine_PropertyChanged;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading machines.");
                _notification.ShowError($"Error loading machines.\n{ex.FlattenMessage()}");
            }
        }

        private void Machine_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (_preventChange) return;

            if (e.PropertyName == nameof(MachineModel.IsSelected))
            {
                if (Machines.TrueForAll(x => x.IsSelected))
                {
                    _selectAll = true;
                }
                else if (Machines.TrueForAll(x => !x.IsSelected))
                {
                    _selectAll = false;
                }
                else
                {
                    _selectAll = null;
                }

                RaisePropertyChanged(nameof(SelectAll));

                var selectedMachines = Machines.Where(x => x.IsSelected).ToList();

                if (selectedMachines.Count > 0)
                {
                    if (selectedMachines.TrueForAll(x => x.EnableSoftwareUpdate))
                    {
                        EnableSoftwareUpdate = true;
                    }
                    else if (selectedMachines.TrueForAll(x => !x.EnableSoftwareUpdate))
                    {
                        EnableSoftwareUpdate = false;
                    }
                    else
                    {
                        EnableSoftwareUpdate = null;
                    }

                    if (selectedMachines.TrueForAll(x => x.EnableFirmwareUpgrade))
                    {
                        EnableFirmwareUpgrade = true;
                    }
                    else if (selectedMachines.TrueForAll(x => !x.EnableFirmwareUpgrade))
                    {
                        EnableFirmwareUpgrade = false;
                    }
                    else
                    {
                        EnableFirmwareUpgrade = null;
                    }

                    if (selectedMachines.TrueForAll(x => x.HardwareVersionGuid == selectedMachines.First().HardwareVersionGuid))
                    {
                        SelectedHardwareVersion = HardwareVersions.FirstOrDefault(x => x.Guid == selectedMachines.First().HardwareVersionGuid);
                    }
                    else
                    {
                        SelectedHardwareVersion = null;
                    }
                }

                InvalidateRelayCommands();
            }
        }

        private bool CanApply()
        {
            var selectedMachines = Machines.Where(x => x.IsSelected).ToList();

            if (selectedMachines.Count == 0) return false;
            if (EnableSoftwareUpdate != null && selectedMachines.Any(x => x.EnableSoftwareUpdate != EnableSoftwareUpdate)) return true;
            if (EnableFirmwareUpgrade != null && selectedMachines.Any(x => x.EnableFirmwareUpgrade != EnableFirmwareUpgrade)) return true;
            if (SelectedHardwareVersion != null && selectedMachines.Any(x => x.HardwareVersionGuid != SelectedHardwareVersion.Guid)) return true;

            return false;
        }

        private async void Apply()
        {
            if (!_notification.ShowQuestion($"You are about to modify {Machines.Count(x => x.IsSelected)} machines. Are you sure?")) return;

            try
            {
                IsFree = false;

                using (_notification.PushTaskItem("Applying changes..."))
                {
                    if (Machines == null || Machines.Count(x => x.IsSelected) == 0)
                    {
                        _notification.ShowInfo("No machines selected");
                        return;
                    }

                    using (ObservablesContext db = ObservablesContext.CreateDefault())
                    {
                        var machines = Machines.Where(x => x.IsSelected).ToList();

                        var guids = machines.Select(x => x.Guid).ToArray();

                        if (EnableSoftwareUpdate != null)
                        {
                            await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
                            new Machine()
                            {
                                SuspendVersionUpdate = !EnableSoftwareUpdate.Value
                            });
                        }

                        if (EnableFirmwareUpgrade != null)
                        {
                            await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
                            new Machine()
                            {
                                SetupFirmware = EnableFirmwareUpgrade.Value,
                                SetupFpga = EnableFirmwareUpgrade.Value,
                            });
                        }

                        if (SelectedHardwareVersion != null)
                        {
                            guids = machines.Select(x => x.ConfigurationGuid).ToArray();

                            await db.Configurations.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
                            new Configuration()
                            {
                                HardwareVersionGuid = SelectedHardwareVersion.Guid
                            });
                        }
                    }

                    await LoadMachines();
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error applying changes.");
                _notification.ShowError($"Error applying changes.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsFree = true;
            }
        }
    }
}