namespace GSModuleManager
{
    /// <summary>
    /// Klasa obsługi widoczności modułów
    /// </summary>
    public class ModuleController : INotifyPropertyChanged
    {
        #region ProperyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        public void OnPropertyChanged(string PropertyName)
        {
            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
        }
        #endregion
        /// <summary>
        /// Inicjuje nową instancję obiektu <see cref="ModuleController"/>
        /// </summary>
        public ModuleController()
        {

        }

        private IModule selectedModule = null;
        /// <summary>
        /// Aktualnie wybrany moduł
        /// </summary>
        public IModule SelectedModule
        {
            get
            {
                return selectedModule;
            }
            private set
            {
                selectedModule = value;
                OnPropertyChanged("SelectedModule");
            }
        }

        /// <summary>
        /// Zamyka aktualny moduł i otwiera nowy
        /// </summary>
        /// <param name="Module">Nowy moduł do wybrania, pozostaw NULL, aby tylko zamknąć aktualny</param>
        public void Select(IModule Module)
        {
            if (SelectedModule != null)
            {
                IModule Zamykany = SelectedModule;
                Closing?.Invoke(Zamykany, ModuleActionEventArgs.Empty(Zamykany));
                SelectedModule = null;
                Closed?.Invoke(Zamykany, ModuleActionEventArgs.Empty(Zamykany));
            }
            if (Module != null)
            {
                Activating?.Invoke(Module, ModuleActionEventArgs.Empty(Module));
                SelectedModule = Module;
                Activated?.Invoke(Module, ModuleActionEventArgs.Empty(Module));
            }
        }
        /// <summary>
        /// Zamyka aktualny moduł i otwiera nowy
        /// </summary>
        /// <param name="Module">Nowy moduł do wybrania, pozostaw NULL, aby tylko zamknąć aktualny</param>
        /// <param name="Args">Dodatkowe parametry</param>
        public void Select(IModule Module, object Args)
        {
            if (SelectedModule != null)
            {
                IModule Zamykany = SelectedModule;
                Closing?.Invoke(Zamykany, new ModuleActionEventArgs(Zamykany, Args));
                SelectedModule = null;
                Closed?.Invoke(Zamykany, new ModuleActionEventArgs(Zamykany, Args));
            }
            if (Module != null)
            {
                Activating?.Invoke(Module, new ModuleActionEventArgs(Module, Args));
                SelectedModule = Module;
                Activated?.Invoke(Module, new ModuleActionEventArgs(Module, Args));
            }
        }

        /// <summary>
        /// Informuje o otwieraniu modułu. W parametrze Sender znajduje się <see cref="IModule"/>
        /// </summary>
        public event EventHandler<ModuleActionEventArgs> Activating;
        /// <summary>
        /// Informuje o otwarciu modułu. W parametrze Sender znajduje się <see cref="IModule"/>
        /// </summary>
        public event EventHandler<ModuleActionEventArgs> Activated;
        /// <summary>
        /// Informuje o zamykaniu modułu. W parametrze Sender znajduje się <see cref="IModule"/>
        /// </summary>
        public event EventHandler<ModuleActionEventArgs> Closing;
        /// <summary>
        /// Informuje o Zamknięciu modułu. W parametrze Sender znajduje się <see cref="IModule"/>
        /// </summary>
        public event EventHandler<ModuleActionEventArgs> Closed;
    }
    /// <summary>
    /// Interfejs dziedziczony przez każdy moduł
    /// </summary>
    public interface IModule
    {
        string ID { get; }

        bool Compare(IModule Module);
        bool Compare(string ModuleName);
    }
    /// <summary>
    /// Klasa przesyłana w zdarzeniach obsługujących <see cref="KontrolaWidocznosciModulow"/>
    /// </summary>
    public class ModuleActionEventArgs : EventArgs
    {
        public ModuleActionEventArgs(IModule Module, object Args)
        {
            this.Module = Module;
            this.Args = Args;
        }
        public IModule Module { get; private set; }
        public object Args { get; private set; }

        public new static ModuleActionEventArgs Empty(IModule Module)
        {
            return new ModuleActionEventArgs(Module, null);
        }
    }
    /// <summary>
    /// Konwerter nazwy moduły na stan widoczności
    /// </summary>
    public class ModuleVisibilityConverter : IValueConverter
    {
        private string module;
        /// <summary>
        /// Nazwa modułu do którego powiązywana będzie nazwa
        /// </summary>
        public string Module
        {
            get { return module; }
            set { module = value; }
        }


        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            IModule current = (IModule)value;
            return (current != null && Module != null && current.Compare(Module)) ? Visibility.Visible : Visibility.Collapsed;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}