import com.example.exception.RetryException;

import lombok.extern.slf4j.Slf4j;

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

/**
 * 
重试工具类
 *
 * @author GFire
 * @since 2025/4/22 17:58
 */
@Slf4j
public abstract class RetryUtils {
    /**
     * 失败重试
     *
     * @param task            执行的任务，无返回值
     * @param acceptException 可接受的异常类型，执行的任务抛出此异常（及其子类）则失败重试。null表示不接受任何异常
     * @param maxRetryCount   最大重试次数
     * @param waitTime        重试间隔等待时间, 单位毫秒,  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            执行的任务，有返回值
     * @param isValid         判断任务返回值是否合法，不合法则失败重试
     * @param acceptException 可接受的异常类型，执行的任务抛出此异常（及其子类）则失败重试。null表示不接受任何异常
     * @param maxRetryCount   最大重试次数
     * @param waitTime        重试间隔等待时间, 单位毫秒,  T doWithRetry(Supplier task, Predicate 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");
        }

        T result = null;
        for (int tryCount = 1; tryCount  0 && tryCount  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);
        }
    }
}

/**
 * 
重试异常
 *
 * @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);
    }
}

 // 模拟调用API接口，失败重试
RetryUtils.doWithRetry(() -> apiService.query(), Exception.class, 3, 2000);

/**
 * 模拟发送通知
 */
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);