package com.tcm.training.admin.utils;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestOperations;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 微赞开放平台HTTP工具，负责Token获取、缓存和自动刷新。
 */
@Slf4j
@Component
public class VzanHttpUtil {

    private static final String TOKEN_URL = "https://openapi.njyqkj0ksyz.com/api/v2/token/get_token";
    private static final String ACCOUNT = "Vzan1247381477";
    private static final String SECRET_KEY = "b1bd524170574dc085a2d75adcd1c644 ";
    private static final long REFRESH_AHEAD_MILLIS = 60_000L;
    private static final DateTimeFormatter DATE_TIME_FORMATTER =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private final Object refreshLock = new Object();
    private final RestOperations restOperations;
    private final ObjectMapper objectMapper;
    private final Clock clock;

    private volatile TokenSnapshot tokenSnapshot;

    @Autowired
    public VzanHttpUtil(ObjectMapper objectMapper) {
        this(createRestTemplate(), objectMapper, Clock.systemDefaultZone());
    }

    public VzanHttpUtil(RestOperations restOperations, ObjectMapper objectMapper, Clock clock) {
        this.restOperations = restOperations;
        this.objectMapper = objectMapper;
        this.clock = clock;
    }

    /**
     * 获取有效Token；Token不存在或即将过期时自动刷新。
     */
    public String getToken() {
        TokenSnapshot current = tokenSnapshot;
        if (isUsable(current)) {
            return current.token;
        }
        synchronized (refreshLock) {
            current = tokenSnapshot;
            if (isUsable(current)) {
                return current.token;
            }
            return requestAndCacheToken().token;
        }
    }

    /**
     * 忽略当前缓存并立即获取新Token。
     */
    public String refreshToken() {
        synchronized (refreshLock) {
            return requestAndCacheToken().token;
        }
    }

    private TokenSnapshot requestAndCacheToken() {
        validateCredentials();
        long timestamp = clock.millis();

        Map<String, String> body = new LinkedHashMap<String, String>();
        body.put("account", ACCOUNT.trim());
        body.put("signkey", md5Lowercase(SECRET_KEY.trim() + timestamp));
        body.put("timestamp", String.valueOf(timestamp));

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, String>> request = new HttpEntity<Map<String, String>>(body, headers);
        ResponseEntity<String> response = restOperations.postForEntity(TOKEN_URL, request, String.class);
        TokenSnapshot received = parseTokenResponse(response.getBody());
        tokenSnapshot = received;
        return received;
    }

    private TokenSnapshot parseTokenResponse(String responseBody) {
        if (!StringUtils.hasText(responseBody)) {
            throw new IllegalStateException("微赞Token接口返回为空");
        }
        try {
            JsonNode root = objectMapper.readTree(responseBody);
            if (!"0".equals(root.path("code").asText())) {
                throw new IllegalStateException("获取微赞Token失败: " + root.path("msg").asText("未知错误"));
            }
            JsonNode data = root.path("data");
            String token = data.path("token").asText();
            String tokenExpires = data.path("tokenExpires").asText();
            if (!StringUtils.hasText(token) || !StringUtils.hasText(tokenExpires)) {
                throw new IllegalStateException("微赞Token接口返回数据不完整");
            }
            return new TokenSnapshot(token, parseExpiresAt(tokenExpires));
        } catch (IllegalStateException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new IllegalStateException("解析微赞Token接口响应失败", ex);
        }
    }

    private Instant parseExpiresAt(String value) {
        String normalized = value.trim();
        try {
            long numericValue = Long.parseLong(normalized);
            if (numericValue < 10_000_000L) {
                return clock.instant().plusSeconds(numericValue);
            }
            return numericValue < 10_000_000_000L
                    ? Instant.ofEpochSecond(numericValue)
                    : Instant.ofEpochMilli(numericValue);
        } catch (NumberFormatException ignored) {
            // 继续兼容标准日期时间格式。
        }
        try {
            return Instant.parse(normalized);
        } catch (DateTimeParseException ignored) {
            // 继续兼容带时区和无时区格式。
        }
        try {
            return OffsetDateTime.parse(normalized).toInstant();
        } catch (DateTimeParseException ignored) {
            // 继续兼容微赞常用的本地日期时间格式。
        }
        try {
            LocalDateTime localDateTime = LocalDateTime.parse(normalized, DATE_TIME_FORMATTER);
            return localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        } catch (DateTimeParseException ex) {
            throw new IllegalStateException("无法识别微赞Token过期时间: " + normalized, ex);
        }
    }

    private boolean isUsable(TokenSnapshot snapshot) {
        return snapshot != null
                && snapshot.expiresAt.toEpochMilli() - clock.millis() > REFRESH_AHEAD_MILLIS;
    }

    private void validateCredentials() {
        if (!StringUtils.hasText(ACCOUNT) || !StringUtils.hasText(SECRET_KEY)) {
            throw new IllegalStateException("请先配置微赞PAAS账号和客户密钥");
        }
    }

    /**
     * 创建微赞代理。接口返回顶层code或data.result非成功时抛出运行时异常。
     *
     * @return 微赞返回的代理业务数据
     */
    public JsonNode createAgent(String agentMobile, String agentName, Integer levelCode,
                                String parentMobile, String storeName) {
        String token = getToken();
        Map<String, Object> body = new LinkedHashMap<String, Object>();
        body.put("agent_mobile", requireText(agentMobile, "代理手机号不能为空"));
        body.put("agent_name", requireText(agentName, "代理名称不能为空"));
        if (levelCode == null) {
            throw new IllegalArgumentException("代理等级不能为空");
        }
        body.put("level_code", levelCode);
        putIfHasText(body, "parent_mobile", parentMobile);
        putIfHasText(body, "store_name", storeName);

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.setBearerAuth(token);
        try {
            ResponseEntity<String> response = restOperations.postForEntity(
                    "https://openapi.njyqkj0ksyz.com/api/v2/agent/createAgent",
                    new HttpEntity<Map<String, Object>>(body, headers), String.class);
            return parseCreateAgentResponse(response.getBody());
        } catch (RestClientException ex) {
            throw new IllegalStateException("调用微赞创建代理接口失败", ex);
        }
    }

    private JsonNode parseCreateAgentResponse(String responseBody) {
        if (!StringUtils.hasText(responseBody)) {
            throw new IllegalStateException("微赞创建代理接口返回为空");
        }
        try {
            JsonNode root = objectMapper.readTree(responseBody);
            if (!"0".equals(root.path("code").asText())) {
                throw new IllegalStateException("微赞创建代理失败: " + root.path("msg").asText("未知错误"));
            }
            JsonNode data = root.path("data");
            if (!data.isObject() || data.path("result").asInt(-1) != 0) {
                throw new IllegalStateException("微赞创建代理失败: 业务处理未成功");
            }
            return data;
        } catch (IllegalStateException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new IllegalStateException("解析微赞创建代理响应失败", ex);
        }
    }

    private static String requireText(String value, String message) {
        if (!StringUtils.hasText(value)) {
            throw new IllegalArgumentException(message);
        }
        return value.trim();
    }

    private static void putIfHasText(Map<String, Object> body, String key, String value) {
        if (StringUtils.hasText(value)) {
            body.put(key, value.trim());
        }
    }

    private static String md5Lowercase(String text) {
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            byte[] bytes = digest.digest(text.getBytes(StandardCharsets.UTF_8));
            StringBuilder result = new StringBuilder(bytes.length * 2);
            for (byte value : bytes) {
                result.append(String.format("%02x", value & 0xff));
            }
            return result.toString();
        } catch (NoSuchAlgorithmException ex) {
            throw new IllegalStateException("当前运行环境不支持MD5", ex);
        }
    }

    private static RestTemplate createRestTemplate() {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(10_000);
        requestFactory.setReadTimeout(10_000);
        return new RestTemplate(requestFactory);
    }

    private static final class TokenSnapshot {
        private final String token;
        private final Instant expiresAt;

        private TokenSnapshot(String token, Instant expiresAt) {
            this.token = token;
            this.expiresAt = expiresAt;
        }
    }

//    /**
//     * 启动时验证微赞Token接口配置和连通性，失败仅记录日志，不阻断应用启动。
//     */
//    @PostConstruct
//    public void init() {
//        if (!StringUtils.hasText(ACCOUNT) || !StringUtils.hasText(SECRET_KEY)) {
//            log.warn("微赞Token连通性测试已跳过：PAAS账号或客户密钥未配置");
//            return;
//        }
//        try {
//            String token = getToken();
//            log.info("微赞Token获取成功：{}", token);
//        } catch (Exception ex) {
//            log.error("微赞Token获取失败", ex);
//        }
//    }
}