using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.SharedUI;
using Tango.SharedUI.Components;
using System.Data.Entity;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.Common.Authentication;
using Tango.BL.ActionLogs;
using Tango.BL.DTO;
using Tango.BL.Builders;
using System.ComponentModel;
using System.Windows.Data;

namespace Tango.MachineStudio.Sites.ViewModels
{
    public class SiteDetailsViewVM : ViewModel
    {
        private ObservablesContext _db;
        private INotificationProvider _notification;
        private IAuthenticationProvider _authentication;
        private IActionLogManager _actionLogManager;
        private bool _isNew;
        private SiteDTO _siteBeforeSave;

        public event EventHandler Saved;

        private Site _site;
        public Site Site
        {
            get { return _site; }
            set { _site = value; RaisePropertyChangedAuto(); }
        }

        private List<Organization> _organizations;
        public List<Organization> Organizations
        {
            get { return _organizations; }
            set { _organizations = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<Rml> _rmls;
        public SelectedObjectCollection<Rml> Rmls
        {
            get { return _rmls; }
            set { _rmls = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<ColorCatalog> _catalogs;
        public SelectedObjectCollection<ColorCatalog> Catalogs
        {
            get { return _catalogs; }
            set { _catalogs = value; RaisePropertyChangedAuto(); }
        }

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

        private SelectedObjectCollection<SpoolType> _spoolTypes;
        public SelectedObjectCollection<SpoolType> SpoolTypes
        {
            get { return _spoolTypes; }
            set { _spoolTypes = value; RaisePropertyChangedAuto(); }
        }

        private bool _showSelectedRMLsOnly;

        public bool ShowSelectedRMLsOnly
        {
            get { return _showSelectedRMLsOnly; }
            set { _showSelectedRMLsOnly = value;
            RaisePropertyChangedAuto(); RMLCollection.Refresh(); }
        }

        private String _RMLFilter;

        public String RMLFilter
        {
            get { return _RMLFilter; }
            set {
                _RMLFilter = value;
                RaisePropertyChangedAuto();
                RMLCollection.Refresh();
            }
        }


        private ICollectionView _rmlscollectionFilter;
        public ICollectionView RMLCollection
        {
            get { return _rmlscollectionFilter; }
            set { _rmlscollectionFilter = value;
                RaisePropertyChangedAuto(); }
        }



        public RelayCommand SaveCommand { get; set; }

        public SiteDetailsViewVM()
        {
            SaveCommand = new RelayCommand(Save, () => IsFree);
            _showSelectedRMLsOnly = true;
        }

        public async Task Init(String siteGuid, INotificationProvider notification, IAuthenticationProvider authentication, IActionLogManager actionLogManager, bool isNew, string newSiteName = null)
        {
            _notification = notification;
            _authentication = authentication;
            _actionLogManager = actionLogManager;

            _db = ObservablesContext.CreateDefault();
            Organizations = await _db.Organizations.ToListAsync();

            if (isNew)
            {
                Site = new Site();
                Site.Name = newSiteName;
                Site.Description = "My site description";
                _db.Sites.Add(Site);

                _isNew = true;
            }
            else
            {
                _isNew = false;
                Site = await new SiteBuilder(_db).Set(siteGuid)
                    .WithSiteCatalogs()
                    .WithCatalogs()
                    .WithSiteRmls()
                    .WithRmls()
                    .WithOrganization()
                    .WithSpoolTypes()
                    .BuildAsync();
            }

            Machines = await _db.Machines.Where(x => x.SiteGuid == Site.Guid).Include(x => x.Organization).ToListAsync();

            var rmls = await _db.Rmls.OrderBy(x => x.Name).ToListAsync();
            var catalogs = await _db.ColorCatalogs.OrderBy(x => x.Name).ToListAsync();
            var spoolTypes = await _db.SpoolTypes.OrderBy(x => x.LastUpdated).ToListAsync();

            Rmls = new SelectedObjectCollection<Rml>(rmls.ToObservableCollection(), Site.SitesRmls.Select(x => x.Rml).ToObservableCollection());
            Catalogs = new SelectedObjectCollection<ColorCatalog>(catalogs.ToObservableCollection(), Site.SitesCatalogs.Select(x => x.ColorCatalog).ToObservableCollection());
            SpoolTypes = new SelectedObjectCollection<SpoolType>(spoolTypes.ToObservableCollection(), Site.SitesSpoolTypes.Select(x => x.SpoolType).ToObservableCollection());

            var standardSpool = SpoolTypes.FirstOrDefault(x => x.Data.Name == "Standard Spool");
            if (standardSpool != null)
            {
                standardSpool.IsEnabled = false;
                standardSpool.IsSelected = true;
            }

            _siteBeforeSave = SiteDTO.FromObservable(Site);

            RMLCollection = CollectionViewSource.GetDefaultView(Rmls);
            RMLCollection.Filter = new Predicate<object>(x =>
            {
                SelectedObject Sel_rml = x as SelectedObject;
                
                if (!String.IsNullOrEmpty(RMLFilter))// by filter and check box Show selected only
                {
                    var rml = Sel_rml.Data as Rml;
                    if (rml != null && rml.Name.ToLower().Contains(RMLFilter.ToLower()))
                    {
                        return ShowSelectedRMLsOnly ? Sel_rml.IsSelected : true;
                    }
                    else
                        return false;
                }
                else
                {
                    return ShowSelectedRMLsOnly ? Sel_rml.IsSelected : true;
                }


            });
        }

        private async void Save()
        {
            try
            {
                if (!Site.Validate(_db))
                {
                    _notification.ShowError(String.Join("\n", Site.ValidationErrors));
                    return;
                }

                IsFree = false;

                using (_notification.PushTaskItem("Saving site details..."))
                {
                    //Check if site organization has changed and there are no machines that belongs to this site but different organization.
                    if (_db.Machines.Any(x => x.SiteGuid == Site.Guid && x.OrganizationGuid != Site.OrganizationGuid))
                    {
                        throw new InvalidOperationException($"One or more machines belongs to this site but not to '{Site.Organization.Name}' organization.");
                    }

                    //Remove site rmls.
                    Site.SitesRmls.ToList().Where(x => !Rmls.SynchedSource.ToList().Exists(y => y.Guid == x.RmlGuid)).ToList().ForEach(x => _db.SitesRmls.Remove(x));
                    Site.SitesCatalogs.ToList().Where(x => !Catalogs.SynchedSource.ToList().Exists(y => y.Guid == x.ColorCatalogGuid)).ToList().ForEach(x => _db.SitesCatalogs.Remove(x));
                    Site.SitesSpoolTypes.ToList().Where(x => !SpoolTypes.SynchedSource.ToList().Exists(y => y.Guid == x.SpoolTypeGuid)).ToList().ForEach(x => _db.SitesSpoolTypes.Remove(x));

                    foreach (var selectedRml in Rmls.SynchedSource.Where(x => !Site.SitesRmls.ToList().Exists(y => y.RmlGuid == x.Guid)))
                    {
                        _db.SitesRmls.Add(new SitesRml() { SiteGuid = Site.Guid, RmlGuid = selectedRml.Guid });
                    }

                    foreach (var selectedCatalog in Catalogs.SynchedSource.Where(x => !Site.SitesCatalogs.ToList().Exists(y => y.ColorCatalogGuid == x.Guid)))
                    {
                        _db.SitesCatalogs.Add(new SitesCatalog() { SiteGuid = Site.Guid, ColorCatalogGuid = selectedCatalog.Guid });
                    }

                    foreach (var selectedSpoolType in SpoolTypes.SynchedSource.Where(x => !Site.SitesSpoolTypes.ToList().Exists(y => y.SpoolTypeGuid == x.Guid)))
                    {
                        _db.SitesSpoolTypes.Add(new SitesSpoolType() { SiteGuid = Site.Guid, SpoolTypeGuid = selectedSpoolType.Guid });
                    }

                    await _db.SaveChangesAsync();

                    if (_isNew)
                    {
                        _actionLogManager.InsertLog(BL.Enumerations.ActionLogType.SiteCreated, _authentication.CurrentUser, Site.Name, Site, "Site created using Machine Studio.");
                    }
                    else
                    {
                        SiteDTO siteAfter = SiteDTO.FromObservable(Site);
                        _actionLogManager.InsertLog(BL.Enumerations.ActionLogType.SiteSaved, _authentication.CurrentUser, _siteBeforeSave.Name, _siteBeforeSave, siteAfter, "Site saved using Machine Studio.");
                        _siteBeforeSave = siteAfter;
                    }
                }
                _db.Dispose();
                Saved?.Invoke(this, new EventArgs());
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error saving site details.");
                _notification.ShowError($"Error saving site details.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsFree = true;
            }
        }
    }
}