using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FlexJobApi.Core
{
    /// <summary>
    /// 时间工具
    /// </summary>
    public static class DateTimeUtils
    {
        /// <summary>
        /// 转时间
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns>时间</returns>
        public static DateTime? ToDateTime(this object obj)
        {
            if (obj != null && DateTime.TryParse(obj.ToString(), out var date) && date != DateTime.MinValue && date != DateTimeOffset.MinValue)
            {
                return date;
            }
            return null;
        }

        /// <summary>
        /// 转时间
        /// </summary>
        /// <param name="dic">字典</param>
        /// <param name="key">键</param>
        /// <returns>值</returns>
        public static DateTime? ToDateTime<TKey, TValue>(this IDictionary<TKey, TValue> dic, TKey key)
        {
            if (dic != null && dic.ContainsKey(key) && dic[key] != null && DateTime.TryParse(dic[key]?.ToString(), out var date) && date != DateTime.MinValue) return date;
            return null;
        }

        /// <summary>
        /// 时间转时间戳
        /// </summary>
        /// <param name="time">时间</param>
        /// <param name="milliseconds">true毫秒级 false秒级</param>
        /// <returns>时间戳</returns>
        public static long ToTimeStamp(this DateTime time, bool milliseconds = true)
        {
            var timespan = time.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0);
            return milliseconds ? (long)timespan.TotalMilliseconds : timespan.Seconds;
        }

        /// <summary>
        /// 时间戳转时间
        /// </summary>
        /// <param name="timestamp">时间戳</param>
        /// <param name="milliseconds">true毫秒级 false秒级</param>
        /// <returns>时间</returns>
        public static DateTime ToDateTimeByMilliseconds(this long timestamp, bool milliseconds = true)
        {
            var time = new DateTime(1970, 1, 1, 0, 0, 0);
            time = milliseconds ? time.AddMilliseconds(timestamp) : time.AddSeconds(timestamp);
            return time.ToLocalTime();
        }

        /// <summary>
        /// 截取日期
        /// </summary>
        /// <param name="date">时间</param>
        /// <returns>日期</returns>
        public static DateTime? GetYYYYMMDD(this DateTime? date)
        {
            return date.HasValue ? date.Value.GetYYYYMMDD() : null;
        }

        /// <summary>
        /// 截取日期
        /// </summary>
        /// <param name="date">时间</param>
        /// <returns>日期</returns>
        public static DateTime GetYYYYMMDD(this DateTime date)
        {
            return new DateTime(date.Year, date.Month, date.Day);
        }

        /// <summary>
        /// 获取年龄
        /// </summary>
        /// <param name="birthday"></param>
        /// <returns></returns>
        public static int? GetAge(this DateTime? birthday)
        {
            if (birthday == null) return null;
            var age = DateTime.Now.Year - birthday.Value.Year;
            if (birthday.Value.Date > DateTime.Today.AddYears(-age))
            {
                age--;
            }
            return age;
        }

        /// <summary>
        /// 获取时间范围选择器
        /// </summary>
        /// <param name="str"></param>
        /// <param name="range"></param>
        /// <returns></returns>
        public static bool TryToDateTimeRange(this string str, out DateTimeRange range)
        {
            range = new DateTimeRange();
            if (str.IsNotNull())
            {
                if (str.Contains(","))
                {
                    var times = str.Split(',');
                    if (times.Length == 2
                        && DateTime.TryParse(times[0], out var start) && start != DateTime.MinValue
                        && DateTime.TryParse(times[1], out var end) && end != DateTime.MinValue
                        && end >= start)
                    {
                        range.Start = start;
                        range.End = end;
                    }
                }
                else if (str.StartsWith("Relative"))
                {
                    var splits = str.Split("_");
                    if (splits.Length == 4
                        && int.TryParse(splits[2], out var quantity))
                    {
                        var type = splits[1];
                        var unit = splits[3];
                        if ((type == "Before" || type == "Current" || type == "After")
                            && (unit == "Day" || unit == "Week" || unit == "Month"))
                        {
                            var now = DateTime.Now;
                            range.Start = new DateTime(now.Year, now.Month, now.Day);
                            if (type == "Before")
                            {
                                quantity = 0 - quantity;
                            }
                            switch (unit)
                            {
                                case "Day":
                                    range.Start = range.Start.AddDays(quantity);
                                    range.End = new DateTime(range.Start.Year, range.Start.Month, range.Start.Day, 23, 59, 59, 999);
                                    break;
                                case "Week":
                                    var week = (int)range.Start.DayOfWeek;
                                    range.Start = range.Start.AddDays(0 - week);
                                    range.Start = range.Start.AddDays(quantity * 7);
                                    range.End = new DateTime(range.Start.Year, range.Start.Month, range.Start.Day, 23, 59, 59, 999).AddDays(6);
                                    break;
                                case "Month":
                                    range.Start = new DateTime(now.Year, now.Month, 1).AddMonths(quantity);
                                    range.End = new DateTime(range.Start.Year, range.Start.Month, DateTime.DaysInMonth(range.Start.Year, range.Start.Month), 23, 59, 59, 999);
                                    break;
                            }
                        }
                    }
                }
                else if (DateTime.TryParse(str, out var time) && time != DateTime.MinValue)
                {
                    range.Start = time;
                    range.End = time;
                }
            }
            if (range.Start == DateTime.MinValue && range.End == DateTime.MinValue)
            {
                range = null;
                return false;
            }
            else if (
                range.Start.Hour == 0 && range.Start.Minute == 0 && range.Start.Second == 0
                && range.End.Hour == 0 && range.End.Minute == 0 && range.End.Second == 0)
            {
                range.End = new DateTime(range.End.Year, range.End.Month, range.End.Day, 23, 59, 59, 999);
            }
            return true;
        }

        /// <summary>
        /// 获取今天范围
        /// </summary>
        /// <returns></returns>
        public static DateTimeRange GetTodayRange()
        {
            var now = DateTime.Now;
            var range = new DateTimeRange();
            range.Start = new DateTime(now.Year, now.Month, now.Day);
            range.End = new DateTime(now.Year, now.Month, now.Day, 23, 59, 59, 999);
            return range;
        }

        /// <summary>
        /// 格式化
        /// </summary>
        /// <param name="span"></param>
        /// <returns></returns>
        public static string Format(this TimeSpan span)
        {
            if (span.Days > 0)
            {
                return $"{span.Days}天";
            }
            else if (span.Hours > 0)
            {
                return $"{span.Hours}小时{span.Minutes}分";
            }
            else if (span.Minutes > 0)
            {
                return $"{span.Minutes}分{span.Seconds}秒";
            }
            else if (span.Seconds > 0)
            {
                return $"{span.Seconds}秒";
            }
            else if (span.Milliseconds > 0)
            {
                return $"{span.Milliseconds}毫秒";
            }
            return null;
        }
    }
}