package com.doumee.core.douyin;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.doumee.core.constants.Constants;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.douyin.dto.DouyinBaseResp;
import com.doumee.core.douyin.dto.DouyinCancelReq;
import com.doumee.core.douyin.dto.DouyinCancelResp;
import com.doumee.core.douyin.dto.DouyinClientTokenReq;
import com.doumee.core.douyin.dto.DouyinClientTokenResp;
import com.doumee.core.douyin.dto.DouyinOnlineQueryReq;
import com.doumee.core.douyin.dto.DouyinOnlineQueryResp;
import com.doumee.core.douyin.dto.DouyinPrepareReq;
import com.doumee.core.douyin.dto.DouyinPrepareResp;
import com.doumee.core.douyin.dto.DouyinShopPoiResp;
import com.doumee.core.douyin.dto.DouyinVerifyReq;
import com.doumee.core.douyin.dto.DouyinVerifyResp;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.utils.Http;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.dao.system.model.SystemDictData;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 抖音开放平台 HTTP 客户端
 * 封装 client_token 获取(带 Redis 缓存,提前刷新)与 goodlife/v1 接口调用。
 *
 * @author rk
 * @date 2026/06/22
 */
@Slf4j
@Component
public class DouyinClient {

    @Autowired
    private DouyinProperties douyinProperties;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /** 字典取数(后台可改抖音配置:client_key/client_secret/account_id/poi_id,免重启) */
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    /**
     * 从字典 DOUYIN_CONFIG 取指定标签的值。
     * 字典无值(返回空对象)时兜底返回 null,由调用方校验。
     *
     * @param label 字典项标签(如 CLIENT_KEY / POI_ID)
     * @return 配置值;查不到返回 null
     */
    private String getDictValue(String label) {
        SystemDictData data = systemDictDataBiz.queryByCode(Constants.DOUYIN_CONFIG, label);
        return data == null ? null : data.getCode();
    }

    /**
     * 取核销门店ID(单门店,存字典 POI_ID)。
     *
     * @return 门店ID
     */
    public String getPoiId() {
        return getDictValue(Constants.DOUYIN_POI_ID);
    }

    // 官方 API 文档(生活服务 / 团购核销):
    // https://partner.open-douyin.com/docs/resource/zh-CN/local-life/develop/OpenAPI/general-capabilities/life.capacity.fulfilment/certificate.prepare
    /** 「生成 client_token」接口路径 */
    private static final String URL_CLIENT_TOKEN = "/oauth/client_token/";
    /** 「查询商品线上数据列表」接口路径 */
    private static final String URL_PRODUCT_ONLINE_QUERY = "/goodlife/v1/goods/product/online/query/";
    /** 「查询门店信息」接口路径(查询商户下已认领的门店列表) */
    private static final String URL_SHOP_POI_QUERY = "/goodlife/v1/shop/poi/query/";
    /** 「验券准备」接口路径 */
    private static final String URL_PREPARE = "/goodlife/v1/fulfilment/certificate/prepare/";
    /** 「验券(核销)」接口路径 */
    private static final String URL_VERIFY = "/goodlife/v1/fulfilment/certificate/verify/";
    /** 「撤销核销」接口路径 */
    private static final String URL_CANCEL = "/goodlife/v1/fulfilment/certificate/cancel/";

    /** token 提前刷新余量(秒),避免临界过期 */
    private static final long TOKEN_REFRESH_LEAD_SECONDS = 300L;
    /** client_token 默认有效期(秒),接口未返回时兜底 */
    private static final long TOKEN_DEFAULT_EXPIRE_SECONDS = 7200L;

    /** access_token 无效 / 过期错误码 */
    private static final int ERR_TOKEN_INVALID = 2190002;
    private static final int ERR_TOKEN_EXPIRED = 2190008;

    // ============================ client_token ============================

    /**
     * 获取 access-token(带 Redis 缓存,临近过期自动刷新)
     */
    public String getAccessToken() {
        String key = douyinProperties.getRedisTokenKey();
        Object cached = redisTemplate.opsForValue().get(key);
        if (cached instanceof String) {
            String token = (String) cached;
            Long ttl = redisTemplate.getExpire(key, TimeUnit.SECONDS);
            if (StringUtils.isNotBlank(token) && ttl != null && ttl > TOKEN_REFRESH_LEAD_SECONDS) {
                return token;
            }
        }
        return refreshAccessToken();
    }

    /**
     * 强制刷新 access-token
     */
    public String refreshAccessToken() {
        DouyinClientTokenReq req = new DouyinClientTokenReq();
        // client_key / client_secret 从字典 DOUYIN_CONFIG 实时读取(后台可改)
        req.setClientKey(getDictValue(Constants.DOUYIN_CLIENT_KEY));
        req.setClientSecret(getDictValue(Constants.DOUYIN_CLIENT_SECRET));
        req.setGrantType("client_credential");
        try {
            Http.HttpWrap wrap = new Http().build(douyinProperties.getHost() + URL_CLIENT_TOKEN);
            Http.HttpResult result = wrap.setRequestProperty("Content-Type", "application/json")
                    .postJSON(JSONObject.parseObject(JSON.toJSONString(req)));
            DouyinClientTokenResp resp = result.toClass(DouyinClientTokenResp.class);
            if (resp == null || resp.getData() == null
                    || resp.getData().getErrorCode() == null
                    || resp.getData().getErrorCode() != 0
                    || StringUtils.isBlank(resp.getData().getAccessToken())) {
                log.error("抖音 client_token 获取失败:{}", JSON.toJSONString(resp));
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "抖音 client_token 获取失败");
            }
            String token = resp.getData().getAccessToken();
            long expiresIn = resp.getData().getExpiresIn() == null
                    ? TOKEN_DEFAULT_EXPIRE_SECONDS : resp.getData().getExpiresIn();
            redisTemplate.opsForValue().set(douyinProperties.getRedisTokenKey(), token, expiresIn, TimeUnit.SECONDS);
            return token;
        } catch (BusinessException e) {
            throw e;
        } catch (Exception e) {
            log.error("调用抖音 client_token 异常", e);
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),
                    "调用抖音 client_token 异常:" + e.getMessage());
        }
    }

    /**
     * client_token 剩余有效期(秒);未缓存返回 0
     */
    public long getTokenTtlSeconds() {
        return redisTemplate.getExpire(douyinProperties.getRedisTokenKey(), TimeUnit.SECONDS);
    }

    /**
     * 清空缓存的 access-token。
     * <p>后台修改了 client_key/client_secret 后,旧 token 已失效,不清会被 {@link #getAccessToken()}
     * 继续复用,导致抖音接口报「access-token 无效/过期」;清掉后,下次真正调用抖音接口时
     * 才用新配置换取新 token(比立即 refresh 更稳:新配置若有误,不会在保存瞬间就报错)。
     */
    public void clearAccessToken() {
        redisTemplate.delete(douyinProperties.getRedisTokenKey());
    }

    // ============================ 商品线上数据列表 ============================

    /**
     * 查询商品线上数据列表(单页),token 失效自动刷新重试
     */
    public DouyinBaseResp<DouyinOnlineQueryResp> onlineQuery(DouyinOnlineQueryReq req) {
        if (StringUtils.isBlank(req.getAccountId())) {
            // account_id 从字典 DOUYIN_CONFIG 实时读取(后台可改)
            req.setAccountId(getDictValue(Constants.DOUYIN_ACCOUNT_ID));
        }
        if (req.getPoiIds() == null || req.getPoiIds().isEmpty()) {
            // poi_ids 从字典 POI_ID 实时读取(当前单门店,放入单元素列表);
            // 抖音规则:poi_ids 传 0 视为空值(返回商户下全量商品),故字典须配真实门店ID,
            // 非数字或 0 时放弃门店过滤(等价返回全量),避免把脏值当过滤条件发出
            String poiIdStr = getDictValue(Constants.DOUYIN_POI_ID);
            if (StringUtils.isNotBlank(poiIdStr)) {
                try {
                    long poiId = Long.parseLong(poiIdStr.trim());
                    if (poiId > 0) {
                        req.setPoiIds(Collections.singletonList(poiId));
                    }
                } catch (NumberFormatException e) {
                    log.warn("字典 POI_ID 非数字,online/query 忽略门店过滤:{}", poiIdStr);
                }
            }
        }
        // GET 方式:入参拼成 query 参数(仿 prepare);buildQuery 会跳过 null 值
        DouyinBaseResp<DouyinOnlineQueryResp> resp = doGet(URL_PRODUCT_ONLINE_QUERY, buildOnlineQueryParams(req),
                new TypeReference<DouyinBaseResp<DouyinOnlineQueryResp>>() {});
        if (tokenInvalid(resp)) {
            refreshAccessToken();
            resp = doGet(URL_PRODUCT_ONLINE_QUERY, buildOnlineQueryParams(req),
                    new TypeReference<DouyinBaseResp<DouyinOnlineQueryResp>>() {});
        }
        return resp;
    }

    /**
     * 把 online/query 入参拼成 GET 查询参数。
     * <p>覆盖 account_id / product_id / out_id / status / cursor / count / poi_ids;
     * buildQuery 会跳过 null 值;status/count 仅非 null 时放入;poi_ids 数组用逗号分隔传参。
     *
     * @param req 查询商品线上数据列表入参
     * @return GET 查询参数 Map(值可能为 null,由 buildQuery 统一跳过)
     */
    private Map<String, String> buildOnlineQueryParams(DouyinOnlineQueryReq req) {
        Map<String, String> params = new LinkedHashMap<>();
        params.put("account_id", req.getAccountId());
        params.put("product_id", req.getProductId());
        params.put("goods_query_type", "2");
        params.put("out_id", req.getOutId());
        if (req.getStatus() != null) {
            params.put("status", String.valueOf(req.getStatus()));
        }
        params.put("cursor", req.getCursor());
        if (req.getCount() != null) {
            params.put("count", String.valueOf(req.getCount()));
        }
        // poi_ids 为 Array<Int64>,GET 用逗号分隔传参(如 poi_ids=123,456)
        if (req.getPoiIds() != null && !req.getPoiIds().isEmpty()) {
            params.put("poi_ids", StringUtils.join(req.getPoiIds(), ","));
        }
        return params;
    }

    // ============================ 查询门店信息 ============================

    /**
     * 查询商户下已认领的门店列表(管理端选核销门店用),token 失效自动刷新重试。
     * <p>account_id 固定从字典 DOUYIN_CONFIG 实时读取(后台可改),不接收外部入参。
     *
     * @return 门店信息列表;接口异常抛 {@link BusinessException}
     */
    public DouyinBaseResp<DouyinShopPoiResp> shopPoiQuery() {
        // account_id 从字典 DOUYIN_CONFIG 实时读取(后台可改)
        Map<String, String> params = new LinkedHashMap<>();
        params.put("account_id", getDictValue(Constants.DOUYIN_ACCOUNT_ID));
        // GET 方式:入参拼成 query 参数;buildQuery 会跳过 null 值
        DouyinBaseResp<DouyinShopPoiResp> resp = doGet(URL_SHOP_POI_QUERY, params,
                new TypeReference<DouyinBaseResp<DouyinShopPoiResp>>() {});
        if (tokenInvalid(resp)) {
            refreshAccessToken();
            resp = doGet(URL_SHOP_POI_QUERY, params,
                    new TypeReference<DouyinBaseResp<DouyinShopPoiResp>>() {});
        }
        return resp;
    }

    // ============================ 验券准备 ============================

    /**
     * 把扫码短链(或含 object_id 的长链)解析为 encrypted_data
     *
     * @return encrypted_data(object_id),解析失败返回 null
     */
    public String resolveShortLink(String shortUrl) {
        if (StringUtils.isBlank(shortUrl)) {
            return null;
        }
        String input = shortUrl.trim();
        String objectId = extractObjectId(input);
        if (objectId != null) {
            return objectId;
        }
        try {
            HttpURLConnection conn = (HttpURLConnection) new URL(input).openConnection();
            conn.setInstanceFollowRedirects(true);
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(5000);
            conn.connect();
            String finalUrl = conn.getURL().toString();
            conn.disconnect();
            return extractObjectId(finalUrl);
        } catch (Exception e) {
            log.error("解析抖音短链异常:{}", input, e);
            return null;
        }
    }

    /**
     * 从 url 中提取 object_id 参数值(即 encrypted_data)
     *
     * @param url 可能含 object_id=xxx 的链接
     * @return 解码后的 object_id,不含则返回 null
     */
    private String extractObjectId(String url) {
        if (url == null) {
            return null;
        }
        int idx = url.indexOf("object_id=");
        if (idx < 0) {
            return null;
        }
        String tail = url.substring(idx + "object_id=".length());
        int end = tail.indexOf('&');
        String val = end < 0 ? tail : tail.substring(0, end);
        try {
            return URLDecoder.decode(val, "UTF-8");
        } catch (Exception e) {
            return val;
        }
    }

    /**
     * 验券准备,token 失效自动刷新重试
     */
    public DouyinBaseResp<DouyinPrepareResp> prepare(DouyinPrepareReq req) {
        if (StringUtils.isBlank(req.getAccountId())) {
            // account_id 从字典 DOUYIN_CONFIG 实时读取(后台可改)
            req.setAccountId(getDictValue(Constants.DOUYIN_ACCOUNT_ID));
        }
        DouyinBaseResp<DouyinPrepareResp> resp = doGet(URL_PREPARE, buildPrepareQuery(req),
                new TypeReference<DouyinBaseResp<DouyinPrepareResp>>() {});
        if (tokenInvalid(resp)) {
            refreshAccessToken();
            resp = doGet(URL_PREPARE, buildPrepareQuery(req),
                    new TypeReference<DouyinBaseResp<DouyinPrepareResp>>() {});
        }
        return resp;
    }

    /**
     * 把验券准备入参拼成 GET 查询参数(prepare 接口走 GET)
     */
    private Map<String, String> buildPrepareQuery(DouyinPrepareReq req) {
        Map<String, String> params = new LinkedHashMap<>();
        params.put("encrypted_data", req.getEncryptedData());
        params.put("code", req.getCode());
        params.put("poi_id", req.getPoiId());
        params.put("account_id", req.getAccountId());
        if (req.getCanVerify() != null) {
            params.put("can_verify", String.valueOf(req.getCanVerify()));
        }
        return params;
    }

    // ============================ 验券 ============================

    /**
     * 验券(核销),token 失效自动刷新重试
     */
    public DouyinBaseResp<DouyinVerifyResp> verify(DouyinVerifyReq req) {
        if (StringUtils.isBlank(req.getAccountId())) {
            // account_id 从字典 DOUYIN_CONFIG 实时读取(后台可改)
            req.setAccountId(getDictValue(Constants.DOUYIN_ACCOUNT_ID));
        }
        DouyinBaseResp<DouyinVerifyResp> resp = doPost(URL_VERIFY, req,
                new TypeReference<DouyinBaseResp<DouyinVerifyResp>>() {});
        if (tokenInvalid(resp)) {
            refreshAccessToken();
            resp = doPost(URL_VERIFY, req,
                    new TypeReference<DouyinBaseResp<DouyinVerifyResp>>() {});
        }
        return resp;
    }

    // ============================ 撤销核销 ============================

    /**
     * 撤销核销,token 失效自动刷新重试
     */
    public DouyinBaseResp<DouyinCancelResp> cancel(DouyinCancelReq req) {
        if (StringUtils.isBlank(req.getAccountId())) {
            // account_id 从字典 DOUYIN_CONFIG 实时读取(后台可改)
            req.setAccountId(getDictValue(Constants.DOUYIN_ACCOUNT_ID));
        }
        DouyinBaseResp<DouyinCancelResp> resp = doPost(URL_CANCEL, req,
                new TypeReference<DouyinBaseResp<DouyinCancelResp>>() {});
        if (tokenInvalid(resp)) {
            refreshAccessToken();
            resp = doPost(URL_CANCEL, req,
                    new TypeReference<DouyinBaseResp<DouyinCancelResp>>() {});
        }
        return resp;
    }

    // ============================ 内部工具 ============================

    /**
     * 统一 POST 调用:带 access-token 请求头,序列化入参,反序列化 {@link DouyinBaseResp}
     *
     * @param path 接口路径(不含 host)
     * @param req  业务入参对象
     * @param type 响应泛型类型引用
     * @return 抖音通用响应外壳;调用异常统一抛 {@link BusinessException}
     */
    private <T> DouyinBaseResp<T> doPost(String path, Object req, TypeReference<DouyinBaseResp<T>> type) {
        try {
            // 入参日志:只打请求 body,不含 access-token 请求头,避免泄密
            log.info("抖音请求 {} 入参:{}", path, JSON.toJSONString(req));
            Http.HttpWrap wrap = new Http().build(douyinProperties.getHost() + path);
            wrap.setRequestProperty("Content-Type", "application/json");
            wrap.setRequestProperty("access-token", getAccessToken());
            Http.HttpResult result = wrap.postJSON(JSONObject.parseObject(JSON.toJSONString(req)));
            // 响应流只能读一次(toStringResult 读后会关闭底层流),先取出字符串复用,避免二次读取报 "stream is closed"
            String body = result.toStringResult();
            // 出参日志:打印抖音响应体,便于排查返回内容
            log.info("抖音响应 {} 出参:{}", path, body);
            return JSON.parseObject(body, type);
        } catch (Exception e) {
            log.error("调用抖音接口异常:path={}", path, e);
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),
                    "调用抖音接口异常:" + e.getMessage());
        }
    }

    /**
     * 统一 GET 调用:带 access-token 请求头,查询参数拼到 url,反序列化 {@link DouyinBaseResp}
     */
    private <T> DouyinBaseResp<T> doGet(String path, Map<String, String> params, TypeReference<DouyinBaseResp<T>> type) {
        String url = douyinProperties.getHost() + path;
        String query = buildQuery(params);
        if (StringUtils.isNotBlank(query)) {
            url = url + "?" + query;
        }
        try {
            // 入参日志:GET 查询参数,不含 access-token 请求头
            log.info("抖音请求 {} 入参:{}", path, params);
            Http.HttpWrap wrap = new Http().build(url);
            wrap.setRequestProperty("Content-Type", "application/json");
            wrap.setRequestProperty("access-token", getAccessToken());
            Http.HttpResult result = wrap.get();
            // 响应流只能读一次(toStringResult 读后会关闭底层流),先取出字符串复用,避免二次读取报 "stream is closed"
            String body = result.toStringResult();
            // 出参日志:打印抖音响应体,便于排查返回内容
            log.info("抖音响应 {} 出参:{}", path, body);
            return JSON.parseObject(body, type);
        } catch (Exception e) {
            log.error("调用抖音接口异常:path={}", path, e);
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),
                    "调用抖音接口异常:" + e.getMessage());
        }
    }

    /**
     * 把参数 Map 拼成 a=1&b=2 形式的查询串(跳过 null 值)
     */
    private String buildQuery(Map<String, String> params) {
        if (params == null || params.isEmpty()) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> e : params.entrySet()) {
            if (e.getValue() == null) {
                continue;
            }
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(e.getKey()).append("=").append(urlEncode(e.getValue()));
        }
        return sb.toString();
    }

    /**
     * UTF-8 URL 编码,编码异常时原样返回
     */
    private String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, "UTF-8");
        } catch (Exception e) {
            return value;
        }
    }

    /**
     * 判断响应是否为 access-token 无效/过期(命中则由调用方刷新后重试一次)
     */
    private boolean tokenInvalid(DouyinBaseResp<?> resp) {
        if (resp == null || resp.getExtra() == null || resp.getExtra().getErrorCode() == null) {
            return false;
        }
        int code = resp.getExtra().getErrorCode();
        return code == ERR_TOKEN_INVALID || code == ERR_TOKEN_EXPIRED;
    }
}