import com.example.exception.RetryException;

import lombok.extern.slf4j.Slf4j;

import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * <h2>重試工具類</h2>
 *
 * @author GFire
 * @since 2025/4/22 17:58
 */
@Slf4j
public abstract class RetryUtils {
    /**
     * 失敗重試
     *
     * @param task            執(zhí)行的任務(wù)，無(wú)返回值
     * @param acceptException 可接受的異常類型，執(zhí)行的任務(wù)拋出此異常（及其子類）則失敗重試。null表示不接受任何異常
     * @param maxRetryCount   最大重試次數(shù)
     * @param waitTime        重試間隔等待時(shí)間, 單位毫秒, <=0則不等待
     * @throws RetryException 如果任務(wù)重試超過(guò)最大次數(shù)、或拋出不可接受的異常，則統(tǒng)一包裝拋出RetryException
     */
    public static void doWithRetry(Runnable task, Class<? extends Throwable> acceptException, int maxRetryCount, int waitTime) {
        if (task == null) {
            throw new IllegalArgumentException("task can not be null");
        }

        doWithRetry(() -> {
            task.run();
            return 1;
        }, i -> i == 1, acceptException, maxRetryCount, waitTime);
    }

    /**
     * 失敗重試
     *
     * @param task            執(zhí)行的任務(wù)，有返回值
     * @param isValid         判斷任務(wù)返回值是否合法，不合法則失敗重試
     * @param acceptException 可接受的異常類型，執(zhí)行的任務(wù)拋出此異常（及其子類）則失敗重試。null表示不接受任何異常
     * @param maxRetryCount   最大重試次數(shù)
     * @param waitTime        重試間隔等待時(shí)間, 單位毫秒, <=0則不等待
     * @return supplier執(zhí)行結(jié)果
     * @throws RetryException 如果任務(wù)重試超過(guò)最大次數(shù)、或拋出不可接受的異常，則統(tǒng)一包裝拋出RetryException
     */
    public static <T> T doWithRetry(Supplier<T> task, Predicate<T> isValid, Class<? extends Throwable> acceptException, int maxRetryCount, int waitTime) {
        if (task == null) {
            throw new IllegalArgumentException("task can not be null");
        }
        if (isValid == null) {
            throw new IllegalArgumentException("isValid can not be null");
        }
        if (maxRetryCount <= 0) {
            throw new IllegalArgumentException("maxRetryCount must be > 0");
        }

        T result = null;
        for (int tryCount = 1; tryCount <= maxRetryCount; tryCount++) {
            try {
                result = task.get();
                if (isValid.test(result)) {
                    return result;
                } else {
                    log.error("result invalid, tryCount: {}, result: {}", tryCount, result);
                }
            } catch (Throwable e) {
                handleException(e, acceptException, maxRetryCount, tryCount);
            }

            if (waitTime > 0 && tryCount < maxRetryCount) {
                sleep(waitTime); // 等待一段時(shí)間后重試
            }
        }
        throw new RetryException("result: " + result);
    }

    private static void handleException(Throwable e, Class<? extends Throwable> acceptException, int maxRetryCount, int tryCount) {
        log.error("error, tryCount: {}, Exception: ", tryCount, e);
        if (acceptException != null && acceptException.isInstance(e)) {
            if (tryCount == maxRetryCount) { // 最后一次重試仍失敗，則拋出
                throw new RetryException(e);
            }
        } else { // 不可接受的異常，直接拋出
            throw new RetryException(e);
        }
    }

    private static void sleep(int waitTime) {
        try {
            Thread.sleep(waitTime);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RetryException(e);
        }
    }
}

/**
 * <h2>重試異常</h2>
 *
 * @author GFire
 * @since 2025/4/23 11:20
 */
public class RetryException extends RuntimeException {
    public RetryException(String message) {
        super(message);
    }

    public RetryException(Throwable cause) {
        super(cause);
    }
}

 // 模擬調(diào)用API接口，失敗重試
RetryUtils.doWithRetry(() -> apiService.query(), Exception.class, 3, 2000);

/**
 * 模擬發(fā)送通知
 */
public boolean send(String content) {
    try {
        RetryUtils.doWithRetry(() -> noticeService.send(content), this::isValid, Exception.class, 3, 2000);
        return true;
    } catch (RetryException e) {
        log.error("send error: {}", e.toString());
    }
    return false;
}

private boolean isValid(String res) {
    if (StringUtils.isNotEmpty(res)) {
        JSONObject response = JSON.parseObject(res);
        return "ok".equals(response.getString("status"));
    }
    return false;
}

RetryUtils.doWithRetry(() -> noticeService.send(), (res) -> true, Exception.class, 3, 2000);