using System.Text.RegularExpressions;

namespace LTEMvcApp.Models
{
    /// <summary>
    /// 日志工具类
    /// </summary>
    public static class LogUtils
    {
        /// <summary>
        /// 日志级别常量
        /// </summary>
        public static class LogLevels
        {
            public const int None = 0;
            public const int Error = 1;
            public const int Warn = 2;
            public const int Info = 3;
            public const int Debug = 4;

            /// <summary>
            /// 获取级别名称
            /// </summary>
            /// <param name="level">级别值</param>
            /// <returns>级别名称</returns>
            public static string GetLevelName(int level)
            {
                return level switch
                {
                    None => "none",
                    Error => "error",
                    Warn => "warn",
                    Info => "info",
                    Debug => "debug",
                    _ => "unknown"
                };
            }

            /// <summary>
            /// 获取级别值
            /// </summary>
            /// <param name="levelName">级别名称</param>
            /// <returns>级别值</returns>
            public static int GetLevelValue(string levelName)
            {
                return levelName?.ToLower() switch
                {
                    "none" => None,
                    "error" => Error,
                    "warn" => Warn,
                    "info" => Info,
                    "debug" => Debug,
                    _ => None
                };
            }

            /// <summary>
            /// 获取所有级别选项
            /// </summary>
            /// <returns>级别选项列表</returns>
            public static List<LevelOption> GetLevelOptions()
            {
                return new List<LevelOption>
                {
                    new() { Value = Error, Text = "Error" },
                    new() { Value = Warn, Text = "Warning" },
                    new() { Value = Info, Text = "Info" },
                    new() { Value = Debug, Text = "Debug" }
                };
            }
        }

        /// <summary>
        /// 级别选项
        /// </summary>
        public class LevelOption
        {
            public int Value { get; set; }
            public string Text { get; set; } = string.Empty;
        }

        /// <summary>
        /// 时间戳转换为时间字符串
        /// </summary>
        /// <param name="timestamp">时间戳（毫秒）</param>
        /// <param name="full">是否显示完整日期</param>
        /// <returns>时间字符串</returns>
        public static string TimestampToTime(long timestamp, bool full = false)
        {
            // 持续时间 (< 2000-01-01 00:00:00)
            if (timestamp < 946681200000)
            {
                return TimestampToDuration(timestamp);
            }

            var dateTime = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime;
            if (full)
            {
                return dateTime.ToString("yyyy-MM-dd HH:mm:ss.fff");
            }
            return dateTime.ToString("HH:mm:ss.fff");
        }

        /// <summary>
        /// 时间戳转换为持续时间字符串
        /// </summary>
        /// <param name="timestamp">时间戳（毫秒）</param>
        /// <returns>持续时间字符串</returns>
        public static string TimestampToDuration(long timestamp)
        {
            var prefix = timestamp < 0 ? "-" : "";
            var absTimestamp = Math.Abs(timestamp);
            var timeSpan = TimeSpan.FromMilliseconds(absTimestamp);
            return $"{prefix}{timeSpan.Hours:D2}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2}.{timeSpan.Milliseconds:D3}";
        }

        /// <summary>
        /// 时间字符串转换为时间戳
        /// </summary>
        /// <param name="timeString">时间字符串</param>
        /// <returns>时间戳，转换失败返回null</returns>
        public static long? TimeStringToTimestamp(string timeString)
        {
            if (string.IsNullOrEmpty(timeString))
                return null;

            // 匹配格式: HH:mm:ss.fff 或 mm:ss.fff 或 ss.fff
            var match = Regex.Match(timeString, @"^(((\d+):)?(\d+):)?(\d+)(\.(\d+))?$");
            if (!match.Success)
                return null;

            var hours = int.Parse(match.Groups[3].Success ? match.Groups[3].Value : "0");
            var minutes = int.Parse(match.Groups[4].Success ? match.Groups[4].Value : "0");
            var seconds = int.Parse(match.Groups[5].Value);
            var milliseconds = match.Groups[7].Success ? int.Parse(match.Groups[7].Value.PadRight(3, '0')) : 0;

            return (hours * 3600000L) + (minutes * 60000L) + (seconds * 1000L) + milliseconds;
        }

        /// <summary>
        /// 获取日期偏移量
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <returns>日期偏移量</returns>
        public static long GetDayOffset(long timestamp)
        {
            if (timestamp < 946681200000)
                return 0;

            var dateTime = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime;
            var dayStart = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0, DateTimeKind.Utc);
            return new DateTimeOffset(dayStart).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 字符串转ID
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>ID值</returns>
        public static int StringToId(string str)
        {
            if (string.IsNullOrEmpty(str))
                return 0;

            var hash = 5381;
            foreach (var c in str)
            {
                hash = ((hash << 5) + hash) ^ c;
            }
            return hash;
        }

        /// <summary>
        /// 创建正则表达式
        /// </summary>
        /// <param name="pattern">模式</param>
        /// <param name="ignoreCase">是否忽略大小写</param>
        /// <returns>正则表达式，创建失败返回null</returns>
        public static Regex? CreateRegex(string pattern, bool ignoreCase = true)
        {
            if (string.IsNullOrEmpty(pattern))
                return null;

            try
            {
                var options = ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None;
                
                // 检查是否是正则表达式格式 /pattern/flags
                var regexMatch = Regex.Match(pattern, @"^/(.+)/([gi]*)$");
                if (regexMatch.Success)
                {
                    var regexPattern = regexMatch.Groups[1].Value;
                    var flags = regexMatch.Groups[2].Value;
                    
                    if (flags.Contains('i'))
                        options |= RegexOptions.IgnoreCase;
                    if (flags.Contains('g'))
                        options |= RegexOptions.Multiline;
                    
                    return new Regex(regexPattern, options);
                }
                
                // 普通文本搜索，添加转义
                var escapedPattern = Regex.Escape(pattern);
                return new Regex(escapedPattern, options);
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 高亮搜索文本
        /// </summary>
        /// <param name="text">原文本</param>
        /// <param name="searchPattern">搜索模式</param>
        /// <returns>高亮后的文本</returns>
        public static string HighlightSearchText(string text, string searchPattern)
        {
            if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(searchPattern))
                return text;

            var regex = CreateRegex(searchPattern);
            if (regex == null)
                return text;

            return regex.Replace(text, "<highlight>$&</highlight>");
        }

        /// <summary>
        /// 格式化文件大小
        /// </summary>
        /// <param name="bytes">字节数</param>
        /// <returns>格式化后的字符串</returns>
        public static string FormatFileSize(long bytes)
        {
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            double len = bytes;
            int order = 0;
            while (len >= 1024 && order < sizes.Length - 1)
            {
                order++;
                len = len / 1024;
            }
            return $"{len:0.##} {sizes[order]}";
        }

        /// <summary>
        /// 解析大小字符串
        /// </summary>
        /// <param name="sizeString">大小字符串</param>
        /// <returns>字节数</returns>
        public static long ParseSizeString(string sizeString)
        {
            if (string.IsNullOrEmpty(sizeString))
                return 0;

            var match = Regex.Match(sizeString, @"^(\d+)([KMG])?$", RegexOptions.IgnoreCase);
            if (!match.Success)
                return 0;

            var size = long.Parse(match.Groups[1].Value);
            var unit = match.Groups[2].Value.ToUpper();

            return unit switch
            {
                "K" => size * 1024,
                "M" => size * 1024 * 1024,
                "G" => size * 1024 * 1024 * 1024,
                _ => size
            };
        }

        /// <summary>
        /// 获取颜色亮度
        /// </summary>
        /// <param name="color">颜色代码</param>
        /// <returns>亮度值 (0-1)</returns>
        public static double GetColorBrightness(string color)
        {
            var match = Regex.Match(color, @"#([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})");
            if (!match.Success)
                return 1;

            var r = int.Parse(match.Groups[1].Value, System.Globalization.NumberStyles.HexNumber);
            var g = int.Parse(match.Groups[2].Value, System.Globalization.NumberStyles.HexNumber);
            var b = int.Parse(match.Groups[3].Value, System.Globalization.NumberStyles.HexNumber);

            return (r * r * 0.299 + g * g * 0.587 + b * b * 0.114) / (255.0 * 255.0);
        }

        /// <summary>
        /// 获取文本颜色
        /// </summary>
        /// <param name="backgroundColor">背景颜色</param>
        /// <returns>文本颜色</returns>
        public static string GetTextColor(string backgroundColor)
        {
            var brightness = GetColorBrightness(backgroundColor);
            return brightness >= 0.15 ? "black" : "white";
        }

        /// <summary>
        /// 生成唯一ID
        /// </summary>
        /// <returns>唯一ID</returns>
        public static string GenerateUniqueId()
        {
            return Guid.NewGuid().ToString("N");
        }

        /// <summary>
        /// 安全地执行操作
        /// </summary>
        /// <param name="action">要执行的操作</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns>操作结果或默认值</returns>
        public static T SafeExecute<T>(Func<T> action, T defaultValue)
        {
            try
            {
                return action();
            }
            catch
            {
                return defaultValue;
            }
        }
    }
}