using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.PPC.Common;
using System.Data.Entity;
using Tango.PPC.Technician.Dialogs;
using Tango.PPC.Common.Synchronization;

namespace Tango.PPC.Technician.ViewModels
{
    public class UpdatesViewVM : PPCViewModel
    {
        public RelayCommand SynchronizeCommand { get; set; }

        private List<TangoUpdate> _updates;
        public List<TangoUpdate> Updates
        {
            get { return _updates; }
            set { _updates = value; RaisePropertyChangedAuto(); }
        }

        private TangoUpdate _selectedUpdate;
        public TangoUpdate SelectedUpdate
        {
            get { return _selectedUpdate; }
            set { _selectedUpdate = value; OnSelectedUpdateChanged(); }
        }

        private SynchronizationStatus _selectedSynchronization;
        public SynchronizationStatus SelectedSynchronization
        {
            get { return _selectedSynchronization; }
            set { _selectedSynchronization = value; OnSelectedSynchronizationChanged();  }
        }

        public UpdatesViewVM()
        {
            Updates = new List<TangoUpdate>();
            SynchronizeCommand = new RelayCommand(Synchronize, () => !MachineDataSynchronizer.IsSynchronizing);
        }

        public override void OnApplicationStarted()
        {

        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();
            MachineDataSynchronizer.SynchronizationStarted += (_, __) => InvalidateRelayCommands();
            MachineDataSynchronizer.SynchronizationEnded += (_, __) => InvalidateRelayCommands();
        }

        private async void Synchronize()
        {
            try
            {
                await MachineDataSynchronizer.Synchronize();
            }
            catch { }
        }

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

            try
            {
                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    Updates = await db.TangoUpdates.Where(x =>
                    x.Status != (int)TangoUpdateStatuses.SynchronizationCompleted &&
                    x.Status != (int)TangoUpdateStatuses.SynchronizationFailed &&
                    x.Status != (int)TangoUpdateStatuses.SynchronizationStarted
                    ).OrderByDescending(x => x.StartDate).ToListAsync();
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading update history.");
            }
        }

        private async void OnSelectedUpdateChanged()
        {
            if (SelectedUpdate != null)
            {
                await NotificationProvider.ShowDialog<UpdateDetailsViewVM>(new UpdateDetailsViewVM() { Update = SelectedUpdate });
            }
        }

        private async void OnSelectedSynchronizationChanged()
        {
            if (SelectedSynchronization != null)
            {
                await NotificationProvider.ShowDialog<SynchronizationDetailsViewVM>(new SynchronizationDetailsViewVM() { Status = SelectedSynchronization });
            }
        }
    }
}