package com.ruoyi.framework.config;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TimeZone;

/**
 * 时间格式全局配置：接口出参一律精确到分（{@code yyyy-MM-dd HH:mm}），入参宽松兼容带/不带秒。
 *
 * <p><b>为什么用全局配置而不是逐字段改注解：</b>系统里
 * {@code @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")} 有 182 处、{@code @DateTimeFormat} 73 处，
 * 逐个改既容易漏（漏一处就是提交 400），也覆盖不到未加注解的 {@code Date} 字段。
 * 这里用 Jackson 的 {@link BeanSerializerModifier} / {@link BeanDeserializerModifier}
 * 在<b>不改任何注解</b>的前提下统一格式化口径。
 *
 * <p><b>规则：</b>
 * <ol>
 *   <li>序列化：所有 {@code Date} 输出 {@code yyyy-MM-dd HH:mm}（沿用
 *       {@link ApplicationConfig} 配置的 JVM 默认时区；字段上显式声明了
 *       {@code @JsonFormat(timezone=...)} 的仍按其时区）；</li>
 *   <li>反序列化：兼容 {@code yyyy-MM-dd HH:mm:ss} / {@code yyyy-MM-dd HH:mm} /
 *       {@code yyyy-MM-dd} / 斜杠分隔 / ISO8601 / 时间戳 —— 这样前端回填"无秒"的值原样提交也不会 400；</li>
 *   <li>运维日志（操作日志/登录日志/定时任务日志）<b>保留秒</b>，便于排查问题。</li>
 * </ol>
 *
 * <p><b>不影响的范围：</b>数据库存储（仍为 datetime，秒位照常保留）、
 * Excel 导入导出（走 {@code @Excel.dateFormat}，未改动）、
 * 致远协同推送报文（自建 {@code SimpleDateFormat}，未改动）、
 * 钉钉消息时间（{@code FundNotifyMessageBuilder} 自建格式）。
 *
 * @author ruoyi
 */
@Configuration
public class JacksonDateConfig {

    /** 无秒格式 */
    private static final String PATTERN_NO_SECONDS = "yyyy-MM-dd HH:mm";
    /** 有秒格式（运维日志用） */
    private static final String PATTERN_WITH_SECONDS = "yyyy-MM-dd HH:mm:ss";

    /** 保留秒的类：运维日志，秒对排查有用 */
    private static final Set<String> KEEP_SECONDS_CLASSES = new HashSet<String>(Arrays.asList(
            "com.ruoyi.system.domain.SysOperLog",
            "com.ruoyi.system.domain.SysLogininfor",
            "com.ruoyi.quartz.domain.SysJobLog"
    ));

    /** 反序列化尝试顺序：从最具体到最宽松 */
    private static final String[] PARSE_PATTERNS = new String[]{
            "yyyy-MM-dd HH:mm:ss.SSS",
            "yyyy-MM-dd HH:mm:ss",
            "yyyy-MM-dd HH:mm",
            "yyyy-MM-dd'T'HH:mm:ss.SSS",
            "yyyy-MM-dd'T'HH:mm:ss",
            "yyyy-MM-dd'T'HH:mm",
            "yyyy/MM/dd HH:mm:ss",
            "yyyy/MM/dd HH:mm",
            "yyyy-MM-dd",
            "yyyy/MM/dd",
            "yyyyMMddHHmmss",
            "yyyyMMdd"
    };

    /**
     * 2026-10-15 改造：不再用 {@code Jackson2ObjectMapperBuilderCustomizer} + {@code modulesToInstall}。
     *
     * <p><b>为什么改：</b>{@code Jackson2ObjectMapperBuilder.modulesToInstall(...)} 的语义是
     * "设置"模块列表（不是追加），而 Spring Boot 自身也用同一方法注册它自带的模块（JavaTime 等）；
     * 两个定制器互相覆盖，谁后执行谁的列表生效。实测后果：本模块被丢掉 ——
     * 表现为"类在包里、bean 也创建了，但 Date 的宽松解析与去秒序列化都不起作用"，
     * 前端按 {@code yyyy-MM-dd} 提交时直接 400（Cannot deserialize ... expected format yyyy-MM-dd HH:mm:ss）。
     *
     * <p>改为把模块声明成 {@code SimpleModule} bean：Spring Boot 通过 {@code ObjectProvider<Module>}
     * 统一收集所有 Module bean 并一次性安装，与定制器的执行顺序无关。
     */
    @Bean
    public SimpleModule dateNoSecondsModule() {
        SimpleModule module = new SimpleModule("dateNoSecondsModule");
        module.addSerializer(Date.class, new NoSecondsDateSerializer());
        module.setSerializerModifier(new NoSecondsDateSerializerModifier());
        module.setDeserializerModifier(new LenientDateDeserializerModifier());
        // 启动自证：这条日志出现即说明模块已被创建并会被 Spring Boot 安装
        LoggerFactory.getLogger(JacksonDateConfig.class).info(
                "[JacksonDateConfig] 已启用：Date 出参去秒({})，入参宽松兼容({})",
                PATTERN_NO_SECONDS, String.join(" / ", PARSE_PATTERNS));
        return module;
    }

    /**
     * 序列化器：按分钟输出。
     * 只作用于序列化，<b>不影响入参解析</b>。
     */
    static class NoSecondsDateSerializer extends JsonSerializer<Date> implements ContextualSerializer {

        private final DateTimeFormatter formatter;

        NoSecondsDateSerializer() {
            this.formatter = null;
        }

        private NoSecondsDateSerializer(TimeZone timeZone, boolean keepSeconds) {
            this.formatter = DateTimeFormatter
                    .ofPattern(keepSeconds ? PATTERN_WITH_SECONDS : PATTERN_NO_SECONDS)
                    .withZone((timeZone == null ? TimeZone.getDefault() : timeZone).toZoneId());
        }

        @Override
        public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) {
            TimeZone timeZone = resolveTimeZone(prov.getConfig().getTimeZone(),
                    property == null ? null : property.getMember());
            return new NoSecondsDateSerializer(timeZone, isKeepSeconds(property == null ? null : property.getMember()));
        }

        @Override
        public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            if (value == null) {
                gen.writeNull();
                return;
            }
            if (formatter != null) {
                gen.writeString(formatter.format(value.toInstant()));
                return;
            }
            // 兜底：未被 contextualize 时按当前配置时区、无秒输出
            gen.writeString(DateTimeFormatter.ofPattern(PATTERN_NO_SECONDS)
                    .withZone(serializers.getConfig().getTimeZone().toZoneId())
                    .format(value.toInstant()));
        }
    }

    /**
     * 让 Bean 属性上的日期也走上面的序列化器。
     * 字段级 {@code @JsonFormat} 生成的序列化器优先级更高，必须在这里替换掉，否则注解字段仍带秒。
     */
    static class NoSecondsDateSerializerModifier extends BeanSerializerModifier {
        @Override
        @SuppressWarnings({"unchecked", "rawtypes"})
        public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc,
                                                         List<BeanPropertyWriter> beanProperties) {
            boolean keepSeconds = KEEP_SECONDS_CLASSES.contains(beanDesc.getBeanClass().getName());
            for (BeanPropertyWriter writer : beanProperties) {
                if (Date.class.isAssignableFrom(writer.getType().getRawClass())) {
                    TimeZone timeZone = resolveTimeZone(config.getTimeZone(), writer.getMember());
                    writer.assignSerializer((JsonSerializer) new NoSecondsDateSerializer(timeZone, keepSeconds));
                }
            }
            return beanProperties;
        }
    }

    /**
     * 入参解析：兼容带秒/不带秒/纯日期/ISO/时间戳，避免"出参无秒、回填后再提交"导致 400。
     */
    static class LenientDateDeserializerModifier extends BeanDeserializerModifier {
        @Override
        @SuppressWarnings({"unchecked", "rawtypes"})
        public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc,
                                                     BeanDeserializerBuilder builder) {
            Iterator<SettableBeanProperty> properties = builder.getProperties();
            List<SettableBeanProperty> replaced = new ArrayList<SettableBeanProperty>();
            while (properties.hasNext()) {
                SettableBeanProperty property = properties.next();
                if (property.getType() != null && Date.class.isAssignableFrom(property.getType().getRawClass())) {
                    TimeZone timeZone = resolveTimeZone(config.getTimeZone(), property.getMember());
                    replaced.add(property.withValueDeserializer(new LenientDateDeserializer(timeZone)));
                }
            }
            // 不能边遍历边改，先收集再替换
            for (SettableBeanProperty property : replaced) {
                builder.addOrReplaceProperty(property, true);
            }
            return builder;
        }
    }

    /** 宽松日期解析器 */
    static class LenientDateDeserializer extends JsonDeserializer<Date> {

        private final TimeZone timeZone;

        LenientDateDeserializer(TimeZone timeZone) {
            this.timeZone = timeZone == null ? TimeZone.getDefault() : timeZone;
        }

        @Override
        public Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            if (p.hasToken(JsonToken.VALUE_NUMBER_INT)) {
                return new Date(p.getLongValue());
            }
            String text = p.getValueAsString();
            if (text == null || text.trim().isEmpty()) {
                return null;
            }
            text = text.trim();
            for (String pattern : PARSE_PATTERNS) {
                SimpleDateFormat format = new SimpleDateFormat(pattern);
                format.setLenient(false);
                format.setTimeZone(timeZone);
                ParsePosition position = new ParsePosition(0);
                Date parsed = format.parse(text, position);
                // 必须整串被消费，否则 "yyyy-MM-dd" 会把 "2026-10-08 15:23" 的时分静默丢掉
                if (parsed != null && position.getIndex() == text.length()) {
                    return parsed;
                }
            }
            try {
                return Date.from(Instant.parse(text));
            } catch (Exception ignore) {
                // 落到下面统一报错
            }
            throw ctxt.weirdStringException(text, Date.class,
                    "无法解析的时间格式，支持 yyyy-MM-dd[ HH:mm[:ss]]");
        }
    }

    /** 属性上显式声明的时区优先，否则用全局配置（即 JVM 默认时区） */
    private static TimeZone resolveTimeZone(TimeZone fallback, AnnotatedMember member) {
        if (member != null) {
            try {
                JsonFormat jsonFormat = member.getAnnotation(JsonFormat.class);
                if (jsonFormat != null && jsonFormat.timezone() != null
                        && !jsonFormat.timezone().isEmpty()
                        && !"##default".equals(jsonFormat.timezone())) {
                    return TimeZone.getTimeZone(jsonFormat.timezone());
                }
            } catch (Exception ignore) {
                // 取不到注记时用全局时区
            }
        }
        return fallback == null ? TimeZone.getDefault() : fallback;
    }

    /** 运维日志类保留秒 */
    private static boolean isKeepSeconds(AnnotatedMember member) {
        return member != null && KEEP_SECONDS_CLASSES.contains(member.getDeclaringClass().getName());
    }
}