package io.meteorcat.pino;

import android.app.Activity;
import android.util.Log;

/**
 * 用于测试编写自定义构建的 Activity 层
 *
 */
public class PinoActivity extends Activity {

    /**
     * Activity 启动回调
     */
    @Override
    protected void onStart() {
        super.onStart();
        Log.i("PinoSDKActivity", "onStart");
    }

    /**
     * Activity 重启回调
     */
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.i("PinoSDKActivity", "onStart");
    }

    /**
     * Activity 恢复回调
     */
    @Override
    protected void onResume() {
        super.onResume();
        Log.i("PinoSDKActivity", "onResume");
    }

    /**
     * Activity 停止回调
     */
    @Override
    protected void onStop() {
        super.onStop();
        Log.i("PinoSDKActivity", "onStop");
    }

    /**
     * Activity 销毁回调
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i("PinoSDKActivity", "onDestroy");
    }
}

package io.meteorcat.pino.app;

import android.os.Bundle;
import io.meteorcat.pino.PinoActivity; // 这就是 lib 内部的 Activity

/**
 * 继承实现自定义上级 Activity
 */
public class MainActivity extends PinoActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

package io.meteorcat.pino.utils;

import org.apache.commons.codec.digest.DigestUtils;

import java.nio.charset.StandardCharsets;

/**
 * MD5工具类
 */
public class MD5Utils {

    /**
     * 字符串MD5加密（默认UTF-8编码）
     *
     * @param content 待加密字符串
     * @return 32位小写MD5结果
     */
    public static String encrypt(String content) {
        return DigestUtils.md5Hex(content.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 字节数组MD5加密
     *
     * @param bytes 待加密字节数组
     * @return 32位小写MD5结果
     */
    public static String encrypt(byte[] bytes) {
        return DigestUtils.md5Hex(bytes);
    }

    /**
     * 带盐值的MD5加密（增强安全性）
     *
     * @param content 待加密字符串
     * @param salt    盐值（建议服务端约定固定值/动态值）
     * @return 32位小写MD5结果
     */
    public static String encryptWithSalt(String content, String salt) {
        return encrypt(content + salt);
    }
}

package io.meteorcat.pino.utils;

import android.util.Log;
import com.google.gson.Gson;
import io.meteorcat.pino.BuildConfig;
import okhttp3.*;
import okhttp3.logging.HttpLoggingInterceptor;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 简易 HTTP 请求工具（优化版）
 */
public class SimpleHttpUtils {

    /**
     * JSON 请求的 MEDIA 类型
     */
    public static final MediaType JSON_MEDIA_TYPE = MediaType.parse("application/json; charset=utf-8");

    /**
     * Gson 实例, 静态统一
     */
    private static final Gson GSON = new Gson();

    /**
     * OkHttp客户端(单例)
     */
    private static final OkHttpClient okHttpClient;

    /**
     * 默认日志标签
     */
    private static final String TAG = "SimpleHttpUtils";

    static {
        // 添加日志拦截器（仅调试模式），方便排查问题
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(message -> Log.d(TAG, "OkHttp: " + message));
        loggingInterceptor.setLevel(BuildConfig.DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);

        // 构建 HTTP 客户端
        okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .addInterceptor(loggingInterceptor) // 调试日志
                .retryOnConnectionFailure(true) // 弱网自动重试
                .build();
    }

    /**
     * POST请求：JSON参数 + MD5签名
     *
     * @param url    接口地址
     * @param params 请求参数（Map）
     * @param salt   MD5盐值
     * @param clazz  解析目标类
     * @return 解析后的实体类，失败返回null
     */
    public static <T> T fetch(String url, Map<String, Object> params, String salt, Class<T> clazz) {
        // 空值校验
        if (url == null || url.isEmpty() || clazz == null) {
            Log.e(TAG, "fetch: 参数异常（url/clazz不能为空）");
            return null;
        }
        try {
            String paramStr = buildParamStr(params);
            String sign = MD5Utils.encryptWithSalt(paramStr, salt);
            Map<String, Object> finalParams = params == null ? new HashMap<>() : new HashMap<>(params);
            finalParams.put("sign", sign);

            String jsonParams = GSON.toJson(finalParams);
            RequestBody requestBody = RequestBody.create(jsonParams, JSON_MEDIA_TYPE);
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();

            Response response = okHttpClient.newCall(request).execute();
            // 完整状态码处理
            if (response.isSuccessful()) {
                ResponseBody body = response.body();
                if (body.contentLength() > 0) {
                    String responseBody = body.string();
                    Log.d(TAG, "fetch success: " + responseBody);
                    return GSON.fromJson(responseBody, clazz);
                } else {
                    Log.e(TAG, "fetch: 响应体为空");
                }
            } else {
                Log.e(TAG, "fetch: 接口返回非200状态码 " + response.code());
            }
        } catch (Exception e) {
            Log.e(TAG, "fetch error", e);
        }
        return null;
    }

    /**
     * GET请求：URL参数 + MD5签名
     *
     * @param url    接口地址
     * @param params 请求参数（Map）
     * @param salt   MD5盐值
     * @param clazz  解析目标类
     * @return 解析后的实体类，失败返回null
     */
    public static <T> T query(String url, Map<String, Object> params, String salt, Class<T> clazz) {
        if (url == null || url.isEmpty() || clazz == null) {
            Log.e(TAG, "query: 参数异常（url/clazz不能为空）");
            return null;
        }
        try {
            String paramStr = buildParamStr(params);
            String sign = MD5Utils.encryptWithSalt(paramStr, salt);
            String urlWithParams = buildUrlWithParams(url, params, sign);

            Request request = new Request.Builder()
                    .url(urlWithParams)
                    .get()
                    .build();

            Response response = okHttpClient.newCall(request).execute();
            if (response.isSuccessful()) {
                ResponseBody body = response.body();
                if (body.contentLength() > 0) {
                    String responseBody = body.string();
                    Log.d(TAG, "query success: " + responseBody);
                    return GSON.fromJson(responseBody, clazz);
                } else {
                    Log.e(TAG, "query: 响应体为空");
                }
            } else {
                Log.e(TAG, "query: 接口返回非200状态码 " + response.code());
            }
        } catch (Exception e) {
            Log.e(TAG, "query error", e);
        }
        return null;
    }

    /**
     * 按Key排序拼接参数（避免签名不一致）
     * 示例：{a:1, b:2} → "a=1&b=2"
     */
    private static String buildParamStr(Map<String, Object> params) {
        if (params == null || params.isEmpty()) {
            return "";
        }
        List<Map.Entry<String, Object>> sortedEntries = new ArrayList<>(params.entrySet());
        sortedEntries.sort(Map.Entry.comparingByKey());

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < sortedEntries.size(); i++) {
            Map.Entry<String, Object> entry = sortedEntries.get(i);
            // 过滤null值，避免签名错误
            if (entry.getValue() != null) {
                sb.append(entry.getKey()).append("=").append(entry.getValue());
                if (i != sortedEntries.size() - 1) {
                    sb.append("&");
                }
            }
        }
        return sb.toString();
    }

    /**
     * 拼接URL和参数（含签名）
     */
    private static String buildUrlWithParams(String url, Map<String, Object> params, String sign) {
        return (url.contains("?") ? url : url + "?") +
                buildParamStr(params) +
                "&sign=" + sign;
    }
}