using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
namespace LogisTrac
{
    /// <summary>
    ///  The log class
    ///  The queue   Can be in / month / weeks / day / The size of the segmentation
    ///  Call method:
    ///  Log.Instance.LogDirectory=@"C:\";  The default is to run the program directory
    ///  Log.Instance.FileNamePrefix="cxd"; The default is log_
    ///  Log.Instance.CurrentMsgType = MsgLevel.Debug; The default is Error
    ///  Log.Instance.logFileSplit = LogFileSplit.Daily;  Log split type LogFileSplit.Sizely  The size of the
    ///  Log.Instance.MaxFileSize = 5;  Default size is 2M , only LogFileSplit.Sizely The configuration is valid
    ///  Log.Instance.LogWrite("aa");
    ///  Log.Instance.LogWrite("aa", MsgLevel.Debug);
    /// </summary>
    public class Log : IDisposable
    {
        private static Log _instance = null;
        private static readonly object _synObject = new object();
        /// <summary>
        /// The singleton
        /// </summary>
        public static Log Instance
        {
            get
            {
                if (null == _instance)
                {
                    lock (_synObject)
                    {
                        if (null == _instance)
                        {
                            _instance = new Log();
                        }
                    }
                }
                return _instance;
            }
        }
        /// <summary>
        ///  The cache queue for the log object
        /// </summary>
        private static Queue<Msg> _msgs;
        /// <summary>
        ///  The control flag for the log writing thread   ture In the writing |false Didn't write
        /// </summary>
        private  bool _state;
        private  string _logDirectory = AppDomain.CurrentDomain.BaseDirectory;
        /// <summary>
        ///  Log files are stored in directories
        /// </summary>
        public  string LogDirectory
        {
            get { return _logDirectory; }
            set { _logDirectory = value; }
        }
        private  LogFileSplit _logFileSplit = LogFileSplit.Sizely;
        /// <summary>
        ///  Log split type
        /// </summary>
        public  LogFileSplit logFileSplit
        {
            get { return _logFileSplit; }
            set { _logFileSplit = value; }
        }
        private MsgLevel _currentLogLevel = MsgLevel.Error;
        /// <summary>
        ///  Current logging level
        /// </summary>
        public MsgLevel CurrentMsgType
        {
            get { return _currentLogLevel; }
            set { _currentLogLevel = value; }
        }
        /// <summary>
        ///  Currently responsible for logging the name of the log file
        /// </summary>
        private  string _currentFileName="1.log";
        private  string _fileNamePrefix = "log_";
        /// <summary>
        ///  The prefix name of the log, by default log_
        /// </summary>
        public string FileNamePrefix
        {
            get { return _fileNamePrefix; }
            set { _fileNamePrefix = value; }
        }
        /// <summary>
        ///  A time marker for the log file lifecycle
        /// </summary>
        private  DateTime _CurrentFileTimeSign = new DateTime();
        private  int _maxFileSize = 2;
        /// <summary>
        ///  The default size for a single log file ( Unit: $ )
        /// </summary>
        public  int MaxFileSize
        {
            get { return _maxFileSize; }
            set { _maxFileSize = value; }
        }
        /// <summary>
        ///  File suffix
        /// </summary>
        private  int _fileSymbol = 0;

        /// <summary>
        ///  Current file size ( Units: B)
        /// </summary>
        private  long _fileSize = 0;
        /// <summary>
        ///  Log files are written into the stream object
        /// </summary>
        private StreamWriter _writer;

        /// <summary>
        ///  Create a new instance of the log object , Creates a type based on the specified log file path and the specified log file
        /// </summary>
        private Log()
        {
            if (_msgs == null)
            {
                GetCurrentFilename();
                _state = true;
                _msgs = new Queue<Msg>();
                Thread thread = new Thread(work);
                thread.Start();
            }
        }
        // The method by which the log file is written to the thread execution
        private void work()
        {
            while (true)
            {
                // Determines if there is a log to write in the queue
                if (_msgs.Count > 0)
                {
                    Msg msg = null;
                    lock (_msgs)
                    {
                        msg = _msgs.Dequeue();
                        if (msg != null)
                        {
                            FileWrite(msg);
                        }
                    }
                }
                else
                {
                    // Determines whether a message has been sent to terminate the log and close it
                    if (_state)
                    {
                        Thread.Sleep(1);
                    }
                    else
                    {
                        FileClose();
                    }
                }
            }
        }
        /// <summary>
        ///  Gets the log file name based on the log type , And at the same time create a time marker for the file to expire
        ///  The decision to create a new file is made by determining the expiration date of the file.
        /// </summary>
        /// <returns></returns>
        private
            void  GetCurrentFilename()
        {
            DateTime now = DateTime.Now;
            string format = "";
            switch (_logFileSplit)
            {
                case LogFileSplit.Daily:
                    _CurrentFileTimeSign = new DateTime(now.Year, now.Month, now.Day);
                    _CurrentFileTimeSign = _CurrentFileTimeSign.AddDays(1);
                    format = now.ToString("yyyyMMdd'.log'");
                    break;
                case LogFileSplit.Weekly:
                    _CurrentFileTimeSign = new DateTime(now.Year, now.Month, now.Day);
                    _CurrentFileTimeSign = _CurrentFileTimeSign.AddDays(7);
                    format = now.ToString("yyyyMMdd'.log'");
                    break;
                case LogFileSplit.Monthly:
                    _CurrentFileTimeSign = new DateTime(now.Year, now.Month, 1);
                    _CurrentFileTimeSign = _CurrentFileTimeSign.AddMonths(1);
                    format = now.ToString("yyyyMM'.log'");
                    break;
                case LogFileSplit.Annually:
                    _CurrentFileTimeSign = new DateTime(now.Year, 1, 1);
                    _CurrentFileTimeSign = _CurrentFileTimeSign.AddYears(1);
                    format = now.ToString("yyyy'.log'");
                    break;
                default:
                    _fileSymbol++;
                    format = _fileSymbol.ToString() + ".log";
                    break;
            }
            if (File.Exists(Path.Combine(LogDirectory, _currentFileName)))
            {
                _fileSize = new FileInfo(Path.Combine(LogDirectory, _currentFileName)).Length;
            }
            else
            {
                _fileSize = 0;
            }
            _currentFileName=_fileNamePrefix + format.Trim();
        }
        // Method to write log text to a file
        private void FileWrite(Msg msg)
        {
            try
            {
                if (_writer == null)
                {
                    FileOpen();
                }
                if (_writer != null)
                {
                    // Determine the file expiration mark , If the current file expires, close the current file to create a new log file
                    if ((_logFileSplit != LogFileSplit.Sizely && DateTime.Now >= _CurrentFileTimeSign)||
                        (_logFileSplit == LogFileSplit.Sizely && ((double)_fileSize / 1048576) > _maxFileSize))
                    {
                        GetCurrentFilename();
                        FileClose();
                        FileOpen();
                    }
                    _writer.Write(msg.datetime);
                    _writer.Write('\t');
                    _writer.Write(msg.type);
                    _writer.Write('\t');
                    _writer.WriteLine(msg.text);                   
                    _fileSize+=System.Text.Encoding.UTF8.GetBytes(msg.ToString()).Length;  
                    _writer.Flush();
                }
            }
            catch (Exception e)
            {
                Console.Out.Write(e);
            }
        }
        // Open file ready to write
        private void FileOpen()
        {
            _writer = new StreamWriter(LogDirectory + _currentFileName, true, Encoding.UTF8);
        }
        // Close the open log file
        private void FileClose()
        {
            if (_writer != null)
            {
                _writer.Flush();
                _writer.Close();
                _writer.Dispose();
                _writer = null;
            }
        }
        /// <summary>
        ///  Write to new log , According to the specified log object Msg
        /// </summary>
        /// <param name="msg"> Log content object </param>
        private void LogWrite(Msg msg)
        {
            if (msg.type < CurrentMsgType)
                return;
            if (_msgs != null)
            {
                lock (_msgs)
                {
                    _msgs.Enqueue(msg);
                }
            }
        }
        /// <summary>
        ///  Write to new log , According to the specified log content and information type , Write a new log using the current time for the log time
        /// </summary>
        /// <param name="text"> Log contents </param>
        /// <param name="type"> Information types </param>
        public void LogWrite(string text, MsgLevel type)
        {
            LogWrite(new Msg(text, type));
        }
        /// <summary>
        ///  Write to new log , According to the specified log content
        /// </summary>
        /// <param name="text"> Log contents </param>
        public void LogWrite(string text)
        {
            LogWrite(text, MsgLevel.Debug);
        }
        /// <summary>
        ///  Write to new log , Writes a new log based on the specified log time, log content, and information type
        /// </summary>
        /// <param name="dt"> Log time </param>
        /// <param name="text"> Log contents </param>
        /// <param name="type"> Information types </param>
        public void LogWrite(DateTime dt, string text, MsgLevel type)
        {
            LogWrite(new Msg(dt, text, type));
        }
        /// <summary>
        ///  Write to new log , Writes the new log based on the specified exception class and information type
        /// </summary>
        /// <param name="e"> The exception object </param>
        /// <param name="type"> Information types </param>
        public void LogWrite(Exception e)
        {
            LogWrite(new Msg(e.Message, MsgLevel.Error));
        }
        /// <summary>
        ///  Destroy log object
        /// </summary>
        public void Dispose()
        {
            _state = false;
        }
    }

    /// <summary>
    /// 1 Two logged objects
    /// </summary>
    public class Msg
    {
        /// <summary>
        ///  Create a new logging instance ; The contents of the log record are empty , The message type is MsgType.Unknown, The log time is the current time
        /// </summary>
        public Msg()
            : this("", MsgLevel.Debug)
        {
        }
        /// <summary>
        ///  Create a new logging instance ; The log event is the current time
        /// </summary>
        /// <param name="t"> The textual content of the log </param>
        /// <param name="p"> The type of message logged </param>
        public Msg(string t, MsgLevel p)
            : this(DateTime.Now, t, p)
        {
        }
        /// <summary>
        ///  Create a new logging instance ;
        /// </summary>
        /// <param name="dt"> Time logged </param>
        /// <param name="t"> The textual content of the log </param>
        /// <param name="p"> The type of message logged </param>
        public Msg(DateTime dt, string t, MsgLevel p)
        {
            datetime = dt;
            type = p;
            text = t;
        }
        /// <summary>
        ///  Time logged
        /// </summary>
        public DateTime datetime { get; set; }
        /// <summary>
        /// The contents of the log
        /// </summary>
        public string text { get; set; }
        /// <summary>
        ///  The log level
        /// </summary>
        public MsgLevel type { get; set; }

        public new string ToString()
        {
            return datetime.ToString(CultureInfo.InvariantCulture) + "\t" + text + "\n";
        }
    }
    /// <summary>
    ///  Enumeration of log file splitting
    /// </summary>
    /// <remarks> Log type enumeration indicates how log files are created , If you have more logs, consider creating them daily 1 Log files
    ///  If the logs are small, consider creating them weekly, monthly, or annually 1 Log files </remarks>
    public enum LogFileSplit
    {
        /// <summary>
        ///  This enumeration indicates daily creation 1 Two new log files
        /// </summary>
        Daily,
        /// <summary>
        ///  This enumeration indicates weekly creation 1 Two new log files
        /// </summary>
        Weekly,
        /// <summary>
        ///  This enumeration indicates monthly creation 1 Two new log files
        /// </summary>
        Monthly,
        /// <summary>
        ///  This enumeration indicates annual creation 1 Two new log files
        /// </summary>
        Annually,
        /// <summary>
        ///  The log file size exceeds the specified creation 1 Two new log files, MaxFileSize Specify the size
        /// </summary>
        Sizely
    }
    /// <summary>
    ///  Log level type  Debug=0 Infor Warn Error
    /// </summary>
    public enum MsgLevel
    {
        /// <summary>
        ///  Debugging information
        /// </summary>
        Debug = 0,
        /// <summary>
        ///  Logging that indicates a common information type
        /// </summary>
        Infor,
        /// <summary>
        ///  Logging that indicates the type of warning message
        /// </summary>
        Warn,
        /// <summary>
        ///  Logging that indicates the type of error message
        /// </summary>
        Error
    }
}