CoreAgent/CoreAgent.ProtocolClient/Helpers/TimeStampHelper.cs

using System;

namespace CoreAgent.ProtocolClient.Helpers
{
    /// <summary>
    /// 时间戳工具类
    /// 提供各种时间戳转换和处理的静态方法
    /// </summary>
    public static class TimeStampHelper
    {
        /// <summary>
        /// 中国标准时间（北京时间，UTC+8）
        /// </summary>
        private static readonly TimeZoneInfo ChinaStandardTime = TimeZoneInfo.FindSystemTimeZoneById("China Standard Time");

        /// <summary>
        /// 将只有时分秒毫秒的时间戳转换为包含年月日的完整时间戳（按北京时间）
        /// </summary>
        /// <param name="timeOnlyTimestamp">只有时分秒毫秒的时间戳（如：73365316）</param>
        /// <returns>包含年月日的完整Unix时间戳（毫秒）</returns>
        public static long ConvertToFullTimestamp(long timeOnlyTimestamp)
        {
            // 获取当前北京时间的日期部分
            var utcNow = DateTime.UtcNow;
            var beijingNow = TimeZoneInfo.ConvertTime(utcNow, ChinaStandardTime);
            var beijingToday = beijingNow.Date;

            // 将毫秒时间戳转换为TimeSpan
            var timeSpan = TimeSpan.FromMilliseconds(timeOnlyTimestamp);

            // 组合成完整的北京时间
            var fullDateTime = beijingToday.Add(timeSpan);

            // 转换为Unix时间戳（确保使用UTC时间）
            var utcDateTime = TimeZoneInfo.ConvertTimeToUtc(fullDateTime, ChinaStandardTime);
            return new DateTimeOffset(utcDateTime, TimeSpan.Zero).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 将Unix时间戳转换为北京时间
        /// </summary>
        /// <param name="timestamp">Unix时间戳（毫秒）</param>
        /// <returns>北京时间</returns>
        public static DateTime ConvertToBeijingTime(long timestamp)
        {
            var utcDateTime = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).UtcDateTime;
            return TimeZoneInfo.ConvertTimeFromUtc(utcDateTime, ChinaStandardTime);
        }

        /// <summary>
        /// 将Unix时间戳转换为UTC时间
        /// </summary>
        /// <param name="timestamp">Unix时间戳（毫秒）</param>
        /// <returns>UTC时间</returns>
        public static DateTime ConvertToUtcTime(long timestamp)
        {
            return DateTimeOffset.FromUnixTimeMilliseconds(timestamp).UtcDateTime;
        }

        /// <summary>
        /// 获取时间戳的北京时间字符串表示
        /// </summary>
        /// <param name="timestamp">Unix时间戳（毫秒）</param>
        /// <param name="includeMilliseconds">是否包含毫秒</param>
        /// <returns>格式化的北京时间字符串</returns>
        public static string GetBeijingTimeString(long timestamp, bool includeMilliseconds = true)
        {
            var beijingTime = ConvertToBeijingTime(timestamp);
            return includeMilliseconds 
                ? beijingTime.ToString("yyyy-MM-dd HH:mm:ss.fff")
                : beijingTime.ToString("yyyy-MM-dd HH:mm:ss");
        }

        /// <summary>
        /// 获取时间戳的UTC时间字符串表示
        /// </summary>
        /// <param name="timestamp">Unix时间戳（毫秒）</param>
        /// <param name="includeMilliseconds">是否包含毫秒</param>
        /// <returns>格式化的UTC时间字符串</returns>
        public static string GetUtcTimeString(long timestamp, bool includeMilliseconds = true)
        {
            var utcTime = ConvertToUtcTime(timestamp);
            return includeMilliseconds 
                ? utcTime.ToString("yyyy-MM-dd HH:mm:ss.fff")
                : utcTime.ToString("yyyy-MM-dd HH:mm:ss");
        }

        /// <summary>
        /// 判断时间戳是否为毫秒级
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <returns>true表示毫秒级，false表示秒级</returns>
        public static bool IsMillisecondsTimestamp(long timestamp)
        {
            return timestamp > 9999999999; // 大于10位数字通常是毫秒级
        }

        /// <summary>
        /// 智能转换时间戳（自动判断是秒级还是毫秒级）
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <returns>北京时间</returns>
        public static DateTime SmartConvertToBeijingTime(long timestamp)
        {
            if (IsMillisecondsTimestamp(timestamp))
            {
                return ConvertToBeijingTime(timestamp);
            }
            else
            {
                // 秒级时间戳转换为毫秒级
                var millisecondTimestamp = timestamp * 1000;
                return ConvertToBeijingTime(millisecondTimestamp);
            }
        }

        /// <summary>
        /// 智能转换时间戳（自动判断是秒级还是毫秒级）
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <returns>UTC时间</returns>
        public static DateTime SmartConvertToUtcTime(long timestamp)
        {
            if (IsMillisecondsTimestamp(timestamp))
            {
                return ConvertToUtcTime(timestamp);
            }
            else
            {
                // 秒级时间戳转换为毫秒级
                var millisecondTimestamp = timestamp * 1000;
                return ConvertToUtcTime(millisecondTimestamp);
            }
        }

        /// <summary>
        /// 获取当前北京时间的Unix时间戳
        /// </summary>
        /// <returns>当前北京时间的Unix时间戳（毫秒）</returns>
        public static long GetCurrentBeijingTimestamp()
        {
            var beijingNow = TimeZoneInfo.ConvertTime(DateTime.UtcNow, ChinaStandardTime);
            return new DateTimeOffset(beijingNow, ChinaStandardTime.GetUtcOffset(beijingNow)).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 获取当前UTC时间的Unix时间戳
        /// </summary>
        /// <returns>当前UTC时间的Unix时间戳（毫秒）</returns>
        public static long GetCurrentUtcTimestamp()
        {
            return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 解析时间字符串为Unix时间戳
        /// </summary>
        /// <param name="dateTimeString">时间字符串（格式：yyyy-MM-dd HH:mm:ss 或 yyyy-MM-dd HH:mm:ss.fff）</param>
        /// <param name="isBeijingTime">是否为北京时间，true为北京时间，false为UTC时间</param>
        /// <returns>Unix时间戳（毫秒）</returns>
        public static long ParseDateTimeString(string dateTimeString, bool isBeijingTime = true)
        {
            if (DateTime.TryParse(dateTimeString, out DateTime parsedDateTime))
            {
                if (isBeijingTime)
                {
                    // 假设输入的是北京时间，转换为UTC
                    var utcDateTime = TimeZoneInfo.ConvertTimeToUtc(parsedDateTime, ChinaStandardTime);
                    return new DateTimeOffset(utcDateTime, TimeSpan.Zero).ToUnixTimeMilliseconds();
                }
                else
                {
                    // 假设输入的是UTC时间
                    return new DateTimeOffset(parsedDateTime, TimeSpan.Zero).ToUnixTimeMilliseconds();
                }
            }
            
            throw new ArgumentException($"无法解析时间字符串: {dateTimeString}");
        }

        /// <summary>
        /// 获取时间戳的详细信息
        /// </summary>
        /// <param name="timestamp">Unix时间戳（毫秒）</param>
        /// <returns>包含各种时间格式的详细信息</returns>
        public static TimeStampInfo GetTimeStampInfo(long timestamp)
        {
            var beijingTime = ConvertToBeijingTime(timestamp);
            var utcTime = ConvertToUtcTime(timestamp);

            return new TimeStampInfo
            {
                OriginalTimestamp = timestamp,
                BeijingTime = beijingTime,
                UtcTime = utcTime,
                BeijingTimeString = beijingTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                UtcTimeString = utcTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                Year = beijingTime.Year,
                Month = beijingTime.Month,
                Day = beijingTime.Day,
                Hour = beijingTime.Hour,
                Minute = beijingTime.Minute,
                Second = beijingTime.Second,
                Millisecond = beijingTime.Millisecond
            };
        }
    }

    /// <summary>
    /// 时间戳详细信息
    /// </summary>
    public class TimeStampInfo
    {
        /// <summary>
        /// 原始时间戳
        /// </summary>
        public long OriginalTimestamp { get; set; }

        /// <summary>
        /// 北京时间
        /// </summary>
        public DateTime BeijingTime { get; set; }

        /// <summary>
        /// UTC时间
        /// </summary>
        public DateTime UtcTime { get; set; }

        /// <summary>
        /// 北京时间字符串
        /// </summary>
        public string BeijingTimeString { get; set; } = string.Empty;

        /// <summary>
        /// UTC时间字符串
        /// </summary>
        public string UtcTimeString { get; set; } = string.Empty;

        /// <summary>
        /// 年
        /// </summary>
        public int Year { get; set; }

        /// <summary>
        /// 月
        /// </summary>
        public int Month { get; set; }

        /// <summary>
        /// 日
        /// </summary>
        public int Day { get; set; }

        /// <summary>
        /// 时
        /// </summary>
        public int Hour { get; set; }

        /// <summary>
        /// 分
        /// </summary>
        public int Minute { get; set; }

        /// <summary>
        /// 秒
        /// </summary>
        public int Second { get; set; }

        /// <summary>
        /// 毫秒
        /// </summary>
        public int Millisecond { get; set; }
    }
}