using System;
using System.Linq;
using System.Runtime.Remoting.Lifetime;
using System.Threading.Tasks;
using System.Windows;
using DTS.Common.Classes;
using DTS.Common.Events;
using DTS.Common.Interface;
using DTS.Common.Base;
using Microsoft.Practices.Prism.Regions;
using Microsoft.Practices.Prism.Events;
using Microsoft.Practices.Unity;
namespace DTS.Common
{
    public class DataProRegionManager : IDataProRegionManager
    {
        /// <summary>
        /// Injected unity container
        /// </summary>
        private readonly IUnityContainer _unityContainer;

        /// <summary>
        /// Injected region manager
        /// </summary>
        private readonly IRegionManager _regionManager;

        /// <summary>
        /// Injected event aggregator
        /// </summary>
        private readonly IEventAggregator _eventAggregator;

        /// <summary>
        /// Creates a new instance of the <see cref="DataProRegionManager"/> class.
        /// </summary>
        /// <param name="unityContainer">Obtained reference of the unity container by using dependency injection.</param>
        /// <param name="regionManager">Obtained reference of the region manager by using dependency injection.</param>
        /// <param name="eventAggregator">Obtained reference of the event aggregator by using dependency injection.</param>
        public DataProRegionManager(IUnityContainer unityContainer, IRegionManager regionManager,
                                  IEventAggregator eventAggregator)
        {
            _unityContainer = unityContainer;
            _regionManager = regionManager;
            _eventAggregator = eventAggregator;
        }

        /// <summary>
        /// Adds View to the Main Region.
        /// </summary>
        /// <param name="viewDefinition">The View definition.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        public void AddView(ViewDefinition viewDefinition, object parameter)
        {
            AddView(viewDefinition, parameter, false);
        }

        private IShellViewModel GetShellViewModelByRegionName(string regionName)
        {
            IShellViewModel shellVm = null;

            if (regionName == RegionNames.MainRegion)
            {
                shellVm = _unityContainer.Resolve<IShellViewModel>();
            }
            //TODO: Add more stuff
            /*
            else if (regionName == RegionNames.BottomRegion)
            {
                shellVm = _unityContainer.Resolve<IShellViewModel2>();
            }
            else if (regionName == RegionNames.RightRegion)
            {
                shellVm = _unityContainer.Resolve<IShellViewModel3>();
            }
            */
            return shellVm;
        }

        /// <summary>
        /// Adds View to the Main Region.
        /// </summary>
        /// <param name="viewDefinition">The View definition.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        /// <param name="allowMultipleInstances">A value indicating whether to allow to create the multiple views.</param>
        public void AddView(ViewDefinition viewDefinition, object parameter, bool allowMultipleInstances)
        {
            IShellViewModel shell = _unityContainer.Resolve<IShellViewModel>();

            var viewModel = (IBaseViewModel)_unityContainer.Resolve(viewDefinition.ViewModelInterfaceType);
            var view = (IBaseView)_unityContainer.Resolve(viewDefinition.ViewInterfaceType);
            view.DataContext = viewModel;

            _regionManager.AddViewToRegion(viewDefinition.RegionName, view);
            _regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType);

            if (parameter == null)
                viewModel.Initialize();
            else
                viewModel.Initialize(parameter);

            switch (viewDefinition.RegionName)
            {
                case RegionNames.NavigationRegion:
                    shell.ContextNavigationRegion = view;
                    break;
                case RegionNames.MainRegion:
                    shell.ContextMainRegion = view;
                    break;
            }

            //IShellViewModel shellVm = GetShellViewModelByRegionName(viewDefinition.RegionName);
            //if (shellVm != null)
            //{
            //    shellVm.ContextMainRegion = view;
            //}
        }

        /// <summary>
        /// Adds View to the Main Region asynchronously.
        /// </summary>
        /// <param name="viewDefinition">The View definition.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        public async Task AddViewAsync(ViewDefinition viewDefinition, object parameter)
        {
            await AddViewAsync(viewDefinition, parameter, false);
        }

        /// <summary>
        /// Adds View to the Main Region asynchronously.
        /// </summary>
        /// <param name="viewDefinition">The View definition.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        /// <param name="allowMultipleInstances">A value indicating whether to allow to create the multiple views.</param>
        public async Task AddViewAsync(ViewDefinition viewDefinition, object parameter, bool allowMultipleInstances)
        {
            try
            {
                if (!allowMultipleInstances)
                {
                    if (_regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType))
                        return;
                }

                var viewModel = (IBaseViewModel)_unityContainer.Resolve(viewDefinition.ViewModelInterfaceType);
                var view = (IBaseView)_unityContainer.Resolve(viewDefinition.ViewInterfaceType);
                view.DataContext = viewModel;

                _regionManager.AddViewToRegion(viewDefinition.RegionName, view);
                _regionManager.ActivateViewIfExists(viewDefinition.RegionName, viewDefinition.ViewInterfaceType);

                if (parameter == null)
                    await viewModel.InitializeAsync();
                else
                    await viewModel.InitializeAsync(parameter);

                IShellViewModel shellVm = GetShellViewModelByRegionName(viewDefinition.RegionName);

                if (shellVm != null)
                {
                    shellVm.ContextMainRegion = view;
                }
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<RaiseNotification>()
                                .Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
            }
        }

        /// <summary>
        /// Removes View from the Main Region asynchronously.
        /// </summary>
        /// <param name="viewModel">The View-model.</param>
        public void RemoveView(IBaseViewModel viewModel)
        {
            // Jtacc is composed of three regions(three shells)
            foreach (var region in _regionManager.Regions)
            {
                var view =
                    region.Views.FirstOrDefault(
                        v => v is IBaseView && ReferenceEquals(((IBaseView)v).DataContext, viewModel));

                if (view != null)
                {
                    viewModel.Cleanup();
                    region.Deactivate(view);
                    region.Remove(view);
                }
            }
        }

        public void RemoveViewByRegionName(string regionName)
        {
            _regionManager.ClearRegion(regionName);
        }

        /// <summary>
        /// Reloads data for the specified View.
        /// </summary>
        /// <param name="interfaceForView">Type of the View's interface.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        public void RefreshView(Type interfaceForView, object parameter)
        {
            try
            {
                foreach (var region in _regionManager.Regions)
                {
                    var existingView = _regionManager.GetView(region.Name, interfaceForView) as IBaseView;

                    if (existingView != null)
                    {
                        var viewModel = existingView.DataContext as IBaseViewModel;
                        if (viewModel != null)
                        {
                            viewModel.Cleanup();

                            if (parameter == null)
                                viewModel.Initialize();
                            else
                                viewModel.Initialize(parameter);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<RaiseNotification>()
                                .Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
            }
        }

        /// <summary>
        /// Reloads data for the specified View asynchronously.
        /// </summary>
        /// <param name="interfaceForView">Type of the View's interface.</param>
        /// <param name="parameter">The parameter which uses to initialize the View.</param>
        public async Task RefreshViewAsync(Type interfaceForView, object parameter)
        {
            //TODO: fix so that it finds view in right view.
            try
            {
                foreach (var region in _regionManager.Regions)
                {
                    var existingView =
                        _regionManager.GetView(region.Name, interfaceForView) as IBaseView;
                    if (existingView != null)
                    {
                        var viewModel = existingView.DataContext as IBaseViewModel;
                        if (viewModel != null)
                        {
                            await viewModel.CleanupAsync();

                            if (parameter == null)
                                await viewModel.InitializeAsync();
                            else
                                await viewModel.InitializeAsync(parameter);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<RaiseNotification>()
                                .Publish(new NotificationContentEventArgs(Utility.GetAllErrorMessages(ex)));
            }
        }

        public IRegionCollection Regions { get; private set; }
        public IRegionManager CreateRegionManager()
        {
            return  new RegionManager();
        }
    }
}