using System.Xml;
namespace Wayne.Lib.Log
{
    /// <summary>
    /// Definition of a max size of a log file.
    /// </summary>
    public class LogConfigTextFileMaxSize
    {
        #region Properties

        /// <summary>
        /// Max bytes per file
        /// </summary>
        public long MaxSizePerFile { get; set; }

        /// <summary>
        /// Max number of files that are opened before it starts over with the first one.
        /// </summary>
        public int MaxFileCircleCount { get; set; }

        /// <summary>
        /// Maximum number of extra days to keep around. The number of days of logs is this number + 1 (always keep current day's logs)
        /// </summary>
        public int MaxDays { get; set; }

        /// <summary>
        /// Whether or not we try to clean up files left over that match prefix when instantiated, default is false
        /// </summary>
        public bool CleanOnStartup { get; set; }

        #endregion

        #region Construction

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="maxSizePerFileMb"></param>
        public LogConfigTextFileMaxSize(long? maxSizePerFileMb)
            : this(maxSizePerFileMb, 1)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="maxSizePerFileMb"></param>
        /// <param name="maxFileCircleCount"></param>
        public LogConfigTextFileMaxSize(long? maxSizePerFileMb, int maxFileCircleCount)
            : this(maxSizePerFileMb, 1, 1, false)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="maxSizePerFileMb"></param>
        /// <param name="maxFileCircleCount"></param>
        /// <param name="maxDays"></param>
        /// <param name="cleanOnStartup"></param>
        public LogConfigTextFileMaxSize(long? maxSizePerFileMb, int maxFileCircleCount, int maxDays, bool cleanOnStartup)
        {
            if (maxSizePerFileMb.HasValue)
                MaxSizePerFile = maxSizePerFileMb.Value * 1024 * 1024; // Convert from megabytes to bytes.
            else
                MaxSizePerFile = long.MaxValue;
            MaxFileCircleCount = maxFileCircleCount;
            MaxDays = maxDays;
            CleanOnStartup = cleanOnStartup;
        }

        /// <summary>
        /// Deserialization constructor
        /// </summary>
        /// <param name="maxSizeElement"></param>
        internal LogConfigTextFileMaxSize(XmlNode maxSizeElement)
        {
            int? maxSizePerFileMb = null;

            // Default values when deserializing
            MaxSizePerFile = long.MaxValue;
            MaxFileCircleCount = 1;
            MaxDays = 7;
            CleanOnStartup = false;

            XmlAttribute maxSizePerFileMbAttribute = maxSizeElement.Attributes["MaxSizePerFileMb"];
            if ((maxSizePerFileMbAttribute != null) && (maxSizePerFileMbAttribute.Value != "unlimited"))
                maxSizePerFileMb = XmlConvert.ToInt32(maxSizePerFileMbAttribute.Value);
            else
                maxSizePerFileMb = null;

            if (maxSizePerFileMb.HasValue)
                MaxSizePerFile = maxSizePerFileMb.Value * 1024 * 1024; // Convert from megabytes to bytes.
            else
                MaxSizePerFile = long.MaxValue;

            XmlAttribute maxFileCircleCountAttribute = maxSizeElement.Attributes["MaxFileCircleCount"];
            if (maxFileCircleCountAttribute != null)
                MaxFileCircleCount = XmlConvert.ToInt32(maxFileCircleCountAttribute.Value);
            else
                MaxFileCircleCount = 1;

            XmlAttribute maxDaysAttribute = maxSizeElement.Attributes["MaxDays"];
            if (maxDaysAttribute != null)
                MaxDays = XmlConvert.ToInt32(maxDaysAttribute.Value);

            XmlAttribute cleanOnStartupAttribute = maxSizeElement.Attributes["CleanOnStartup"];
            if (cleanOnStartupAttribute != null)
                CleanOnStartup = XmlConvert.ToBoolean(cleanOnStartupAttribute.Value);

        }

        #endregion

        #region Methods

        /// <summary>
        /// Serialization.
        /// </summary>
        /// <param name="xmlWriter"></param>
        internal void WriteXml(XmlWriter xmlWriter)
        {
            xmlWriter.WriteStartElement("MaxSize");

            if (MaxSizePerFile == long.MaxValue)
                xmlWriter.WriteAttributeString("MaxSizePerFileMb", "unlimited");
            else
                xmlWriter.WriteAttributeString("MaxSizePerFileMb", XmlConvert.ToString(MaxSizePerFile / 1024 / 1024));

            if (MaxFileCircleCount > 1)
                xmlWriter.WriteAttributeString("MaxFileCircleCount", XmlConvert.ToString(MaxFileCircleCount));

            if (MaxDays > 0)
                xmlWriter.WriteAttributeString("MaxDays", XmlConvert.ToString(MaxDays));

            if (CleanOnStartup)
                xmlWriter.WriteAttributeString("CleanOnStartup", XmlConvert.ToString(CleanOnStartup));

            xmlWriter.WriteEndElement(); // MaxSize
        }

        #endregion
    }
}