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

namespace DuckEmulator.HabboHotel.Inside.Helpers
{
    public static class Out
    {
        #region logFlags enum

        public enum logFlags
        {
            lowLogLevel,
            BelowStandardlogLevel,
            StandardLogLevel,
            ImportantLogLevel,
        }

        #endregion

        private static readonly Queue queItem = new Queue();
        public static logFlags minimumImportance = logFlags.lowLogLevel;
        private static bool logging;
        private static DateTime timeNow;

        public static void startLogger()
        {
            new Thread((() =>
                            {
                                logging = true;
                                while (logging)
                                {
                                    if (queItem.Count > 0)
                                    {
                                        lock (queItem.SyncRoot)
                                        {
                                            while (queItem.Count > 0)
                                                ((PrintItem) queItem.Dequeue()).doWrite();
                                        }
                                    }
                                    else
                                        Thread.Sleep(5);
                                }
                            })).Start();
        }

        public static void stopLogger()
        {
            logging = false;
        }

        private static void enQueueItem(PrintItem item)
        {
            if (!logging)
                return;

            timeNow = DateTime.Now;

            lock (queItem.SyncRoot)
                queItem.Enqueue(item);
        }

        public static void writeNotification(string logText)
        {
            if (minimumImportance > logFlags.lowLogLevel)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeNormal));
        }

        public static void writeLine(string logText, logFlags flag)
        {
            if (flag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeNormal));
        }

        public static void WriteLine(string logText, logFlags flag)
        {
            if (flag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeNormal));
        }

        public static void writeLine(string logText, logFlags logFlag, ConsoleColor colorOne, ConsoleColor colorTwo)
        {
            if (logFlag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeSpecialColorLine,
                                      colorOne, colorTwo));
        }

        public static void writeError(string logText)
        {
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeSpecialColorLine,
                                      ConsoleColor.Red, ConsoleColor.DarkRed));
        }

        public static void writePlain(string logText, logFlags flag)
        {
            if (flag < minimumImportance)
                return;
            enQueueItem(new PrintItem(logText.Replace(Convert.ToChar(13).ToString(), "{13}"), null, null, null, null,
                                      writePlain));
        }

        public static void writeBlank()
        {
            enQueueItem(new PrintItem(null, null, null, null, null, printEmpty));
        }

        public static void writeSpecialLine(string logText, logFlags flag, ConsoleColor headerColor,
                                            ConsoleColor colorTwo, string headerHead)
        {
            if (flag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeSpecialLineWithHeaderHead,
                                      headerColor, colorTwo, headerHead));
        }

        public static void writeRedText(string logText, logFlags flag)
        {
            if (flag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeRed));
        }

        public static void writeDCError(string logText)
        {
            enQueueItem(new PrintItem(logText, null, null, null, null, fileWriter, ConsoleColor.Black,
                                      ConsoleColor.Black, "dc.err"));
        }

        public static void writeAreaLoopError(string logText)
        {
            enQueueItem(new PrintItem(logText, null, null, null, null, fileWriter, ConsoleColor.Black,
                                      ConsoleColor.Black, "areaLoop.err"));
        }

        private static void fileWriter(PrintItem item)
        {
            writeToFile(item.headerText, item.message);
        }

        public static void writeSeriousError(string logText)
        {
            enQueueItem(new PrintItem(logText, null, null, null, null, fileWriter, ConsoleColor.Black,
                                      ConsoleColor.Black, "serious.err"));
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(
                new PrintItem(
                    "A serious error occured in the brainwave platform. It has been written to the file serious.err",
                    frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name, timeNow.ToLongTimeString(),
                    timeNow.Millisecond.ToString(), writeSpecialColorLine, ConsoleColor.Red, ConsoleColor.DarkRed));
        }

        public static void writeSqlError(Exception ex, string command)
        {
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(ex.Message + "\r\n\r\n" + command, null, null, null, null, fileWriter,
                                      ConsoleColor.Black, ConsoleColor.Black, "sql.err"));
            enQueueItem(new PrintItem(ex.Message + "\r\n\r\n" + command, frame.GetMethod().Name,
                                      frame.GetMethod().ReflectedType.Name, timeNow.ToLongTimeString(),
                                      timeNow.Millisecond.ToString(), writeSpecialColorLine, ConsoleColor.Red,
                                      ConsoleColor.DarkRed));
        }

        private static void writeToFile(string fileName, string text)
        {
            try
            {
                var fileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write);
                while (!fileStream.CanWrite)
                    Thread.Sleep(1);
                byte[] bytes = Encoding.ASCII.GetBytes(text + "\r\n\r\n");
                fileStream.Write(bytes, 0, bytes.Length);
                fileStream.Close();
            }
            catch (Exception e)
            {
                writeError(e.Message, logFlags.ImportantLogLevel);
            }
        }

        public static void writeError(string logText, logFlags flag)
        {
            if (flag < minimumImportance)
                return;
            StackFrame frame = new StackTrace().GetFrame(1);
            enQueueItem(new PrintItem(logText, frame.GetMethod().Name, frame.GetMethod().ReflectedType.Name,
                                      timeNow.ToLongTimeString(), timeNow.Millisecond.ToString(), writeSpecialColorLine,
                                      ConsoleColor.Red, ConsoleColor.DarkRed));
        }

        private static void writeSpecialColorLine(PrintItem item)
        {
            Console.Write("[" + item.dateTimenow + ":" + item.milliSecond + "] [");
            Console.ForegroundColor = item.colorOne;
            Console.Write(item.className + "." + item.methodName);
            Console.ForegroundColor = ConsoleColor.Gray;
            Console.Write("] » ");
            Console.ForegroundColor = item.colorTwo;
            Console.WriteLine(item.message);
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        private static void writePlain(PrintItem item)
        {
            Console.WriteLine(item.message);
        }

        private static void printEmpty(PrintItem item)
        {
            Console.WriteLine();
        }

        private static void writeDefaultHeader(PrintItem item)
        {
            Console.Write("[" + item.dateTimenow + ":" + item.milliSecond + "] [");
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write(item.className + "." + item.methodName);
            Console.ForegroundColor = ConsoleColor.Gray;
            Console.Write("] » ");
        }

        private static void writeRed(PrintItem item)
        {
            writeDefaultHeader(item);
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(item.message);
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        private static void writeNormal(PrintItem item)
        {
            writeDefaultHeader(item);
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.WriteLine(item.message);
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        private static void writeSpecialLineWithHeaderHead(PrintItem item)
        {
            writeDefaultHeader(item);
            Console.ForegroundColor = item.colorOne;
            Console.Write(item.headerText);
            Console.ForegroundColor = item.colorTwo;
            Console.WriteLine(item.message);
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        #region Nested type: PrintItem

        private class PrintItem
        {
            #region Delegates

            public delegate void LoggerMethod(PrintItem item);

            #endregion

            public readonly string className;
            public readonly ConsoleColor colorOne;
            public readonly ConsoleColor colorTwo;
            public readonly string dateTimenow;
            public readonly string headerText;
            private readonly LoggerMethod loggerMethod;
            public readonly string message;
            public readonly string methodName;
            public readonly string milliSecond;

            public PrintItem(string message, string methodName, string className, string dateTimenow, string milliSecond,
                             LoggerMethod method)
            {
                this.message = message;
                this.methodName = methodName;
                this.dateTimenow = dateTimenow;
                loggerMethod = method;
                this.milliSecond = milliSecond;
                this.className = className;
            }

            public PrintItem(string message, string methodName, string className, string dateTimenow, string milliSecond,
                             LoggerMethod method, ConsoleColor colorOne, ConsoleColor colorTwo)
                : this(message, methodName, className, dateTimenow, milliSecond, method)
            {
                this.colorOne = colorOne;
                this.colorTwo = colorTwo;
            }

            public PrintItem(string message, string methodName, string className, string dateTimenow, string milliSecond,
                             LoggerMethod method, ConsoleColor colorOne, ConsoleColor colorTwo, string headerText)
                : this(message, methodName, className, dateTimenow, milliSecond, method, colorOne, colorTwo)
            {
                this.headerText = headerText;
            }

            public void doWrite()
            {
                loggerMethod(this);
            }
        }

        #endregion
    }
}