using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Threading;

namespace SysBaseLibs
{
    public class ThreadLog : IDisposable
    {
        //日志对象的缓存队列
        private static Queue<Msg> msgs;
        //日志文件保存的路径
        private static string path;
        //日志写入线程的控制标记
        private static bool state;
        //日志记录的类型
        private static SysLogType type;
        //日志文件生命周期的时间标记
        private static DateTime TimeSign;
        //日志文件写入流对象
        private static StreamWriter writer;

        Thread _thread = null;
        /// <summary>
        /// 创建日志对象的新实例，采用默认当前程序位置作为日志路径和默认的每日日志文件类型记录日志
        /// </summary>
        public ThreadLog()
            : this(".\\", SysLogType.Daily)
        {
        }

        /// <summary>
        /// 创建日志对象的新实例，采用默认当前程序位置作为日志路径并指定日志类型
        /// </summary>
        /// <param name="t">日志文件创建方式的枚举</param>
        public ThreadLog(SysLogType t)
            : this(".\\", t)
        {
        }

        /// <summary>
        /// 创建日志对象的新实例，根据指定的日志文件路径和指定的日志文件创建类型
        /// </summary>
        /// <param name="p">日志文件保存路径</param>
        /// <param name="t">日志文件创建方式的枚举</param>
        public ThreadLog(string p, SysLogType t)
        {
            if (msgs == null)
            {
                state = true;
                path = p;
                type = t;
                msgs = new Queue<Msg>();
                _thread = new Thread(work);
                _thread.Start();
            }
        }

        //日志文件写入线程执行的方法
        private void work()
        {
            while (true)
            {
                //判断队列中是否存在待写入的日志
                if (msgs.Count > 0)
                {
                    Msg msg = null;
                    lock (msgs)
                    {
                        msg = msgs.Dequeue();
                    }
                    if (msg != null)
                    {
                        FileWrite(msg);
                    }
                }
                else
                {
                    //判断是否已经发出终止日志并关闭的消息
                    if (state)
                    {
                        Thread.Sleep(1);
                    }
                    else
                    {
                        FileClose();
                        break;
                    }
                }
            }

            if (_thread != null && _thread.IsAlive)
            {
                _thread.Abort();
                _thread = null;
            }
        }

        //根据日志类型获取日志文件名，并同时创建文件到期的时间标记
        //通过判断文件的到期时间标记将决定是否创建新文件。
        private string GetFilename()
        {
            DateTime now = DateTime.Now;
            string format = "";
            switch (type)
            {
                case SysLogType.Daily:
                    TimeSign = new DateTime(now.Year, now.Month, now.Day);
                    TimeSign = TimeSign.AddDays(1);
                    format = "yyyyMMdd'.txt'";
                    break;
                case SysLogType.Weekly:
                    TimeSign = new DateTime(now.Year, now.Month, now.Day);
                    TimeSign = TimeSign.AddDays(7);
                    format = "yyyyMMdd'.txt'";
                    break;
                case SysLogType.Monthly:
                    TimeSign = new DateTime(now.Year, now.Month, 1);
                    TimeSign = TimeSign.AddMonths(1);
                    format = "yyyyMM'.txt'";
                    break;
                case SysLogType.Annually:
                    TimeSign = new DateTime(now.Year, 1, 1);
                    TimeSign = TimeSign.AddYears(1);
                    format = "yyyy'.txt'";
                    break;
            }
            return now.ToString(format);
        }

        //写入日志文本到文件的方法
        private void FileWrite(Msg msg)
        {
            try
            {
                if (writer == null)
                {
                    FileOpen();
                }
                else
                {
                    //判断文件到期标志，如果当前文件到期则关闭当前文件创建新的日志文件
                    if (DateTime.Now >= TimeSign)
                    {
                        FileClose();
                        FileOpen();
                    }
                    writer.Write(msg.Datetime);
                    writer.Write('\t');
                    if (msg.Type != MsgType.Blank)
                        writer.Write(msg.Type);
                    writer.Write('\t');
                    writer.WriteLine(msg.Text);
                    writer.Flush();
                }
            }
            catch (Exception e)
            {
                Console.Out.Write(e);
            }
        }

        //打开文件准备写入
        private void FileOpen()
        {
            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);
            writer = new StreamWriter(path + GetFilename(), true, Encoding.UTF8);
        }

        //关闭打开的日志文件
        private void FileClose()
        {
            if (writer != null)
            {
                writer.Flush();
                writer.Close();
                writer.Dispose();
                writer = null;
            }
        }
        public void WriteBlank(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Blank));
        }

        public void WriteErr(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Error));
        }

        public void WriteInfor(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Information));
        }

        public void WriteSuccess(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Success));
        }

        public void WriteUnknown(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Unknown));
        }

        public void WriteWarning(string pcMsg)
        {
            Write(new Msg(pcMsg, MsgType.Warning));
        }

        /// <summary>
        /// 写入新日志，根据指定的日志对象Msg
        /// </summary>
        /// <param name="msg">日志内容对象</param>
        public void Write(Msg msg)
        {
            if (msg != null)
            {
                lock (msgs)
                {
                    msgs.Enqueue(msg);
                }
            }
        }

        /// <summary>
        /// 写入新日志，根据指定的日志内容和信息类型，采用当前时间为日志时间写入新日志
        /// </summary>
        /// <param name="text">日志内容</param>
        /// <param name="type">信息类型</param>
        public void Write(string text, MsgType type)
        {
            Write(new Msg(text, type));
        }

        /// <summary>
        /// 写入新日志，根据指定的日志时间、日志内容和信息类型写入新日志
        /// </summary>
        /// <param name="dt">日志时间</param>
        /// <param name="text">日志内容</param>
        /// <param name="type">信息类型</param>
        public void Write(DateTime dt, string text, MsgType type)
        {
            Write(new Msg(dt, text, type));
        }

        /// <summary>
        /// 写入新日志，根据指定的异常类和信息类型写入新日志
        /// </summary>
        /// <param name="e">异常对象</param>
        /// <param name="type">信息类型</param>
        public void Write(Exception e, MsgType type)
        {
            Write(new Msg(e.Message, type));
        }

        #region IDisposable 成员

        /// <summary>
        /// 销毁日志对象
        /// </summary>
        public void Dispose()
        {
            state = false;
        }

        #endregion


        #region Static Motheds About SysLog

        static ThreadLog _SysLog = null;
        public static event evLogInfo LogInfoEvnet;
        public static ThreadLog SysLog
        {
            get
            {
                if (_SysLog == null)
                {
                    _SysLog = new ThreadLog(AppConfig.DefConfig.ReadString("LOGPATH"), SysLogType.Daily);
                }
                return _SysLog;
            }
        }

        public static void LogBlank(string pcMessage)
        {
            ThreadLog.SysLog.Write(pcMessage, MsgType.Blank);
            FireLogEvent(pcMessage, MsgType.Information);
        }

        public static void LogException(Exception err)
        {
            ThreadLog.SysLog.Write("Source:" + err.Source + "\r\nTargetSite:" + err.TargetSite + "\r\nStackTrace:" + err.StackTrace + "\r\nMessage:" + err.Message, MsgType.Error);
            FireLogEvent("Source:" + err.Source + "\r\nTargetSite:" + err.TargetSite + "\r\nStackTrace:" + err.StackTrace + "\r\nMessage:" + err.Message, MsgType.Error);
        }

        public static void LogErr(string pcMessage)
        {
            ThreadLog.SysLog.Write(pcMessage, MsgType.Error);
            FireLogEvent(pcMessage, MsgType.Error);
        }

        public static void LogInfo(string pcMessage)
        {
            ThreadLog.SysLog.Write(pcMessage, MsgType.Information);
            FireLogEvent(pcMessage, MsgType.Information);
        }

        public static void LogWarning(string pcMessage)
        {
            ThreadLog.SysLog.Write(pcMessage, MsgType.Warning);
            FireLogEvent(pcMessage, MsgType.Warning);
        }

        public static void LogUnknown(string pcMessage)
        {
            ThreadLog.SysLog.Write(pcMessage, MsgType.Unknown);
            FireLogEvent(pcMessage, MsgType.Unknown);
        }

        static void FireLogEvent(string logInfo, MsgType poMsgType)
        {
            if (LogInfoEvnet != null)
                LogInfoEvnet(logInfo, poMsgType);
        }

        #endregion
    }


    public delegate void evLogInfo(string logInfo, MsgType poMsgType);

    public enum SysLogType
    {
        /// <summary>
        /// 此枚举指示每天创建一个新的日志文件
        /// </summary>
        Daily,

        /// <summary>
        /// 此枚举指示每周创建一个新的日志文件
        /// </summary>
        Weekly,

        /// <summary>
        /// 此枚举指示每月创建一个新的日志文件
        /// </summary>
        Monthly,

        /// <summary>
        /// 此枚举指示每年创建一个新的日志文件
        /// </summary>
        Annually
    }

    public class Msg
    {
        //日志记录的时间
        private DateTime datetime;
        //日志记录的内容
        private string text;
        //日志记录的类型
        private MsgType type;

        /// <summary>
        /// 创建新的日志记录实例;日志记录的内容为空,消息类型为MsgType.Unknown,日志时间为当前时间
        /// </summary>
        public Msg()
            : this("", MsgType.Unknown)
        {
        }

        /// <summary>
        /// 创建新的日志记录实例;日志事件为当前时间
        /// </summary>
        /// <param name="t">日志记录的文本内容</param>
        /// <param name="p">日志记录的消息类型</param>
        public Msg(string t, MsgType p)
            : this(DateTime.Now, t, p)
        {
        }

        /// <summary>
        /// 创建新的日志记录实例;
        /// </summary>
        /// <param name="dt">日志记录的时间</param>
        /// <param name="t">日志记录的文本内容</param>
        /// <param name="p">日志记录的消息类型</param>
        public Msg(DateTime dt, string t, MsgType p)
        {
            datetime = dt;
            type = p;
            text = t;
        }

        /// <summary>
        /// 获取或设置日志记录的时间
        /// </summary>
        public DateTime Datetime
        {
            get { return datetime; }
            set { datetime = value; }
        }

        /// <summary>
        /// 获取或设置日志记录的文本内容
        /// </summary>
        public string Text
        {
            get { return text; }
            set { text = value; }
        }

        /// <summary>
        /// 获取或设置日志记录的消息类型
        /// </summary>
        public MsgType Type
        {
            get { return type; }
            set { type = value; }
        }

        public override string ToString()
        {
            return datetime.ToString() + "\t" + text + "\n";
        }
    }



    public enum MsgType
    {
        /// <summary>
        /// 指示空的信息类型的日志记录
        /// </summary>
        Blank,
        /// <summary>
        /// 指示未知信息类型的日志记录
        /// </summary>
        Unknown,

        /// <summary>
        /// 指示普通信息类型的日志记录
        /// </summary>
        Information,

        /// <summary>
        /// 指示警告信息类型的日志记录
        /// </summary>
        Warning,

        /// <summary>
        /// 指示错误信息类型的日志记录
        /// </summary>
        Error,

        /// <summary>
        /// 指示成功信息类型的日志记录
        /// </summary>
        Success
    }
}