package com.wd.foundation.bean.utils;

import android.annotation.SuppressLint;
import android.os.SystemClock;
import android.text.TextUtils;


import com.wd.foundation.bean.R;
import com.wd.foundation.wdkitcore.tools.HostUtil;
import com.wd.foundation.wdkitcore.tools.ResUtils;
import com.wd.foundation.wdkitcore.tools.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;

/**
 * 时间转换的工具类
 *
 * @author wangqingxu
 * @data 2021/102/27.
 */
@SuppressWarnings("all")
public class TimeUtil {
    public static final String YEAR = "年";

    public static final String HOUR = "时";

    public static final String MIN = "分";

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

    private static final SimpleDateFormat datetimeFormatEllip = new SimpleDateFormat("yyyy/MM/dd");

    public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private static final SimpleDateFormat datetimeFormat2 = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");

    public static final SimpleDateFormat datetimeFormat3 = new SimpleDateFormat("yyyy-MM-dd HH:mm");

    public static final SimpleDateFormat datetimeFormat4 = new SimpleDateFormat("MM-dd HH:mm");

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

    private static final SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy.MM.dd");

    private static final SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");


    public static final SimpleDateFormat dateFormat3 = new SimpleDateFormat("MM月dd日 HH:mm");


//    private static final SimpleDateFormat dateFormat4 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");

    private static final SimpleDateFormat dateFormat5 = new SimpleDateFormat("yyyy年 MM月dd日");

    public static final SimpleDateFormat dateFormat6 = new SimpleDateFormat("HH:mm");

    public static final SimpleDateFormat dateFormat7 = new SimpleDateFormat("M月dd日 HH:mm");

    private static final SimpleDateFormat dateFormat8 = new SimpleDateFormat("yyyy年 MM月dd日 HH:mm");

    private static final SimpleDateFormat dateFormat9 = new SimpleDateFormat("yyyy.MM.dd");

    private static final SimpleDateFormat dateFormat10 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm");

    private static final SimpleDateFormat dateFormat11 = new SimpleDateFormat("yyyy年 M月d日");

    private static final SimpleDateFormat dateFormat12 = new SimpleDateFormat("yyyy年M月d日 HH:mm");

    public static final int YESTERDY = -1;

    public static final int TODAY = 0;

    public static final int TOMORROWDAT = 1;

    public static final int OTHER_DAY = 10000;


    private static long VALUE_MINUTE = 60 * 1000;

    private static long VALUE_HOUR = 60 * 60 * 1000;

    private static long VALUE_DAY = 24 * 60 * 60 * 1000;
    /**
     * 英文月份
     */
    private static final String[] enMonthArray = new String[]{ResUtils.getString(R.string.jan), ResUtils.getString(R.string.feb),
            ResUtils.getString(R.string.mar), ResUtils.getString(R.string.apr), ResUtils.getString(R.string.may), ResUtils.getString(R.string.jun),
            ResUtils.getString(R.string.jul), ResUtils.getString(R.string.aug), ResUtils.getString(R.string.sept),
            ResUtils.getString(R.string.oct), ResUtils.getString(R.string.nov), ResUtils.getString(R.string.dec)};

    /**
     * 中文月份全拼
     */
    private static final String[] enMonthAllArray = new String[]{ResUtils.getString(R.string.january), ResUtils.getString(R.string.february),
            ResUtils.getString(R.string.march), ResUtils.getString(R.string.april), ResUtils.getString(R.string.mayMonth), ResUtils.getString(R.string.june),
            ResUtils.getString(R.string.july), ResUtils.getString(R.string.august), ResUtils.getString(R.string.september),
            ResUtils.getString(R.string.october), ResUtils.getString(R.string.november), ResUtils.getString(R.string.december)};

    /**
     * 中文星期
     * 从星期日开始
     */
    private static final String[] weekArray = new String[]{"星期日", "星期一", "星期二", "星期三",
            "星期四", "星期五", "星期六"};

    /**
     * 格式化时间 HH:MM:SS 或者 MM:SS
     *
     * @param timeMs
     * @return
     */
    public static String time2String(long timeMs) {
        return time2String(timeMs, true);
    }

    /**
     * 格式化时间 HH:MM:SS 或者 MM:SS
     *
     * @param timeMs
     * @return
     */
    public static String time2String(long timeMs, boolean auto) {

        long totalSeconds = timeMs / 1000;
        if (totalSeconds <= 0) {
            return "00:00";
        }

        long seconds = totalSeconds % 60;
        long minutes = (totalSeconds / 60) % 60;
        long hours = totalSeconds / 3600;
        if (auto) {
            if (hours > 0) {
                return String.format("%d:%02d:%02d", hours, minutes, seconds);
            } else {
                return String.format("%02d:%02d", minutes, seconds);
            }
        } else {
            return String.format("%d:%02d:%02d", hours, minutes, seconds);
        }
    }

    /**
     * 格式化时间 HH:MM:SS 或者 MM:SS
     *
     * @param timeMs
     * @return
     */
    public static String time2StringLive(long timeMs) {

        long totalSeconds = timeMs / 1000;
        if (totalSeconds <= 0) {
            return "共0分钟0秒";
        }

        long seconds = totalSeconds % 60;
        long minutes = (totalSeconds / 60) % 60;
        long hours = totalSeconds / 3600;

        if (hours > 0) {
            return "共" + hours + "小时" + minutes + "分钟" + seconds + "秒";
        } else {
            return "共" + minutes + "分钟" + seconds + "秒";
        }
    }

    /**
     * 返回当前时间，格式：yyyy-MM-dd 例：2020-06-03
     */
    public static String getCurrentDate() {
        return dateFormat.format(new Date());
    }

    /**
     * 返回当前时间，格式：yyyyMMdd 例：20200603
     */
    public static String getCurrentDateFormat() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHH");
        return simpleDateFormat.format(new Date());
    }

    /**
     * 格式化时间 HH:MM:SS 或者 MM:SS
     *
     * @param timeMs
     * @return
     */
    public static String time2String(String format, long timeMs) {
        return new SimpleDateFormat(format).format(timeMs);
    }

    /**
     * MM月dd日 HH:mm
     *
     * @param timeMs
     * @return
     */
    public static String long2String(long timeMs) {
        SimpleDateFormat sdf = new SimpleDateFormat("MM月dd日 HH:mm");
        return sdf.format(new Date(timeMs));
    }


    public static Date str2Date(String str) {
        return str2Date(str, "");
    }

    /**
     * 字符串转时间
     *
     * @param str
     * @param format
     * @return
     */
    public static Date str2Date(String str, String format) {
        if (str == null || str.length() == 0) {
            return null;
        }
        if (format == null || format.length() == 0) {
            format = FORMAT_DEFAULT;
        }
        Date date = null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            date = sdf.parse(str);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;

    }

    /**
     * 字符串转时间
     *
     * @param str
     * @param format
     * @return
     */
    public static Date str2Date(String str, SimpleDateFormat sdf) {
        if (str == null || str.length() == 0) {
            return null;
        }
        if (sdf == null) {
            return null;
        }
        Date date = null;
        try {
            date = sdf.parse(str);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;

    }

    public static Calendar str2Calendar(String str) {
        return str2Calendar(str, null);

    }

    public static Calendar str2Calendar(String str, String format) {
        Date date = str2Date(str, format);
        if (date == null) {
            return null;
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);

        return c;

    }

    public static String date2Str(Calendar c) {// yyyy-MM-dd HH:mm:ss
        return date2Str(c, null);
    }

    public static String date2Str(Calendar c, String format) {
        if (c == null) {
            return null;
        }
        return date2Str(c.getTime(), format);
    }

    public static String date2Str(Date d) {// yyyy-MM-dd HH:mm:ss
        return date2Str(d, "");
    }

    public static String date2Str(Date d, String format) {// yyyy-MM-dd HH:mm:ss
        if (d == null) {
            return null;
        }
        if (format == null || format.length() == 0) {
            format = FORMAT_DEFAULT;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(d);
        return s;
    }

    public static String date2Str(Date d, SimpleDateFormat sdf) {// yyyy-MM-dd HH:mm:ss
        if (d == null) {
            return null;
        }
        String s = sdf.format(d);
        return s;
    }


    /**
     * 获得当前日期的字符串格式
     *
     * @param format
     * @return
     */
    public static String getCurDateStr(String format) {
        Calendar c = Calendar.getInstance();
        return date2Str(c, format);
    }

    /**
     * 格式到秒
     *
     * @param time
     * @return
     */
    public static String getMillon(long time) {
        return new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(time);

    }

    /**
     * 格式到天
     *
     * @param time
     * @return
     */
    public static String getDay(long time) {
        return new SimpleDateFormat("yyyy-MM-dd").format(time);

    }

    /**
     * 格式到毫秒
     *
     * @param time
     * @return
     */
    public static String getSMillon(long time) {
        return new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS").format(time);

    }

    /**
     * 格式到毫秒
     *
     * @param time
     * @return
     */
    public static String getYYYYMillon(long time) {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time);

    }

    /**
     * 格式到毫秒
     *
     * @param time
     * @return
     */
    public static String getSMillonKF(long time) {
        return new SimpleDateFormat("MMddHHmmssSSS").format(time);

    }

    /**
     * 字符串转换到时间格式
     *
     * @param dateStr   需要转换的字符串
     * @param formatStr 需要格式的目标字符串 举例 yyyy-MM-dd
     * @return Date 返回转换后的时间
     * @throws ParseException 转换异常
     */
    public static Date StringToDate(String dateStr, String formatStr) {
        DateFormat sdf = new SimpleDateFormat(formatStr);
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }


    /**
     * 把字符串转化为时间格式
     *
     * @param timestamp
     * @return
     */
    public static String getStandardTime(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat("MM月dd日");
        Date date = new Date(timestamp);
        sdf.format(date);
        return sdf.format(date);
    }

    /**
     * 把字符串转化为月
     *
     * @param timestamp
     * @return
     */
    public static String getMM(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat("MM");
        Date date = new Date(timestamp);
        sdf.format(date);
        return sdf.format(date);
    }

    /**
     * 把字符串转化为时间
     *
     * @param timestamp
     * @return
     */
    public static String getHH(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
        Date date = new Date(timestamp);
        sdf.format(date);
        return sdf.format(date);
    }

    /**
     * 把字符串转化为时间
     *
     * @param timestamp
     * @return
     */
    public static String getDD(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat("dd");
        Date date = new Date(timestamp);
        sdf.format(date);
        return sdf.format(date);
    }

    /**
     * 英文版
     *
     * @param timestamp
     * @return
     */
    public static String getExactlyStandardTime(long timestamp) {

        Date date = new Date(timestamp);
        Calendar c = Calendar.getInstance();
        c.setTime(date);

        int month = c.get(Calendar.MONTH);
        String monthEnglish = enMonthArray[month];
        int day = c.get(Calendar.DAY_OF_MONTH);
        int year = c.get(Calendar.YEAR);

        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
        String time = sdf.format(date);

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(time);
        stringBuffer.append("\t,\t");
        stringBuffer.append(monthEnglish);
        stringBuffer.append("  ");
        stringBuffer.append(day);
        stringBuffer.append("  ");
        stringBuffer.append(year);
        return stringBuffer.toString();
    }

    /**
     * 获得当前日期时间 日期时间格式yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String currentDatetime() {
        return datetimeFormat.format(now());
    }

    /**
     * 获得当前日期时间
     *
     * @param simpleDateFormat 时间格式
     * @return 时间
     */
    public static String currentDatetime(SimpleDateFormat simpleDateFormat) {
        return simpleDateFormat.format(now());
    }

    /**
     * 格式化日期时间 日期时间格式yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String formatDatetime(Date date) {
        return datetimeFormat.format(date);
    }

    /**
     * 获得当前时间 时间格式HH:mm:ss
     *
     * @return
     */
    public static String currentTime() {
        return timeFormat.format(now());
    }

    /**
     * 格式化时间 时间格式HH:mm:ss
     *
     * @return
     */
    public static String formatTime(Date date) {
        return timeFormat.format(date);
    }

    /**
     * 获得当前时间的<code>java.util.Date</code>对象
     *
     * @return
     */
    public static Date now() {
        return new Date();
    }

    public static Calendar calendar() {
        Calendar cal = GregorianCalendar.getInstance(Locale.CHINESE);
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        return cal;
    }

    public static String getCurDateStr() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        return c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DAY_OF_MONTH) + "-"
                + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND);
    }

    /**
     * 获取年份
     *
     * @return
     */
    public static String getYear() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        return c.get(Calendar.YEAR) + "";
    }

    /**
     * 获取月份xx
     *
     * @return
     */
    public static String getNumMonth() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        int month = c.get(Calendar.MONTH);
        return enMonthArray[month];

    }

    /**
     * 获取中文月份全拼
     *
     * @return
     */
    public static String getMonthAll() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        int month = c.get(Calendar.MONTH);
        return enMonthAllArray[month];

    }

    /**
     * 获取今天多少号
     *
     * @return
     */
    public static String getDay() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        return c.get(Calendar.DAY_OF_MONTH) + "";
    }

    /**
     * 获取星期几
     *
     * @return
     */
    public static String getWeekStr() {
        try {
            Calendar c = Calendar.getInstance();
            c.setTime(new Date());
            int day = c.get(Calendar.DAY_OF_WEEK);
            return weekArray[day - 1];
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获取星期几
     *
     * @return
     */
    public static String getWeekStr(Calendar c) {
        try {
            int day = c.get(Calendar.DAY_OF_WEEK);
            return weekArray[day - 1];
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获得当前时间的毫秒数
     * <p>
     * 详见{@link System#currentTimeMillis()}
     *
     * @return
     */
    public static long millis() {
        return System.currentTimeMillis();
    }

    /**
     * 获取年份
     *
     * @return
     */
    public static int year() {
        return calendar().get(Calendar.YEAR);
    }

    /**
     * 获得当前Chinese月份
     *
     * @return
     */
    public static int month() {
        return calendar().get(Calendar.MONTH) + 1;
    }

    /**
     * 获得月份中的第几天
     *
     * @return
     */
    public static int dayOfMonth() {
        return calendar().get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 今天是星期的第几天
     *
     * @return
     */
    public static int dayOfWeek() {
        return calendar().get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 今天是年中的第几天
     *
     * @return
     */
    public static int dayOfYear() {
        return calendar().get(Calendar.DAY_OF_YEAR);
    }

    /**
     * 判断原日期是否在目标日期之前
     *
     * @param src
     * @param dst
     * @return
     */
    public static boolean isBefore(Date src, Date dst) {
        return src.before(dst);
    }

    /**
     * 判断原日期是否在目标日期之后
     *
     * @param src
     * @param dst
     * @return
     */
    public static boolean isAfter(Date src, Date dst) {
        return src.after(dst);
    }

    /**
     * 判断两日期是否相同
     *
     * @param date1
     * @param date2
     * @return
     */
    public static boolean isEqual(Date date1, Date date2) {
        return date1.compareTo(date2) == 0;
    }

    /**
     * 判断某个日期是否在某个日期范围
     *
     * @param beginDate 日期范围开始
     * @param endDate   日期范围结束
     * @param src       需要判断的日期
     * @return
     */
    public static boolean between(Date beginDate, Date endDate, Date src) {
        return beginDate.before(src) && endDate.after(src);
    }

    /**
     * 获得当前月的最后一天
     * <p>
     * HH:mm:ss为0，毫秒为999
     *
     * @return
     */
    public static Date lastDayOfMonth() {
        Calendar cal = calendar();
        cal.set(Calendar.DAY_OF_MONTH, 0); // M月置零
        cal.set(Calendar.HOUR_OF_DAY, 0);// H置零
        cal.set(Calendar.MINUTE, 0);// m置零
        cal.set(Calendar.SECOND, 0);// s置零
        cal.set(Calendar.MILLISECOND, 0);// S置零
        cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);// 月份+1
        cal.set(Calendar.MILLISECOND, -1);// 毫秒-1
        return cal.getTime();
    }

    /**
     * 获得当前月的第一天
     * <p>
     * HH:mm:ss SS为零
     *
     * @return
     */
    public static Date firstDayOfMonth() {
        Calendar cal = calendar();
        cal.set(Calendar.DAY_OF_MONTH, 1); // M月置1
        cal.set(Calendar.HOUR_OF_DAY, 0);// H置零
        cal.set(Calendar.MINUTE, 0);// m置零
        cal.set(Calendar.SECOND, 0);// s置零
        cal.set(Calendar.MILLISECOND, 0);// S置零
        return cal.getTime();
    }

    private static Date weekDay(int week) {
        Calendar cal = calendar();
        cal.set(Calendar.DAY_OF_WEEK, week);
        return cal.getTime();
    }

    /**
     * 获得周五日期
     * <p>
     * 注：日历工厂方法{@link #calendar()}设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     *
     * @return
     */
    public static Date friday() {
        return weekDay(Calendar.FRIDAY);
    }

    /**
     * 获得周六日期
     * <p>
     * 注：日历工厂方法{@link #calendar()}设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     *
     * @return
     */
    public static Date saturday() {
        return weekDay(Calendar.SATURDAY);
    }

    /**
     * 获得周日日期 注：日历工厂方法{@link #calendar()}设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     *
     * @return
     */
    public static Date sunday() {
        return weekDay(Calendar.SUNDAY);
    }

    /**
     * 将字符串日期时间转换成java.util.Date类型 日期时间格式yyyy-MM-dd HH:mm:ss
     *
     * @param datetime
     * @return
     */
    public static Date parseDatetime(String datetime) throws ParseException {
        return datetimeFormat.parse(datetime);
    }

    /**
     * 将字符串日期转换成java.util.Date类型 日期时间格式yyyy-MM-dd
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static Date parseDate(String date) throws ParseException {
        return dateFormat.parse(date);
    }


    /**
     * 将字符串日期转换成java.util.Date类型 时间格式 HH:mm:ss
     *
     * @param time
     * @return
     * @throws ParseException
     */
    public static Date parseTime(String time) throws ParseException {
        return timeFormat.parse(time);
    }

    /**
     * 根据自定义pattern将字符串日期转换成java.util.Date类型
     *
     * @param datetime
     * @param pattern
     * @return
     * @throws ParseException
     */
    public static Date parseDatetime(String datetime, String pattern) throws ParseException {
        SimpleDateFormat format = (SimpleDateFormat) datetimeFormat.clone();
        format.applyPattern(pattern);
        return format.parse(datetime);
    }

    /**
     * 把秒格式化为分种小时
     *
     * @param second
     * @return
     */
    public static String parseSecond(int second) {
        if (second >= 60) {
            return second / 60 + "分";
        } else if (second >= 60 * 60) {
            return second / 60 * 60 + "时";
        } else if (second >= 60 * 60 * 24) {
            return second / 60 * 60 + "天";
        } else {
            return second + "秒";
        }
    }

    /**
     * 比较时间大小
     *
     * @param begin
     * @param end
     * @return
     */
    public static int compareDate(String begin, String end) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return compareDate(begin, end, df);
    }

    /**
     * 比较时间大小
     *
     * @param begin
     * @param end
     * @return
     */
    public static int compareDate(String begin, String end, SimpleDateFormat sdf) {
        try {
            Date beginDate = sdf.parse(begin);
            Date endDate = sdf.parse(end);
            if (beginDate.getTime() < endDate.getTime()) {
                return -1;
            } else if (beginDate.getTime() > endDate.getTime()) {
                return 1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }

    /**
     * 获得年份
     *
     * @param date
     * @return
     */
    public static int getYear(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.YEAR);
    }

    /**
     * 获得月份
     *
     * @param date
     * @return
     */
    public static int getMonth(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MONTH) + 1;
    }

    /**
     * 获得星期几
     *
     * @param date
     * @return
     */
    public int getWeek(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获得日期
     *
     * @param date
     * @return
     */
    public static int getDay(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.DATE);
    }

    /**
     * 获得天数差
     *
     * @param begin
     * @param end
     * @return
     */
    public long getDayDiff(Date begin, Date end) {
        long day = 1;
        if (end.getTime() < begin.getTime()) {
            day = -1;
        } else if (end.getTime() == begin.getTime()) {
            day = 1;
        } else {
            day += (end.getTime() - begin.getTime()) / (24 * 60 * 60 * 1000);
        }
        return day;
    }

    public static String replaceEnglish(String originalStr) {
        return originalStr.replace("MINUTE", "分钟")
                .replace("HOUR", "小时")
                .replace("DAY", "天")
                .replace("MONTH", "月")
                .replace("YEAR", "年")
                .replace("WEEK", "周");
    }

    public static long dateDiff(String startTime, String endTime, String format) {
        // 按照传入的格式生成一个simpledateformate对象
        SimpleDateFormat sd = new SimpleDateFormat(format);
        long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
        long nh = 1000 * 60 * 60;// 一小时的毫秒数
        long nm = 1000 * 60;// 一分钟的毫秒数
        long ns = 1000;// 一秒钟的毫秒数
        long diff;
        long day = 0;
        try {
            // 获得两个时间的毫秒时间差异
            diff = sd.parse(endTime).getTime() - sd.parse(startTime).getTime();
            day = diff / nd;// 计算差多少天
            long hour = diff % nd / nh;// 计算差多少小时
            long min = diff % nd % nh / nm;// 计算差多少分钟
            long sec = diff % nd % nh % nm / ns;// 计算差多少秒
            // 输出结果
            // System.out.println("时间相差：" + day + "天" + hour + "小时" + min
            // + "分钟" + sec + "秒。");
            if (day >= 1) {
                return day;
            } else {
                if (day == 0) {
                    return 1;
                } else {
                    return 0;
                }

            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0;

    }

    /**
     * 将字符串格式yyyyMMdd的字符串转为日期，格式"MM月dd日"
     *
     * @param //date
     * @return
     * @throws //ParseException
     */
    public static String strToDateFormat(String date) {

        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
        formatter.setLenient(false);
        String showDate = "";
        Date newDate = new Date();

        try {
            newDate = formatter.parse(date);
            formatter = new SimpleDateFormat("M月dd日");
            showDate = formatter.format(newDate);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        return showDate;
    }

    /**
     * type = holiday 日期转换为毫秒值
     *
     * @param date yyyy-MM-dd
     * @return
     */
    public static Long jsonToTimeInMillis(String date) {

        Long jsonToTm = 0L;
        Date newDate = new Date();

        try {
            newDate = dateFormat.parse(date);
            jsonToTm = newDate.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return jsonToTm;
    }

    /**
     * 将长时间（毫秒）转换为分钟和秒的字符串表示形式
     *
     * @param duration 长时间（以毫秒为单位）
     * @return 包含分钟和秒的字符串
     */
    public static String convertLongToMinutesSeconds(long duration) {
        long minutes = (duration / 1000) / 60; // 转换为分钟
        long seconds = (duration / 1000) % 60; // 转换为秒
        String secondStr = "";
        String minuteStr = "";
        if (seconds < 10) {
            secondStr = "0" + seconds;
        } else {
            secondStr = seconds + "";
        }

        if (minutes < 10) {
            minuteStr = "0" + minutes;
        } else {
            minuteStr = minutes + "";
        }
        return minuteStr + ":" + secondStr;
    }

    /**
     * type = holiday 日期转换为毫秒值
     *
     * @param
     * @return date HH:mm:ss
     */
    public static Date jsonToAmOrPm(String date) {
        Date newDate = new Date();
        try {
            newDate = timeFormat.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return newDate;
    }

    /**
     * 功能描述：返回小时
     *
     * @param date 日期
     * @return 返回小时
     */
    public static int getHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 功能描述：返回分钟
     *
     * @param date 日期
     * @return 返回分钟
     */
    public static int getMinute(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MINUTE);
    }

    public static String getTime(int second) {
        try {
            if (second < 10) {
                return "00:00:0" + second;
            }
            if (second < 60) {
                return "00:00:" + second;
            }
            if (second < 3600) {
                int minute = second / 60;
                second = second - minute * 60;
                if (minute < 10) {
                    if (second < 10) {
                        return "00:" + "0" + minute + ":0" + second;
                    }
                    return "00:" + "0" + minute + ":" + second;
                }
                if (second < 10) {
                    return "00:" + minute + ":0" + second;
                }
                return "00:" + minute + ":" + second;
            }
            int hour = second / 3600;
            int minute = (second - hour * 3600) / 60;
            second = second - hour * 3600 - minute * 60;
            if (hour < 10) {
                if (minute < 10) {
                    if (second < 10) {
                        return "0" + hour + ":0" + minute + ":0" + second;
                    }
                    return "0" + hour + ":0" + minute + ":" + second;
                }
                if (second < 10) {
                    return "0" + hour + minute + ":0" + second;
                }
                return "0" + hour + minute + ":" + second;
            }
            if (minute < 10) {
                if (second < 10) {
                    return hour + ":0" + minute + ":0" + second;
                }
                return hour + ":0" + minute + ":" + second;
            }
            if (second < 10) {
                return hour + ":" + minute + ":0" + second;
            }
            return hour + ":" + minute + ":" + second;
        } catch (Exception e) {
            // LogUtil.e("e==" + e);
        }
        return "";
    }

    public static long formatTurnSecond(String time) {
        try {
            if (!TextUtils.isEmpty(time)) {
                if (time.length() == 5) {
                    String s = time;
                    int index1 = s.indexOf(":");
                    int mi = Integer.parseInt(s.substring(0, index1));
                    int ss = Integer.parseInt(s.substring(index1 + 1, time.length()));
                    int hh = 0;
                    return hh * 60 * 60 + mi * 60 + ss;
                } else {
                    String s = time;
                    int index1 = s.indexOf(":");
                    int index2 = s.indexOf(":", index1 + 1);
                    int hh = Integer.parseInt(s.substring(0, index1));
                    int mi = Integer.parseInt(s.substring(index1 + 1, index2));
                    int ss = Integer.parseInt(s.substring(index2 + 1));
                    return hh * 60 * 60 + mi * 60 + ss;
                }
            }
        } catch (Exception e) {
        }
        return 0;
    }

    /**
     * 获取秒数 例如 100:33 格式处理
     */
    public static long formatTurnSecond2(String time) {
        try {
            if (!TextUtils.isEmpty(time)) {
                if (time.length() == 5) {
                    String s = time;
                    int index1 = s.indexOf(":");
                    int mi = Integer.parseInt(s.substring(0, index1));
                    int ss = Integer.parseInt(s.substring(index1 + 1, time.length()));
                    int hh = 0;
                    return hh * 60 * 60 + mi * 60 + ss;
                } else if (time.length() >= 6 && (time.length() - time.replace(":", "").length()) == 1) {
                    String s = time;
                    int index1 = s.indexOf(":");
                    int mi = Integer.parseInt(s.substring(0, index1));
                    int ss = Integer.parseInt(s.substring(index1 + 1, time.length()));
                    int hh = 0;
                    return hh * 60 * 60 + mi * 60 + ss;
                } else {
                    String s = time;
                    int index1 = s.indexOf(":");
                    int index2 = s.indexOf(":", index1 + 1);
                    int hh = Integer.parseInt(s.substring(0, index1));
                    int mi = Integer.parseInt(s.substring(index1 + 1, index2));
                    int ss = Integer.parseInt(s.substring(index2 + 1));
                    return hh * 60 * 60 + mi * 60 + ss;
                }
            }
        } catch (Exception e) {
        }
        return 0;
    }

    /**
     * 判断日期(效率比较高)
     */
    public static int JudgmentDay(String day) throws ParseException {
        Calendar pre = Calendar.getInstance();
        Date predate = new Date(SystemClock.uptimeMillis());
        pre.setTime(predate);

        Calendar cal = Calendar.getInstance();
        Date date = dateFormat.parse(day);
        cal.setTime(date);

        if (cal.get(Calendar.YEAR) == (pre.get(Calendar.YEAR))) {
            int diffDay = cal.get(Calendar.DAY_OF_YEAR) - pre.get(Calendar.DAY_OF_YEAR);

            switch (diffDay) {
                case YESTERDY: {
                    return YESTERDY;
                }
                case TODAY: {
                    return TODAY;
                }
                case TOMORROWDAT: {
                    return TOMORROWDAT;
                }
            }
        }
        return OTHER_DAY;
    }

    /**
     * 指定时间是否时今天
     *
     * @param time
     * @return
     * @throws Exception
     */
    public static boolean isToday(long time) {
        try {
            Calendar pre = Calendar.getInstance();
            Date predate = new Date(System.currentTimeMillis());
            pre.setTime(predate);

            Calendar cal = Calendar.getInstance();
            Date date = new Date(time);
            cal.setTime(date);

            int diffDay = cal.get(Calendar.DAY_OF_YEAR) - pre.get(Calendar.DAY_OF_YEAR);
            if (diffDay == 0) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /*
     * 将时间转换为时间戳
     */
    public static long dateToStamp(String s) throws ParseException {
        long ts = 0;
        if (!TextUtils.isEmpty(s)) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmm");
            Date date = simpleDateFormat.parse(s);
            ts = date.getTime();
        }
        return ts;
    }

    public static String getWatchCurrTime(String currentTime) {
        if (!TextUtils.isEmpty(currentTime)) {
            int seconds = Integer.parseInt(currentTime);
            int temp = 0;
            StringBuffer sb = new StringBuffer();
            temp = seconds / 3600;
            sb.append((temp < 10) ? "0" + temp + ":" : "" + temp + ":");
            temp = seconds % 3600 / 60;
            sb.append((temp < 10) ? "0" + temp + ":" : "" + temp + ":");
            temp = seconds % 3600 % 60;
            sb.append((temp < 10) ? "0" + temp : "" + temp);
            return sb.toString();
        }

        return "";
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> yyyy/MM/dd
     */
    public static String transFormTime(String time) {
        try {
            time = datetimeFormatEllip.format(datetimeFormat.parse(time));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> yyyy-MM-dd HH:mm
     */
    public static String transFormTime3(String time) {
        try {
            time = datetimeFormat3.format(datetimeFormat.parse(time));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * 日期格式转换
     */
    public static String transFormTime(String time, SimpleDateFormat srcFormat, SimpleDateFormat targetFormat) {
        if (srcFormat == null || targetFormat == null) {
            return time;
        }
        try {
            time = targetFormat.format(srcFormat.parse(time));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> MM月dd日 HH:mm
     */
    public static String transFormTime4(String time) {
        try {
            time = dateFormat3.format(datetimeFormat.parse(time));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> MM月dd日 HH:mm
     */
    public static String transFormTime4(long time) {
        Date date = new Date(time);
        return dateFormat3.format(date);
    }


    public static String transFormTime8(long time) {
        Date date = new Date(time);
        return dateFormat8.format(date);
    }

    public static String transFormTime9(long time) {
        Date date = new Date(time);
        return dateFormat9.format(date);
    }

    public static String transFormTime10(long time) {
        Date date = new Date(time);
        return dateFormat10.format(date);
    }


    public static String transFormTime3(long time) {
        Date date = new Date(time);
        return datetimeFormat3.format(date);
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> HH:mm
     */
    public static String transFormTime6(long time) {
        Date date = new Date(time);
        return dateFormat6.format(date);
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> M月d日 HH:mm
     */
    public static String transFormTime7(long time) {
        Date date = new Date(time);
        return dateFormat7.format(date);
    }


    /**
     * yyyy-MM-dd HH:mm:ss ----> yyyy.MM.dd
     */
    public static String transFormTime2(String time) {
        try {
            time = dateFormat2.format(datetimeFormat.parse(time));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * yyyy-MM-dd HH:mm:ss ----> yyyy-MM-dd
     */
    public static String transFormTime31(String time) {
        if (!TextUtils.isEmpty(time) && time.contains("-")) {
            try {
                time = datetimeFormat3.format(datetimeFormat.parse(time));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return time;
        }
        return "";
    }

    /**
     * 将yyyy-MM-dd HH:mm:ss转化为yyyy/MM/dd
     *
     * @param s
     * @return
     * @throws ParseException
     */
    public static String dateToFormat(String s) throws ParseException {
        String result = "";
        if (!TextUtils.isEmpty(s)) {
            SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat(FORMAT_DEFAULT);
            SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy/MM/dd");
            Date date = simpleDateFormat1.parse(s);
            result = simpleDateFormat2.format(date);
        }
        return result;
    }

    /**
     * type = holiday 日期转换为毫秒值
     *
     * @param date yyyy-MM-dd HH:mm:ss
     *             2022-11-25 19:00:01
     */
    public static Long jsonToTimeInMillis2(String date) {
        if (TextUtils.isEmpty(date)) {
            return 0L;
        }
        Long jsonToTm = 0L;
        Date newDate = new Date();

        try {
            newDate = datetimeFormat.parse(date);// datetimeFormat
            jsonToTm = newDate.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return jsonToTm;
    }

    /**
     * type = holiday 日期转换为毫秒值
     *
     * @param date yyyy-MM-dd HH:mm
     * @return
     */
    public static Long jsonToTimeInMillis3(String date) {

        Long jsonToTm = 0L;
        Date newDate = new Date();

        try {
            newDate = datetimeFormat3.parse(date);
            jsonToTm = newDate.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return jsonToTm;
    }

    /**
     * 明天、今天、昨天、MM:dd
     */
    public static String converTimeToText(long timestamp) {
        return converTimeToText(timestamp, null);
    }

    public static String converTimeToText(long timestamp, SimpleDateFormat format) {
        try {
            Calendar now = Calendar.getInstance();
            Calendar time = Calendar.getInstance();
            time.setTimeInMillis(timestamp);
            int nowYear = now.get(Calendar.YEAR);
            int timeYear = time.get(Calendar.YEAR);
            if (nowYear != timeYear) {
                if (null != format) {
                    return format.format(new Date(timestamp));
                } else {
                    return new SimpleDateFormat("yyyy年MM月dd日 HH:mm").format(new Date(timestamp));
                }
            } else {
                int nowDayOfYear = now.get(Calendar.DAY_OF_YEAR);
                int timeDayOfYear = time.get(Calendar.DAY_OF_YEAR);
                if (nowDayOfYear == timeDayOfYear) {
                    return "今天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else if (nowDayOfYear - timeDayOfYear == 1) {
                    return "昨天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else if (nowDayOfYear - timeDayOfYear == -1) {
                    return "明天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else {
                    return new SimpleDateFormat("MM月dd日 HH:mm").format(new Date(timestamp));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    public static String converTimeToTextForNew(long timestamp) {
        try {
            Calendar now = Calendar.getInstance();
            Calendar time = Calendar.getInstance();
            time.setTimeInMillis(timestamp);
            int nowYear = now.get(Calendar.YEAR);
            int timeYear = time.get(Calendar.YEAR);
            if (nowYear != timeYear) {
                return datetimeFormat3.format(new Date(timestamp));
            } else {
                int nowDayOfYear = now.get(Calendar.DAY_OF_YEAR);
                int timeDayOfYear = time.get(Calendar.DAY_OF_YEAR);
                if (nowDayOfYear == timeDayOfYear) {
                    return "今天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else if (nowDayOfYear - timeDayOfYear == 1) {
                    return "昨天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else if (nowDayOfYear - timeDayOfYear == -1) {
                    return "明天 " + new SimpleDateFormat("HH:mm").format(new Date(timestamp));
                } else {
                    return datetimeFormat4.format(new Date(timestamp));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 日期转换成刚刚、半小时前等
     *
     * @param dateTime 字符串数字时间戳  100000000
     * @return * @param dateTime 字符串数字时间戳  100000000
     */
    public static String converTime(String dateTime) {
        try {
            if (TextUtils.isEmpty(dateTime)) {
                return "";
            }
            long l = Long.parseLong(dateTime);
            return TimeUtil.getTimeForParseRule(l);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 直播聊天室IM，以本地手机时间作比较
     * 日期转换成刚刚、半小时前等
     *
     * @param dateTime 字符串数字时间戳  100000000
     * @return * @param dateTime 字符串数字时间戳  100000000
     */
    public static String converTimeForLocalTime(String dateTime) {
        try {
            if (TextUtils.isEmpty(dateTime)) {
                return "";
            }
            long l = Long.parseLong(dateTime);
            return TimeUtil.getTimeForParseRuleWithLocalTime(l);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }


    /**
     * 日期转换成刚刚、半小时前等
     *
     * @param dateTime 日期格式  yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String converTimeForm(String dateTime) {
        try {
            if (TextUtils.isEmpty(dateTime)) {
                return "";
            }
            long l = TimeUtil.dateToStampForm(dateTime);
            return TimeUtil.getTimeForParseRule(l);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }


    /**
     * 将时间转换为时间戳
     *
     * @param dateString
     * @return 时间戳
     */
    public static long dateToStampForm(String dateString) throws ParseException {
        long ts = 0;
        if (!TextUtils.isEmpty(dateString)) {
            Date date = datetimeFormat.parse(dateString);
            ts = date.getTime();
        }
        return ts;
    }


    /**
     * 时间戳转换成字符窜
     *
     * @param milSecond
     * @return 时间字符串
     */
    public static String getDateToString(long milSecond) {
        Date date = new Date(milSecond);
        return datetimeFormat.format(date);
    }


    /**
     * 时间字符串格式转换为时间戳
     *
     * @param timeStr    时间字符串格式, eg. 2018-06-17 00:00:00
     * @param timeFormat 时间格式
     * @return 时间戳
     * @throws Exception 时间格式解析错误
     */
    public static long time2timestamp(String timeStr) throws Exception {
        if (TextUtils.isEmpty(timeStr)) {
            return 0;
        }
        return datetimeFormat.parse(timeStr).getTime();
    }

    /**
     * 时间字符串格式转换为时间戳
     *
     * @param timeStr    时间字符串格式, eg. 2018.06.17 00:00:00
     * @param timeFormat 时间格式
     * @return 时间戳
     * @throws Exception 时间格式解析错误
     */
    public static long time2timestampV2(String timeStr) throws Exception {
        if (TextUtils.isEmpty(timeStr)) {
            return 0;
        }
        return datetimeFormat2.parse(timeStr).getTime();
    }


    /**
     * 日期转化为long时间戳
     */
    public static Long Date2Long(Date date) {

        return date.getTime();
    }


    /**
     * 时间戳转换为时间字符串
     *
     * @param timestamp 时间戳, eg. 1513440360000L
     * @return 时间字符串格式
     */
    public static String timestamp2time(long timestamp, String timeFormat) {
        SimpleDateFormat format = new SimpleDateFormat(timeFormat);
        return format.format(new Date(timestamp));
    }


    /**
     * 格式化毫秒数为 xx:xx:xx这样的时间格式。
     *
     * @param ms 毫秒数
     * @return 格式化后的字符串
     */
    public static String formatMs(long ms) {
        int seconds = (int) (ms / 1000);
        int finalSec = seconds % 60;
        int finalMin = seconds / 60 % 60;
        int finalHour = seconds / 3600;

        StringBuilder msBuilder = new StringBuilder("");
        if (finalHour > 9) {
            msBuilder.append(finalHour).append(":");
        } else if (finalHour > 0) {
            msBuilder.append("0").append(finalHour).append(":");
        }

        if (finalMin > 9) {
            msBuilder.append(finalMin).append(":");
        } else if (finalMin > 0) {
            msBuilder.append("0").append(finalMin).append(":");
        } else {
            msBuilder.append("00").append(":");
        }

        if (finalSec > 9) {
            msBuilder.append(finalSec);
        } else if (finalSec > 0) {
            msBuilder.append("0").append(finalSec);
        } else {
            msBuilder.append("00");
        }

        return msBuilder.toString();
    }

    /**
     * 将毫秒转化成固定格式的时间
     * 时间格式: yyyy-MM-dd-HHmmssSSS
     *
     * @param millisecond 时间毫秒
     * @return 时间格式: yyyy-MM-dd-HHmmssSSS
     */
    public static String getDateTimeFromMillisecond(Long millisecond) {
        @SuppressLint("SimpleDateFormat")
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HHmmssSSS");
        Date date = new Date(millisecond);
        return simpleDateFormat.format(date);
    }


    public static String getTime(long ms) {
        return TimeFormater.formatMs(ms);
    }


    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>时区时间转换开始>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>


    /**
     * 把字符串转化为手机系统设置时区对应的时间
     *
     * @param stringDate 北京时间字符串（接口返回的）
     * @return 手机系统设置时区对应的时间字符串
     */
    public static String dateToGMTString(String stringDate) {
        return dateToGMTString(stringDate, FORMAT_DEFAULT);
    }


    /**
     * 把字符串转化为手机系统设置时区对应的时间
     *
     * @param stringDate           北京时间字符串（接口返回的）
     * @param dateTimeFormatString 格式模板
     * @return 手机系统设置时区对应的时间字符串
     */
    public static String dateToGMTString(String stringDate, String dateTimeFormatString) {
        if (dateTimeFormatString == null || dateTimeFormatString.isEmpty()) {
            dateTimeFormatString = FORMAT_DEFAULT;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(dateTimeFormatString, Locale.CHINESE);
        sdf.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
        Date date = null;
        try {
            date = sdf.parse(stringDate);
        } catch (Exception e) {
            return "";
        }
        return dateToGMTString(date.getTime(), dateTimeFormatString);
    }


    /**
     * 把时间戳转化为手机系统设置时区对应的时间
     *
     * @param timeStamp 时间戳
     * @return 手机系统设置时区对应的时间字符串
     */
    public static String dateToGMTString(long timeStamp) {
        return dateToGMTString(timeStamp, FORMAT_DEFAULT);
    }


    /**
     * 把时间戳转化为手机系统设置时区对应的时间
     *
     * @param timeStamp            时间戳
     * @param dateTimeFormatString 时间格式模板
     * @return 手机系统设置时区对应的时间字符串
     */
    public static String dateToGMTString(long timeStamp, String dateTimeFormatString) {
        SimpleDateFormat tempTimeFormat = new SimpleDateFormat(dateTimeFormatString);
        tempTimeFormat.setTimeZone(TimeZone.getTimeZone(createGmtOffsetString(true, true, TimeZone.getDefault().getRawOffset())));
        return dateToGMTString(new Date(timeStamp), tempTimeFormat);
    }


    /**
     * 把时间戳转化为手机系统设置时区对应的时间
     *
     * @param date           日期对象
     * @param dateTimeFormat 时间格式模板
     * @return 手机系统设置时区对应的时间字符串
     */
    public static String dateToGMTString(Date date, SimpleDateFormat dateTimeFormat) {
        if (date == null) {
            return "";
        }
        String timeZoneId = createGmtOffsetString(true, true, TimeZone.getDefault().getRawOffset());
        String text = dateTimeFormat.format(date);
        return text;
    }


    /**
     * 获取系统当前时区
     * +0800        SimpleDateFormat("Z").format(Calendar.getInstance(TimeZone.getTimeZone("GMT"),Locale.getDefault()).time)
     * GMT+08:00    TimeZone.getDefault().getDisplayName(false, TimeZone.SHORT)——会存在PST、WIB直接别名的时区，后端不好过滤，赞、暂不采用
     * GMT+08:00    参考TimeZone方法createGmtOffsetString自定义方式实现
     *
     * @return GMT+08:00
     */
    public static String createGmtOffsetString(boolean includeGmt,
                                               boolean includeMinuteSeparator, int offsetMillis) {
        int offsetMinutes = offsetMillis / 60000;
        char sign = '+';
        if (offsetMinutes < 0) {
            sign = '-';
            offsetMinutes = -offsetMinutes;
        }
        StringBuilder builder = new StringBuilder(9);
        if (includeGmt) {
            builder.append("GMT");
        }
        builder.append(sign);
        appendNumber(builder, 2, offsetMinutes / 60);
        if (includeMinuteSeparator) {
            builder.append(':');
        }
        appendNumber(builder, 2, offsetMinutes % 60);
        return builder.toString();
    }


    private static void appendNumber(StringBuilder builder, int count, int value) {
        String string = Integer.toString(value);
        for (int i = 0; i < count - string.length(); i++) {
            builder.append('0');
        }
        builder.append(string);
    }

    /**
     * 获取2023-01-11格式
     *
     * @param timestamp
     * @return
     */
    private static String getYearMonthDay(long timestamp) {
        Date date = new Date(timestamp);
        int year = getYear(date);
        int month = getMonth(date);
        int day = getDay(date);
        String monthStr = month + "";
        if (month < 10) {
            monthStr = "0" + month;
        }
        String dayStr = day + "";
        if (day < 10) {
            dayStr = "0" + day;
        }
        return year + "-" + monthStr + "-" + dayStr;
    }

    /**
     * 中文版时间规则转换,使用服务器时间作为比较
     *
     * @param millisecond 毫秒值-string
     * @return
     */
    public static String getTimeForParseRule(long timestamp) {

        return getTimeResultForParseRule(timestamp,true);
    }

    /**
     * 中文版时间规则转换,使用本地时间作为比较
     *
     * @param millisecond 毫秒值-string
     * @return
     */
    public static String getTimeForParseRuleWithLocalTime(long timestamp) {

        return getTimeResultForParseRule(timestamp,false);
    }

    /**
     * 中文版时间规则转换
     *
     * @param millisecond 毫秒值-string
     * @param useServerTime 是否使用服务器时间-注意接口请求才会更新这个时间
     * @return
     */
    private static String getTimeResultForParseRule(long timestamp, boolean useServerTime) {
        String timeStr = "";
        // 服务器时间，豪秒数
        long currentSeconds = 0;
        if (useServerTime){
            currentSeconds = HostUtil.serverTime;
        }
        if (currentSeconds == 0) {
            currentSeconds = Calendar.getInstance().getTimeInMillis();
        }
        // 与现在时间相差豪秒数
        long timeGap = currentSeconds - timestamp;
        if (timeGap >= 60 * 60 * 1000 * 48) {
            //2天~：显示自然时间：2023-01-11格式
            timeStr = timestamp2time(timestamp, "yyyy-MM-dd");//getYearMonthDay(timestamp);
            //新增规则，同年的只展示月日，不展示年份
            int curYear = Calendar.getInstance().get(Calendar.YEAR);
            if (!TextUtils.isEmpty(timeStr) && timeStr.startsWith(String.valueOf(curYear))) {
                timeStr = timeStr.substring(5);
            }
//            String curTime = timestamp2time(currentSeconds, "yyyy-MM-dd");
//            if (!TextUtils.isEmpty(timeStr) && !TextUtils.isEmpty(curTime)){
//                String year = curTime.split("-")[0];
//                if (year.equals(timeStr.split("-")[0])){
//                    timeStr = timeStr.replace(year + "-","");
//                }
//            }
        } else if (timeGap >= 60 * 60 * 1000 * 24) {
            //1天~2天：1 day ago
            timeStr = 1 + ResUtils.getString(R.string.day_ago);
        } else if (timeGap >= 60 * 60 * 1000) {
            //1小时~1天：xx hours ago
            int hour = (int) (timeGap / (60 * 60 * 1000));
            timeStr = hour + ResUtils.getString(R.string.hours_ago);
        } else if (timeGap >= 60 * 1000) {
            //1~60分钟：xx mins ago
            int minute = (int) (timeGap / (60 * 1000));
            timeStr = minute + ResUtils.getString(R.string.mins_ago);
        } else if (timeGap >= 0) {
            //小于1分钟：just now
            timeStr = ResUtils.getString(R.string.just_now);
        } else {
            //小于0，未来的日子
            timeStr = getYearDayTimeString(timestamp);
        }
        return timeStr;
    }

    /**
     * 中文版时间规则转换（直播预约：过去和未来时间都显示年月日）
     *
     * @param millisecond 毫秒值-string
     * @return
     */
    public static String getTimeForParseRuleForLive(String millisecond) {
        if (StringUtils.isEmpty(millisecond) || "0".equals(millisecond)) {
            return "";
        }
        String timeStr = "";
        try {
            long timestamp = Long.parseLong(millisecond);
            // 当前时间，豪秒数
            long currentSeconds = Calendar.getInstance().getTimeInMillis();
            // 与现在时间相差豪秒数
            long timeGap = currentSeconds - timestamp;
            timeStr = getYearDayTimeString(timestamp);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return timeStr;
    }

    /**
     * 返回年月日时间格式(详情页：2022年1月 01日17:00 ）
     *
     * @param timeStr
     * @param timestamp
     * @return
     */
    public static String getYearDayTimeString(long timestamp) {
        Date date = new Date(timestamp);
        int year = getYear(date);
        int month = getMonth(date);
        int day = getDay(date);
        String monthStr = month + "";
        if (month < 10) {
            monthStr = "" + month;
        }

        String dayStr = day + "";
        if (day < 10) {
            dayStr = "0" + day;
        }
        String time = getHH(timestamp);
        return year + "年" + monthStr + "月" + dayStr + "日 " + time;
    }

    /**
     * 返回年月日时间格式(详情页：2022年01月 01日17:00 ）
     *
     * @param timeStr
     * @param timestamp
     * @return
     */
    public static String getYearDayTimeDetailString(long timestamp) {
        Date date = new Date(timestamp);
        int year = getYear(date);
        int month = getMonth(date);
        int day = getDay(date);
        String monthStr = month + "";
        if (month < 10) {
            monthStr = "0" + month;
        }

        String dayStr = day + "";
        if (day < 10) {
            dayStr = "0" + day;
        }
        String time = getHH(timestamp);
        return year + "年" + monthStr + "月" + dayStr + "日 " + time;
    }

    /**
     * 返回年月日时间格式(问政详情页：2023-10-07 20:21 ）
     *
     * @param timeStr
     * @param timestamp
     * @return
     */
    public static String getYearDayTimeString2(long timestamp) {
        Date date = new Date(timestamp);
        int year = getYear(date);
        int month = getMonth(date);
        int day = getDay(date);
        String monthStr = month + "";
        if (month < 10) {
            monthStr = "0" + month;
        }

        String dayStr = day + "";
        if (day < 10) {
            dayStr = "0" + day;
        }
        String time = getHH(timestamp);
        return year + "-" + monthStr + "-" + dayStr + " " + time;
    }

    /**
     * yyyy-MM-dd HH:mm:ss 转换 long
     * 2024-01-22 19:41:03 转换 long
     */
    public static String dateFormat4(String time) {
        //时间为空，不用转换成1970-01-01显示
        if (TextUtils.isEmpty(time)) {
            return "0";
        }

        String reTime = "0";
        try {
            reTime = datetimeFormat.parse(time).getTime() + "";
        } catch (Exception e) {
            e.printStackTrace();
        }
        return reTime;
    }

    /**
     * yyyy年 MM月dd日
     *
     * @param time
     * @return
     */
    public static String dataFormat5(long time) {
        return dateFormat5.format(time);
    }

    public static String dataFormat11(long time) {
        return dateFormat11.format(time);
    }

    /**
     * yyyy年M月d日 HH:mm
     * @param time
     * @return
     */
    public static String dataFormat12(long time) {
        return dateFormat12.format(time);
    }

    /**
     * 时长显示，显示xx时xx分xx秒
     * @param time
     */
//    public static String timeToDurationFormat(int time) {
//        String sDurationFormat = "%1$02d:%2$02d:%3$02d";
//        int sec = Math.round(((float) time) / 1000);
//        int hour = sec / 3600;
//        int min = (sec % 3600) / 60;
//        sec = (sec % 60);
//        try{
//            return String.format(sDurationFormat,
//                    hour,
//                    min,
//                    sec);
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//        return "";
//    }

    /**
     * 时长显示，显示xx分xx秒
     *
     * @param time
     */
    public static String timeToDurationFormat(long time) {
        String sDurationFormat1 = ":%02d";
        String sDurationFormat2 = "%1$02d:%2$02d";
        String reTime = "";
        int sec = Math.round(((float) time) / 1000);
        int min = sec / 60;
        sec = (sec % 60);
        try {
            if (min > 9) {
                reTime = min + String.format(sDurationFormat1, sec);
            } else {
                reTime = String.format(sDurationFormat2,
                        min,
                        sec);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return reTime;
    }


    public static String parseTimeToLongForPublish(String publishTime) {
        if (StringUtils.isBlank(publishTime)) {
            return currentDatetime();
        }

        if (publishTime.contains("今天")) {
            return publishTime.replace("今天", getCurrentDate())
                    .replace("时", ":")
                    .replace("分", ":")
                    + ":00";
        } else {
            return TimeUtil.getYear() + "-" +
                    publishTime.replace("月", "-")
                            .replace("日", "")
                            .replace("时", ":")
                            .replace("分", ":")
                    + ":00";
        }
    }

    /**
     * 获取当前精确到秒的时间戳
     * refreshTime=1715242229113
     * @param date
     * @return
     */
    public static long getSecondTimes(long serverTime){
        try{
            String s = String.valueOf(serverTime);
            if (s != null && s.length() == 13){
                long timestamp = serverTime/1000;
                return timestamp * 1000;
            }else {
                return serverTime;
            }
        }catch (Exception e){
            return serverTime;
        }
    }


    /**
     * 计算历史页面中的标题日期信息
     * @param pushTime
     * @return
     */
    public static String calHistoryTitleData(String pushTime){

        if (getYearDayTimeString2(System.currentTimeMillis()).startsWith(pushTime)) {
            pushTime = "今天";
        } else if (getYearDayTimeString2(System.currentTimeMillis() - 24 * 3600 * 1000).startsWith(pushTime)) {
            pushTime = "昨天";
        }
        return pushTime ;
    }

}