package com.yami.trading.common.util;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.util.*;

/**
 * 日期工具类
 *
 * 参考资料：
 *     https://blog.csdn.net/shuair/article/details/126694562
 *     https://www.cnblogs.com/convict/p/16180509.html
 *
 *  时区对照表：
 *     http://t.zoukankan.com/kakaisgood-p-12523507.html
 *     https://blog.csdn.net/LordForce/article/details/132101076
 */
public class DateTimeTools {
	private final static Logger logger = LoggerFactory.getLogger(DateTimeTools.class);

	public static final String DEFAULT_DATA_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

	// 处理类似格式：2022-07-08T04:02:43.85
	public static final String DATA_TIME_FORMAT_2 = "yyyy-MM-dd'T'HH:mm:ss.SSS";

	// 带时区格式
	public static final String DATA_TIME_FORMAT_3 = "yyyy-MM-dd'T'HH:mm:ssZ";

	public static final String DAY_FORMAT = "yyyy-MM-dd";

	// 提前缓存各个时区的标记，以及各个时区和 UTC 时区的时差
	public static TimeZone utcZone = TimeZone.getTimeZone("UTC");

	/**
	 * 基于系统时区，将指定 date 类型对象转换为 LocalDateTime 对象
	 *
	 * @param date
	 * @return
	 */
	public static LocalDateTime date2LocalDateTime(Date date) {
		if (date == null) {
			return null;
		}

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();

		// 方式1
		ZonedDateTime zonedDateTime = date.toInstant().atZone(zoneId);
		return zonedDateTime.toLocalDateTime();

//		// 方式2
//		return LocalDateTime.ofInstant(date.toInstant(), zoneId);
	}

	public static LocalDate date2LocalDate(Date date) {
		if (date == null) {
			return null;
		}

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();

		// 方式1
		ZonedDateTime zonedDateTime = date.toInstant().atZone(zoneId);
		return zonedDateTime.toLocalDate();

//		// 方式2
//		LocalDateTime localDateTime2 = LocalDateTime.ofInstant(date.toInstant(), zoneId);
//		return localDateTime2.toLocalDate();
	}

	public static LocalTime date2LocalTime(Date date) {
		if (date == null) {
			return null;
		}

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();

		// 方式1
		ZonedDateTime zonedDateTime = date.toInstant().atZone(zoneId);
		return zonedDateTime.toLocalTime();

		// 方式2
//		LocalDateTime localDateTime2 = LocalDateTime.ofInstant(date.toInstant(), zoneId);
//		return localDateTime2.toLocalTime();
	}

	/**
	 * 将当前系统时区的时间转换成 Date 类型对象；
	 * 注意：参数 time 关联的是当前系统时区的时间
	 *
	 * @param time
	 * @return
	 */
	public static Date localDateTime2Date(LocalDateTime time) {
		if (time == null) {
			return null;
		}

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();

		Instant instant = time.atZone(zoneId).toInstant();
		return Date.from(instant);
	}

	public static Date localDate2Date(LocalDate time) {
		if (time == null) {
			return null;
		}
		// 由于`LocalDate`不带有时间信息，所以必须设置时间，才能转 Date

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();
		Instant instant;
		Date date;

		// 方式1：atStartOfDay，自动赋予午夜时间，返回 LocalDateTime，设置时区返回 ZonedDateTime，进而得到 Instant
		instant = time.atStartOfDay().atZone(zoneId).toInstant();
		date = Date.from(instant);
		System.out.println(date);

		return date;

//		// 方式2
//		instant = time.atStartOfDay(zoneId).toInstant();
//		date = Date.from(instant);
//		System.out.println(date);
//
//		// 方式3：atStartOfDay 的底层实现
//		instant = time.atTime(LocalTime.MIDNIGHT).atZone(zoneId).toInstant();
//		date = Date.from(instant);
//		System.out.println(date);
//
//		// 方式4
//		instant = LocalDateTime.of(time, LocalTime.MIDNIGHT).atZone(zoneId).toInstant();
//		date = Date.from(instant);
//		System.out.println(date);
//
//		// 方式5：通过 Timestamp 得到 Instant
//		instant = Timestamp.valueOf(time.atTime(LocalTime.MIDNIGHT)).toInstant();
//		date = Date.from(instant);
//		System.out.println(date);
//
//		// 方式6
//		instant = Timestamp.valueOf(LocalDateTime.of(time, LocalTime.MIDNIGHT)).toInstant();
//		date = Date.from(instant);
//		System.out.println(date);
//
//		// 方式7：通过毫秒数初始化 Date 对象
//		Timestamp timestamp = Timestamp.valueOf(time.atTime(LocalTime.MIDNIGHT));
//		date = new Date(timestamp.getTime());
//		System.out.println(date);
	}

	public static Date localTime2Date(LocalTime time) {
		if (time == null) {
			return null;
		}

		// 由于 LocalTime 不带有日期信息，所以必须设置日期，才能转 Date
		LocalDate nowDate = LocalDate.now();

		// 时区
		ZoneId zoneId = ZoneId.systemDefault();
		Instant instant;
		Date date;

		instant = LocalDateTime.of(nowDate, time).atZone(zoneId).toInstant();
		date = Date.from(instant);

		instant = Timestamp.valueOf(LocalDateTime.of(nowDate, time)).toInstant();
		date = Date.from(instant);

		Timestamp timestamp = Timestamp.valueOf(LocalDateTime.of(nowDate, time));
		date = new Date(timestamp.getTime());

		return date;
	}

	public static Date getDateFromMs(long ms) {
		return new Date(ms);
	}

	public static LocalDate getLocalDateFromMs(long ms) {
		Date date = getDateFromMs(ms);
		return date2LocalDate(date);
	}

	public static LocalTime getLocalTimeFromMs(long ms) {
		Date date = getDateFromMs(ms);
		return date2LocalTime(date);
	}

	public static LocalDateTime getLocalDateTimeFromMs(long ms) {
		Date date = getDateFromMs(ms);
		return date2LocalDateTime(date);
	}

	/**
	 * 获取当前天
	 *
	 * @return String
	 */
	public static String getCurDayStr() {
		return new SimpleDateFormat(DAY_FORMAT).format(new Date());
	}

	public static String getDayStr(Date time) {
		if (time == null) {
			return null;
		}

		return new SimpleDateFormat(DAY_FORMAT).format(time);
	}

	/**
	 * 获取前一天
	 * 注意时区的影响！！！
	 *
	 * @return Date
	 */
	public static Date getPreviousDate() {
		Calendar begin = Calendar.getInstance();
		begin.set(Calendar.DAY_OF_MONTH, begin.get(Calendar.DAY_OF_MONTH) - 1);
		begin.set(Calendar.HOUR_OF_DAY, 0);
		begin.set(Calendar.MINUTE, 0);
		begin.set(Calendar.SECOND, 0);
		return begin.getTime();
	}

	/**
	 * 获取下N天
	 * 注意时区的影响！！！
	 *
	 * @param date
	 *            当前时间
	 * @param n
	 *            下N天
	 * @return Date 下N天日期
	 */
	public static Date getNextDate(Date date, int n) {
		if (date == null) {
			return null;
		}

		Calendar begin = Calendar.getInstance();
		begin.setTime(date);
		begin.set(Calendar.DAY_OF_MONTH, begin.get(Calendar.DAY_OF_MONTH) + n);
		begin.set(Calendar.HOUR_OF_DAY, 0);
		begin.set(Calendar.MINUTE, 0);
		begin.set(Calendar.SECOND, 0);
		begin.set(Calendar.MILLISECOND, 0);
		return begin.getTime();
	}

	/**
	 * 添加秒数
	 * 注意时区的影响！！！
	 *
	 * @return Date
	 */
	public static Date addSecond(Long date, int second) {
		if (date == null) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTimeInMillis(date);
		cal.add(Calendar.SECOND, second);
		return cal.getTime();
	}

	/**
	 * 添加小时
	 * 注意时区的影响！！！
	 *
	 * @param date
	 * @param hour
	 * @return Date
	 */
	public static Date addHour(Long date, int hour) {
		if (date == null || date <= 0) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTimeInMillis(date);
		cal.add(Calendar.HOUR_OF_DAY, hour);
		return cal.getTime();
	}

	/**
	 * 添加小时
	 * 注意时区的影响！！！
	 *
	 * @param date
	 * @param hour
	 * @return Date
	 */
	public static Date addHour(Date date, int hour) {
		if (date == null) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);;
		cal.add(Calendar.HOUR_OF_DAY, hour);
		return cal.getTime();
	}

	/**
	 * 注意时区的影响！！！
	 *
	 * @param date
	 * @param minutes
	 * @return
	 */
	public static Date addMinutes(Date date, int minutes) {
		if (date == null) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.MINUTE, minutes);
		return cal.getTime();
	}

	/**
	 * 添加秒数
	 * 注意时区的影响！！！
	 *
	 * @return Date
	 */
	public static Date addSecond(Date date, int second) {
		if (date == null) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.SECOND, second);
		return cal.getTime();
	}

	/**
	 * 添加天数
	 * 注意时区的影响！！！
	 *
	 * @param date
	 * @param day
	 * @return Date
	 */
	public static Date addDay(Date date, int day) {
		if (date == null) {
			return null;
		}

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.DAY_OF_YEAR, day);
		return cal.getTime();
	}

	/**
	 * 两个时间之间相差距离多少天
	 *
	 * @param starttime 时间参数 1：
	 * @param endtime 时间参数 2：
	 * @return 相差天数
	 */
	public static long getDistanceDays(String starttime, String endtime) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Date one;
		Date two;
		long days = 0;
		try {
			one = df.parse(starttime);
			two = df.parse(endtime);
			long time1 = one.getTime();
			long time2 = two.getTime();
			long diff ;
			if (time1<time2) {
				diff = time2 - time1;
			} else {
				diff = time1 - time2;
			}
			days = diff / (1000 * 60 * 60 * 24);
		} catch (ParseException e) {
			logger.error("计算两个时间:{} - {} 的天数差距报错", starttime, endtime, e);
		}

		return days;//返回相差多少天
	}

	/**
	 * 两个时间相差距离多少天多少小时多少分多少秒
	 * @param starttime 时间参数 1 格式：1990-01-01 12:00:00
	 * @param endtime 时间参数 2 格式：2009-01-01 12:00:00
	 * @return long[] 返回值为：{天, 时, 分, 秒}
	 */
	public static long[] getDistanceTimes(String starttime, String endtime) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date one;
		Date two;
		long day = 0;
		long hour = 0;
		long min = 0;
		long sec = 0;
		try {
			one = df.parse(starttime);
			two = df.parse(endtime);
			long time1 = one.getTime();
			long time2 = two.getTime();
			long diff ;
			if (time1<time2) {
				diff = time2 - time1;
			} else {
				diff = time1 - time2;
			}
			day = diff / (24 * 60 * 60 * 1000);
			hour = (diff / (60 * 60 * 1000) - day * 24);
			min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
			sec = (diff/1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		} catch (ParseException e) {
			logger.error("计算两个时间:{} - {} 的天数差距报错", starttime, endtime, e);
			return null;
		}

		long[] times = {day, hour, min, sec};
		return times;
	}

	/**
	 * 注意时区的影响！！！
	 *
	 * @param ms
	 * @return
	 */
	public static Date fromMilliseconds(long ms) {
		if (ms <= 0L) {
			throw new RuntimeException("错误的参数");
		}

		return new Date(ms);
	}

	public static String formatDateTime(Date date) {
		return DateUtil.formatDateTime(date);
	}

	public static String formatDateTime(LocalTime localTime) {
		if (localTime == null) {
			return null;
		}

		Date date = localTime2Date(localTime);
		return DateUtil.formatDateTime(date);
	}

	public static String formatDateTime(LocalDateTime localDateTime) {
		if (localDateTime == null) {
			return null;
		}

		Date date = localDateTime2Date(localDateTime);
		return DateUtil.formatDateTime(date);
	}

	public static String formatDateTime(LocalDate localDate) {
		if (localDate == null) {
			return null;
		}

		Date date = localDate2Date(localDate);
		return DateUtil.formatDateTime(date);
	}

	public static TimeZone getLocalTimeZone() {
		// 香港是上海时区，该时区和北京时区没有时差
		// utc 标准时区比北京时区晚 8 个小时，就是说北京上午 8 点，UTC 0点
		Calendar ca = Calendar.getInstance();
		TimeZone tz = ca.getTimeZone();// 等效：TimeZone.getDefault();

		logger.info("当前时区:{}", tz.getID());

		return tz;
	}

	public static ZoneId getLocalZoneId() {
		return TimeZone.getDefault().toZoneId();
	}

	/**
	 * 返回美东时区 zone 对象
	 *
	 * @return
	 */
	public static ZoneId getMDZone() {
		return ZoneId.of("Etc/GMT+4");
		//return ZoneId.of("America/New_York");
	}

	/**
	 * 将参数 time 对应的时区时间认为是 fromZone 参数对应的时区时间，转成 toZone 时区对应的时间。
	 * 注意：如果原始时间 time 使用的时区和参数 fromZone 的不一致，则换算结果是不合预期的！！！！
	 *      例如：如果 time 是基于中欧标准时间（比北京时间晚 6 个小时）得到的值， fromZone 填写的是
	 *           北京时区， toZone 是美东时区，则得到的结果将比北京时间晚 18 个小时的时间，而非预期的
	 *           比中欧时间晚 6 个小时的时间（美东时区比北京时区晚 12 个小时）
	 *
	 * 常识：北京时区时间比 UTC 时间早 8 个小时，北京时区时间比中欧时区时间早 6 个小时，北京时区时间比美东时区时间早 12 个小时
	 *
	 * @param time
	 * @param fromZone
	 * @param toZone
	 * @return
	 */
	public static LocalDateTime convertZoneTime(final LocalDateTime time, final ZoneId fromZone, final ZoneId toZone) {
		final ZonedDateTime zonedtime = time.atZone(fromZone);
		final ZonedDateTime converted = zonedtime.withZoneSameInstant(toZone);
		return converted.toLocalDateTime();
	}

	/**
	 * 将当前时区的时间转换为指定时区的时间
	 *
	 * @param time
	 * @param toZone
	 * @return
	 */
	public static LocalDateTime convertZoneTime(final LocalDateTime time, final ZoneId toZone) {
		return convertZoneTime(time, ZoneId.systemDefault(), toZone);
	}

	/**
	 * 将指定时区的时间转换为 UTC 时间；
	 * 注意： time 对象对应的时区需要和参数 fromZone 的保持一致，否则结果会不如预期！！！！
	 *
	 * @param time
	 * @param fromZone
	 * @return
	 */
	public static LocalDateTime toUtc(final LocalDateTime time, final ZoneId fromZone) {
		return convertZoneTime(time, fromZone, ZoneOffset.UTC);
	}

	/**
	 * 将当前时区产生的时间转换为 UTC 时间
	 *
	 * @param time
	 * @return
	 */
	public static LocalDateTime toUtc(final LocalDateTime time) {
		return toUtc(time, ZoneId.systemDefault());
	}

	public static String standardTimeFormat(Date time) {
		return standardTimeFormat(time, null);
	}

	/**
	 * 提取当前系统时区所在的时间 time，对应于指定时区 fromZone 的时间字符串
	 *
	 * @param time
	 * @param fromZone
	 * @return
	 */
	public static String standardTimeFormat(Date time, ZoneId fromZone) {
		if (time == null) {
			return null;
		}
		if (fromZone == null) {
			fromZone = ZoneId.systemDefault();
		}

		SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATA_TIME_FORMAT);
		TimeZone formatTimeZone = TimeZone.getTimeZone(fromZone);
		formatter.setTimeZone(formatTimeZone);
		return formatter.format(time);
	}

	/**
	 * 基于指定时区，来解析传入的时间，返回的是当前系统时区的时间
	 *
	 * 注意：
	 *   本方法返回的是 --- 基于 fromZone 时区来解析字符串时间，返回基于同样的时间戳下，对应的当前系统时区时间；
	 *   务必清楚，此处返回的不是系统时区下减去时间偏移量后计算的 fromZone 时间值。
	 *
	 *   例如：如果传入的 timeStr = 2023-11-08 12:00:00，当前系统时区是 Etc/GMT-8，传入的 fromZone = Etc/GMT+4;
	 *   那么调用本方法返回的 date 对象使用当前系统时区的时间处理工具打印出来的值是： 2023-11-09 00:00:00
	 *
	 * @param timeStr
	 * @param fromZone
	 * @return
	 */
	public static Date parseWithTimeZone(String timeStr, ZoneId fromZone) {
		if (StrUtil.isBlank(timeStr)) {
			return null;
		}
		if (fromZone == null) {
			fromZone = ZoneId.systemDefault();
		}

		timeStr = normalize(timeStr);

		SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATA_TIME_FORMAT);
		TimeZone formatTimeZone = TimeZone.getTimeZone(fromZone);
		formatter.setTimeZone(formatTimeZone);
		try {
			return formatter.parse(timeStr);
		} catch (Exception e) {
			throw new RuntimeException("日期转换报错");
		}
	}

	/**
	 * 基于指定时区，来解析传入的时间，返回的是当前系统时区的时间
	 *
	 * @param time
	 * @param fromZone
	 * @return
	 */
	public static Date parseWithTimeZone(Date time, ZoneId fromZone) {
		LocalDateTime fromLocalTime = DateTimeTools.date2LocalDateTime(time);

		Instant instant = fromLocalTime.atZone(fromZone).toInstant();
		Date targetZoneDate = Date.from(instant);

		return targetZoneDate;
	}

	public static String normalize(String dateStr) {
		if (StrUtil.isBlank(dateStr)) {
			return StrUtil.str(dateStr);
		}

		// 日期时间分开处理
		final List<String> dateAndTime = StrUtil.splitTrim(dateStr, ' ');
		final int size = dateAndTime.size();
		if (size < 1 || size > 2) {
			// 非可被标准处理的格式
			return StrUtil.str(dateStr);
		}

		dateStr = dateStr.replace("T", " ");
		final StringBuilder builder = StrUtil.builder();

		// 日期部分（"\"、"/"、"."、"年"、"月"都替换为"-"）
		String datePart = dateAndTime.get(0).replaceAll("[/.年月]", "-");
		datePart = StrUtil.removeSuffix(datePart, "日");
		builder.append(datePart);

		// 时间部分
		if (size == 2) {
			builder.append(' ');
			String timePart = dateAndTime.get(1).replaceAll("[时分秒]", ":");
			timePart = StrUtil.removeSuffix(timePart, ":");
			//将ISO8601中的逗号替换为.
			timePart = timePart.replace(',', '.');
			builder.append(timePart);
		}

		return builder.toString();
	}

//	/**
//	 * 将当前时区时间转换成 UTC 时区时间
//	 * 注意：此处 Date 对象对应的时区都是系统默认时区
//	 *
//	 * @param time
//	 * @return
//	 */
//	public static Date toUtc(Date time) {
//		if (time == null) {
//			return null;
//		}
//
//		String localTimeZoneId = TimeZone.getDefault().getID();
//		long timeDiff = timeZoneDiffMap.get(localTimeZoneId);
//		return (new Date(time.getTime() - timeDiff * 1000L));
//	}
//
//	public static Date toUtc(Date time, ZoneId fromZone) {
//		if (time == null) {
//			return null;
//		}
//		if (fromZone == null) {
//			fromZone = ZoneId.systemDefault();
//		}
//
//		// 提取指定时区和 UTC 的时差
//		long timeDiff = timeZoneDiffMap.get(fromZone.getId());
//		// 对应时区的时间毫秒值减去时差，就是 UTC 时间
//		return (new Date(time.getTime() - timeDiff * 1000L));
//	}
//
//	/**
//	 *
//	 * @Description: 基于零时区位置的展示时间，计算本地时间；
//	 *               注意：基于返回值算出的时间毫秒值，算是标准时间毫秒值
//	 *
//	 * @time 2020年7月31日 下午9:38:08
//	 * @author daydayup
//	 * @param utcTime
//	 * @return
//	 * Date
//	 * @throws
//	 */
//	public static Date fromUtc(Date utcTime) {
//		if (utcTime == null) {
//			return null;
//		}
//
//		String localTimeZoneId = TimeZone.getDefault().getID();
//		long timeDiff = timeZoneDiffMap.get(localTimeZoneId);
//		return (new Date(utcTime.getTime() + timeDiff * 1000L));
//	}
//
//	public static Date fromUtc(Date utcTime, ZoneId toZone) {
//		if (utcTime == null) {
//			return null;
//		}
//		if (toZone == null) {
//			toZone = ZoneId.systemDefault();
//		}
//
//		long timeDiff = timeZoneDiffMap.get(toZone.getId());
//		return (new Date(utcTime.getTime() + timeDiff * 1000L));
//	}

	/**
	 * 基于当前系统时区指定的时间，计算目标时区的时间
	 *
	 * @param fromTime : 系统时区的时间
	 * @param targetZone : 转换成目标时区
	 * @return
	 */
	public static Date convertZoneTime(Date fromTime, ZoneId targetZone) {
		return convertZoneTime(fromTime, ZoneId.systemDefault(), targetZone);
	}

	public static Date convertZoneTime(long fromTime, ZoneId targetZone) {
		if (fromTime <= 0) {
			return null;
		}
		String checkTimeStr = String.valueOf(fromTime);
		if (checkTimeStr.startsWith("1")) {
			if (checkTimeStr.length() == 10) {
				// 1000000000（秒） 对应 2001-09-09 09:46:40，识别为基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
			}
		} else {
			// 首位数大于 1，要么是 9几年的秒时间，要么是 9 几年的毫秒时间，基于秒的有 9 位数
			if (checkTimeStr.length() <= 9) {
				// 基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
			}
		}

		fromTime = Long.parseLong(checkTimeStr);
		Date dateTime = new Date(fromTime);

		return convertZoneTime(dateTime, targetZone);
	}

	/**
	 * 基于时区 fromZone 的时间 timeStr 解析成时区 toZone 的时间
	 * 注意：返回的是基于 toZone 时区的字面时间，不是系统时区的时间
	 *
	 * @param timeStr
	 * @param fromZone
	 * @param toZone
	 * @return
	 */
	public static Date convertZoneTime(String timeStr, ZoneId fromZone, ZoneId toZone) {
		// 注意：返回的 oriTime 是系统时区的时间值
		Date oriTime = parseWithTimeZone(timeStr, fromZone);

		// 注意写法！
		return convertZoneTime(oriTime, ZoneId.systemDefault(), toZone);
	}

	/**
	 * 基于时区 fromZone 的时间 time 解析成时区 toZone 的时间
	 *
	 * @param time
	 * @param fromZone
	 * @param toZone
	 * @return
	 */
	public static Date convertZoneTime(Date time, ZoneId fromZone, ZoneId toZone) {
		if (time == null) {
			return null;
		}

		// toZone 时区相对于 fromZone 时区的时间偏移
		long timeDiff = getTimeOffset(fromZone, toZone);
		return (new Date(time.getTime() + timeDiff));
	}

	/**
	 * 将系统时区时间转换为对外展示配置的时区时间
	 *
	 * @param localZoneTime
	 * @return
	 */
	public static Date transferToShowTime(Date localZoneTime) {
		if (localZoneTime == null) {
			return null;
		}

		String outPutTimeZoneId = TimeZoneContext.showTimeZoneId.get();
		if (StrUtil.isBlank(outPutTimeZoneId)) {
			throw new RuntimeException("错误的使用方式");
		}

		Date retDate = convertZoneTime(localZoneTime, ZoneId.of(outPutTimeZoneId));
		return retDate;
	}

	/**
	 * 具体业务中使用的方法
	 *
	 * @param fromTime
	 * @return
	 */
	public static Date transferToShowTime(Long fromTime) {
		if (fromTime == null || fromTime <= 0) {
			return null;
		}
		String checkTimeStr = String.valueOf(fromTime);
		if (checkTimeStr.startsWith("1")) {
			if (checkTimeStr.length() == 10) {
				// 1000000000（秒） 对应 2001-09-09 09:46:40，识别为基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
			}
		} else {
			// 首位数大于 1，要么是 9几年的秒时间，要么是 9 几年的毫秒时间，基于秒的有 9 位数
			if (checkTimeStr.length() <= 9) {
				// 基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
			}
		}

		fromTime = Long.parseLong(checkTimeStr);
		Date dateTime = new Date(fromTime);

		return transferToShowTime(dateTime);
	}

	/**
	 * 注意：本方法用于将当前系统时区时间戳，参考预期的展示时间，转换为客户端时区能正确解析的时间戳。
	 * 此处涉及多个时区偏移换算问题，其他业务在不清楚本方法功能时不要随意使用！！！
	 * 本方法目前专用于将业务 API 返回给前端的时间戳值做加工，返回给前端解析时间。
	 *
	 * @param localTimestamp
	 * @return
	 */
	public static long transferShowTimeToClientTime(Long localTimestamp) {
		if (localTimestamp == null || localTimestamp <= 0) {
			return 0L;
		}

		// 时间戳类型： 1-毫秒时间戳， 2-秒时间戳
		int timestampType = 1;
		String checkTimeStr = String.valueOf(localTimestamp);
		if (checkTimeStr.startsWith("1")) {
			if (checkTimeStr.length() == 10) {
				// 1000000000（秒） 对应 2001-09-09 09:46:40，识别为基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
				timestampType = 2;
			}
		} else {
			// 首位数大于 1，要么是 9几年的秒时间，要么是 9 几年的毫秒时间，基于秒的有 9 位数
			if (checkTimeStr.length() <= 9) {
				// 基于秒的时间戳
				checkTimeStr = checkTimeStr + "000";
				timestampType = 2;
			}
		}

		localTimestamp = Long.parseLong(checkTimeStr);

		String showTimeZoneId = TimeZoneContext.showTimeZoneId.get();
		if (StrUtil.isBlank(showTimeZoneId)) {
			throw new RuntimeException("错误的使用方式");
		}
		String clientTimeZoneId = TimeZoneContext.clientTimeZoneId.get();
		if (StrUtil.isBlank(clientTimeZoneId)) {
			throw new RuntimeException("错误的使用方式");
		}

		long timeOffset = getTimeOffset(ZoneId.of(clientTimeZoneId), ZoneId.of(showTimeZoneId));
		//logger.info("----------------> DateTimeTools.transferShowTimeToClientTime 传入时间戳:{}, showTimeZoneId:{}, clientTimeZoneId:{}, timeOffset:{}",
		//		localTimestamp, showTimeZoneId, clientTimeZoneId, timeOffset);

		long retTimestamp = localTimestamp + timeOffset;
		if (timestampType == 1) {
			// 以毫秒入，以毫秒出
			return retTimestamp;
		} else if (timestampType == 2) {
			// 以秒入，以秒出
			return retTimestamp / 1000L;
		}

		// TODO
		return retTimestamp;
	}

	/**
	 * 将基于 fromZone 时区的时间值 inputTime，转换为对应的系统时间
	 *
	 * @param inputTime : 请求参数传入的字符串时间值
	 * @param timeFormat : 时间格式
	 * @param inputTimeZone : 参数时间使用的时区，如果未指定时区，则从当前线程上下文中自动提取时区
	 * @return
	 */
	public static Date readQueryTime(String inputTime, String timeFormat, ZoneId inputTimeZone) {
		if (StrUtil.isBlank(inputTime)) {
			return null;
		}

		if (inputTimeZone == null) {
			String inPutTimeZoneId = TimeZoneContext.showTimeZoneId.get();
			if (StrUtil.isBlank(inPutTimeZoneId)) {
				throw new RuntimeException("不能识别当前时间所属的时区，无法解析");
			}

			inputTimeZone = ZoneId.of(inPutTimeZoneId);
		}

		return convertZoneTime(inputTime, inputTimeZone, ZoneId.systemDefault());
	}

	/**
	 * 计算指定时区当前时间到 UTC 时间的时差，返回单位为毫秒
	 * 当值大于 0，代表当前时区更早，例如当前时区已经 12 点了，utc 时区才 11 点。
	 *
	 * 参考资料：
	 *     https://qa.1r1g.com/sf/ask/1105223941/
	 *
	 * @return
	 */
	public static long getTimeOffset(ZoneId zoneId) {
		LocalDateTime refNow = LocalDateTime.now();
		ZoneId refZoneId = ZoneId.of("Z");
		ZonedDateTime refTime = refNow.atZone(refZoneId);

		ZonedDateTime curZoneTime = refNow.atZone(zoneId);
		Duration diff = Duration.between(curZoneTime, refTime);
		return diff.toMillis();
	}

	/**
	 * 计算 targetZone 时区时间偏移量比 sourceZone 时区时间偏移量大的值
	 *
	 * @param sourceZone
	 * @param targetZone
	 * @return
	 */
	public static long getTimeOffset(ZoneId sourceZone, ZoneId targetZone) {
		LocalDateTime refNow = LocalDateTime.now();
		ZonedDateTime refTime = refNow.atZone(sourceZone);

		ZonedDateTime targetZoneTime = refNow.atZone(targetZone);
		Duration diff = Duration.between(targetZoneTime, refTime);
		return diff.toMillis();
	}

	public static void main(String[] args) {
		TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.of("GMT-4")));
		long now = System.currentTimeMillis();
		TimeZoneContext.showTimeZoneId.set("GMT+4");
		TimeZoneContext.clientTimeZoneId.set("GMT+3");

		long retNow = transferShowTimeToClientTime(now / 1000L);
		System.out.println("----> now:" + now + ", retNow:" + retNow);
	}

	/**
	 * 时区资料：
	 * https://zhuanlan.zhihu.com/p/538934548
	 * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
	 *
	 * @param args
	 */
	public static void main2(String[] args) {
//		for (String oneZone : TimeZone.getAvailableIDs()) {
//			System.out.println("-----> oneZone:" + oneZone);
//		}
		//TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.of("GMT+4")));
		System.out.println("-----> defaultTimeZone:" + ZoneId.systemDefault());

		Date now = new Date();
		// 展示 GMT-4 时区当前时间
		TimeZoneContext.showTimeZoneId.set("GMT-4");
		Date showTime = transferToShowTime(now);

		Date innerTime = readQueryTime("2023-11-08 12:00:00", "yyyy-MM-dd HH:mm:ss", ZoneId.of("GMT-3"));
		System.out.println("-----> now:" + DateUtil.formatDateTime(now) + ", showTime:" + DateUtil.formatDateTime(showTime) + ", innerTime:" + DateUtil.formatDateTime(innerTime));

		// 注意： atZone 的用途是，将系统时区所在的时刻，应用到目标时区来解释，同时返回的时间是系统时区的时间。
		// 而不是误以为的：将系统时区对应的时间，换算成目标时区的时间，并将这个目标时区的时间换算成系统时区的时间
		LocalDateTime localNow = LocalDateTime.now();
		Instant convertInstant = localNow.atZone(ZoneId.of("GMT-4")).toInstant();
		Date convertDateTime = Date.from(convertInstant);
		System.out.println("-----> convertDateTime:" + DateUtil.formatDateTime(convertDateTime));

		String timeStr = "2023-11-08 12:00:00";
		Date strTime1 = parseWithTimeZone(timeStr, ZoneId.of("Etc/GMT+4")); // 返回： 2023-11-09 00:00:00
		Date strTime2 = parseWithTimeZone(timeStr, ZoneId.of("Etc/GMT-8")); // 返回： 2023-11-08 12:00:00
		System.out.println("-----> strTime1:" + DateUtil.formatDateTime(strTime1) + ", strTime2:" + DateUtil.formatDateTime(strTime2));

		// 符合预期
		Date convertTime1 = convertZoneTime(timeStr, ZoneId.of("Etc/GMT+4"), ZoneId.of("Etc/GMT+5"));
		System.out.println("-------> convertTime1: " + DateUtil.formatDateTime(convertTime1));

		// 符合预期
		long offset1 = getTimeOffset(ZoneId.of("GMT+0800"));
		long offset2 = getTimeOffset(ZoneId.of("Z"));
		long offset3 = getTimeOffset(ZoneId.of("GMT+0800"), ZoneId.of("GMT+7"));
		System.out.println("------> offset1:" + offset1 + ", offset2:" + offset2 + ", offset3:" + offset3);

		Date localNowTime = new Date();
		TimeZone tz1 = TimeZone.getTimeZone("GMT+0500");// Etc/GMT+4  America/New_York （北京时间比纽约时间早 13 个小时）
		SimpleDateFormat timeZoneDateFormat1 = new SimpleDateFormat(DEFAULT_DATA_TIME_FORMAT);
		timeZoneDateFormat1.setTimeZone(tz1);

		TimeZone tz2 = TimeZone.getTimeZone("GMT+4:00");// Etc/GMT+4  America/New_York （北京时间比纽约时间早 13 个小时）
		SimpleDateFormat timeZoneDateFormat2 = new SimpleDateFormat(DEFAULT_DATA_TIME_FORMAT);
		timeZoneDateFormat2.setTimeZone(tz2);
        // 符合预期
		System.out.println("------> tz1.time:" + timeZoneDateFormat1.format(localNowTime) + ", tz2.time:" + timeZoneDateFormat2.format(localNowTime));

//		try {
//			Date time = timeZoneDateFormat1.parse(normalize(timeStr));
//			String targetTime = timeZoneDateFormat1.format(localNowTime);
//			System.out.println("-----> localTime1:" + DateUtil.formatDateTime(time) +
//					", localTime2:" + timeZoneDateFormat1.format(time) + ", targetTime:" + targetTime);
//		} catch (Exception e) {
//			throw new RuntimeException("日期转换报错");
//		}

		// now1 是北京时区的时间值
		LocalDateTime now1 = LocalDateTime.now();
		long now1time = System.currentTimeMillis();
		// 现在是北京时间 2023-11-06 22:00:00， 已经是 Etc/GMT 时区上偏离 0 时区的 -8 得到的时间，下面将获取此时 +4 时区的时间（相对于当前时区的时间），
		// 这代表 +4 时区上此时已经是当前北京时间 12 个小时后的时间了，这既是目标时区的当时时间（例如北京地方 12点，目标地方已经夜里 24点），也可理解为当前
		// 时区的一个未来时间
		ZoneId zoneId = ZoneId.of("Etc/GMT+4"); // 北京时区是： Etc/GMT-8

		// 计算当前在 ETC/GMT+4 时区的时间
		Instant instant = now1.atZone(zoneId).toInstant();
		Date date1 = Date.from(instant);
		long now2time = date1.getTime();
		// 以下显示：无论是从时间字符串打印来看，还是时间戳差值来看，都是 12 个小时后的时间
		System.out.println("-----> now1 at Etc/GMT+4 : " + DateUtil.formatDateTime(date1) + ", offset: " + (now2time - now1time));

		// 符合预期
		Date now2 = new Date();
		Date date2 = convertZoneTime(now2, ZoneId.of("Etc/GMT-8"), ZoneId.of("Etc/GMT+4"));
		System.out.println("-----> now2 at Etc/GMT+4 : " + DateUtil.formatDateTime(date2) + ", offset: " + (date2.getTime() - now2.getTime()));

		// 符合预期
		Date now22 = new Date();
		Date date22 = convertZoneTime(now22, ZoneId.of("GMT+3"), ZoneId.of("GMT+4"));
		System.out.println("-----> now22 at GMT+4 : " + DateUtil.formatDateTime(date22));

		// 符合预期
		long timeoffset1 = getTimeOffset(ZoneId.of("Etc/GMT-8"));
		long timeoffset2 = getTimeOffset(ZoneId.of("Etc/GMT+4"));
		System.out.println("------> timeoffset1:" + timeoffset1 + ", timeoffset2:" + timeoffset2);

		// 符合预期
		Date now3 = new Date();
		Date date3 = convertZoneTime(now3, ZoneId.of("Etc/GMT+4"));
		System.out.println("-----> now3 at Etc/GMT+4 : " + DateUtil.formatDateTime(date3) + ", offset: " + (date3.getTime() - now3.getTime()));

		// Etc/GMT+4 地方所在的 date3 时刻，也是当前时区 Etc/GMT-8 的一个未来时间(但是是一个虚拟的 Etc/GMT+4 地方的时间)
		// Etc/GMT+4 时区的当前时间，转换为 Etc/GMT-8 时区的时间，是要在此基础上加 12 个小时，符合预期
		Date now4 = new Date();
		Date date4 = convertZoneTime(now3, ZoneId.of("Etc/GMT+4"), ZoneId.of("Etc/GMT-8"));
		System.out.println("-----> date4 at Etc/GMT-8 : " + DateUtil.formatDateTime(date4) + ", offset: " + (now4.getTime() - date4.getTime()));

		// 符合预期
		Date date5 = convertZoneTime("2023-11-08 12:00:00", ZoneId.of("GMT+8"), ZoneId.of("GMT-4"));
		System.out.println("-----> date5 at GMT-4 : " + DateUtil.formatDateTime(date5));

		// 符合预期
		Date localNowTime2 = new Date();
		String date61 = standardTimeFormat(localNowTime2, ZoneId.of("GMT+8"));
		String date62 = standardTimeFormat(localNowTime2, ZoneId.of("GMT-4"));
		System.out.println("-----> date61 : " + date61 + ", date62:" + date62);


//		for (int i = 0; i < 200; i++) {
//			Date now = new Date();
//			LocalDateTime locatTime = date2LocalDateTime (now);
//			if (now.getTime() != DateTimeTools.localDateTime2Date(locatTime).getTime()) {
//				System.out.println("----------------> 时间转换有差距, now:" + DateUtil.formatDateTime(now));
//			}
//
//			try {
//				Thread.sleep(500L);
//			} catch (Exception e) {
//				e.printStackTrace();
//			}
//		}
	}

	private static void testTimeZoneOffset() {
		// 问题：随着时间的不同，通过以下方式计算时差不是一个固定值，目前看来有时是 4 个小时，有时是 5 个小时！！！！
//		String refTimeStr = "2022-09-15 01:38:01"; // 字面时间
		String refTimeStr = "2000-01-02 01:00:00"; // 字面时间
		SimpleDateFormat refSDF1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		SimpleDateFormat refSDF2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		refSDF1.setTimeZone(utcZone);
		refSDF2.setTimeZone(TimeZone.getTimeZone("America/New_York"));

		try {
			Date utcTime = refSDF1.parse(refTimeStr);
			Date mdTime = refSDF2.parse(refTimeStr);
			logger.info("utcTime时分秒:{}-{}-{} {}:{}, mdTime时分秒:{}-{}-{} {}:{}", utcTime.getYear(), utcTime.getMonth(), utcTime.getDay(), utcTime.getHours(), utcTime.getMinutes(), mdTime.getYear(), mdTime.getMonth(), mdTime.getDay(), mdTime.getHours(), mdTime.getMinutes());
			logger.info("utcTime:{}, mdTime:{}, 时差:{} 个小时", DateUtil.formatDateTime(utcTime), DateUtil.formatDateTime(mdTime), (mdTime.getTime() - utcTime.getTime())/3600000L);
		} catch (ParseException e) {
			logger.error("[DateTimeUtils static] 初始化时区信息报错:", e);
		}
	}
}