//
// Rule.cs
//
// Author:
//   Jacob Johnston (jacobj@inchoatethoughts.com)
//
// Copyright (C) 2009 Jacob Johnston
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as 
// published by the Free Software Foundation, either version 3 of 
// the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System.ComponentModel;
using System.IO;
using System.Xml;

namespace ZenLibrary.RuleBase
{
    #region class Rule
    /// <summary>
    /// An abstract base class for custom rules. Custom rules should
    /// inherit from this class and implement the abstract methods.
    /// </summary>
    public abstract class Rule : INotifyPropertyChanged
    {
        private bool isEnabled = true;

        /// <summary>
        /// Fires after the IsEnabled property changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
                
        /// <summary>
        /// The Name of the rule that will be displayed to the user.
        /// </summary>
        public abstract string Name { get; }

        /// <summary>
        /// The type of rule (Per Directory or Per File)
        /// </summary>
        public abstract TestType TestType { get; }

        /// <summary>
        /// The method that stores the test logic for the rule.
        /// </summary>
        /// <param name="directoryInfo">The directory info for the test (null if the TestType is FileScan)</param>
        /// <param name="fileInfo">The file info for the test.</param>
        /// <returns>Returns the result of the test (pass/fail). If the test fails, will contain a display string for the failure.</returns>
        public abstract RuleTestResult RunTest(DirectoryInfo directoryInfo, FileInfo fileInfo);

        /// <summary>
        /// Gets or Sets whether the rule is selected to be run.
        /// </summary>
        public bool IsEnabled 
        {
            get
            {
                return isEnabled;
            }
            set
            {
                isEnabled = value;
                if(PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("IsEnabled"));

                // Changing the IsEnabled property triggers the config information to be resaved so this information
                // is persisted between sessions.
                Config.Instance.SaveConfig();
            }
        }

        /// <summary>
        /// Writes the XML config element for the rule.
        /// </summary>
        /// <param name="writer">The XMLWriter used to output config information.</param>
        public void WriteXml(XmlWriter writer)
        {
            writer.WriteStartElement(this.GetType().ToString());
            writer.WriteAttributeString("IsEnabled", isEnabled.ToString());
            WriteCustomConfigAttributes(writer);
            writer.WriteEndElement();
        }

        /// <summary>
        /// When overridden, contains logic to write custom rule attributes to the rule config element.
        /// </summary>
        /// <param name="writer">The XMLWriter used to output config information.</param>
        protected virtual void WriteCustomConfigAttributes(XmlWriter writer)
        {
            // Do nothing. Will be overridden in child classes.
        }

        /// <summary>
        /// Reads the XML config element for the rule.
        /// </summary>
        /// <param name="reader">The XMLReader used to input config information.</param>
        public void ReadXml(XmlReader reader)
        {            
            if(reader.HasAttributes)
                IsEnabled = bool.Parse(reader["IsEnabled"]);            
            ReadCustomConfigAttributes(reader);            
            reader.MoveToElement();
        }

        /// <summary>
        /// When overridden, contains logic to read custom rule attributes from the rule config element.
        /// </summary>
        /// <param name="reader">The XMLReader used to input config information.</param>
        protected virtual void ReadCustomConfigAttributes(XmlReader reader)
        {
            // Do nothing. Will be overridden in child classes.
        }
    }
    #endregion

    #region class ConfigurableRule
    /// <summary>
    /// A special type of rule that allows for user configuration.
    /// </summary>
    public abstract class ConfigurableRule : Rule
    {
        /// <summary>
        /// The method that will handle the configure button being pressed.
        /// </summary>
        public abstract void Configure();
    }
    #endregion

    #region enum TestType
    /// <summary>
    /// The type of rule test to perform.
    /// </summary>
    public enum TestType
    {
        /// <summary>
        /// Tests are performed on a per directory basis.
        /// </summary>
        DirectoryScan,

        /// <summary>
        /// Tests are performed on a per file basis.
        /// </summary>
        FileScan
    }
    #endregion
}