package cn.freemud.es.manager.retry;


import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * @author hongwang.zhang 重試工具類(lèi)
 */
@Slf4j
public class Retry<T> {
    /**
     * 默認(rèn)重試次數(shù)
     */
    private int maxRetryTimes = 3;
    /**
     * 重試的 對(duì)象
     */
    private Operation<T> operation;
    /**
     * 判斷是否成功
     */
    private List<Judgement<T>> judgements;

    /**
     * 異常 call
     */
    private ExceptionCallback exceptionCallback;

    public Retry<T> maxRetryTimes(int maxRetryTimes) {
        this.maxRetryTimes = maxRetryTimes;
        return this;
    }

    public Retry<T> operation(Operation<T> operation) {
        this.operation = operation;
        return this;
    }

    public Retry<T> judgement(Judgement<T> judgement) {
        if (this.judgements == null) {
            this.judgements = new ArrayList<>();
        }
        this.judgements.add(judgement);
        return this;
    }

    public Retry<T> exceptionCallback(ExceptionCallback exceptionCallback) {
        this.exceptionCallback = exceptionCallback;
        return this;
    }

    public T execute(){
        return  execute(this.maxRetryTimes,this.operation,this.judgements,this.exceptionCallback);
    }
    /**
     *
     * todo  1罩扇、池化 2怜奖、方法的超時(shí)時(shí)間
     * @param maxRetryTimes 重試次數(shù)
     * @param operation     重試的方法
     * @param judgements    校驗(yàn)
     * @param exceptionCallback    異趁贫撸回調(diào)
     * @return
     * @throws Exception 重試次數(shù)達(dá)到 指定次數(shù)后如果有異常拋出異常
     */

    public T execute(int maxRetryTimes, Operation<T> operation, List<Judgement<T>> judgements,ExceptionCallback exceptionCallback) {
        if (Objects.isNull(operation)) {
            throw new NullPointerException("operation not is null");
        }
        boolean isBreak = false;
        T operate =null;
        int times = 1;
        while(times <= maxRetryTimes && (!isBreak)){
            try {
                operate = operation.operate();
            }catch (Exception e){
                log.error("Retry.execute,times:{},exception:{}", times,new Gson().toJsonTree(e));
                if(Objects.nonNull(exceptionCallback)){
                    exceptionCallback.call(e);
                }

            }
            if (null != judgements && judgements.size() > 0) {
                boolean judge = false;
                for (Judgement<T> judgement : judgements) {
                     judge = judgement.judge(operate);
                    if(!judge){
                        times ++;
                        break;
                    }
                }
                if(judge){
                    isBreak = true;
                }
            }else {
                isBreak = true;
            }
        }
        return  operate;





    }

    public interface Operation<T> {
        /**
         * 返回的對(duì)象
         *
         * @return
         */
        T operate() throws IOException;
    }

    public interface ExceptionCallback<T> {
        /**
         * 異常處理
         * @return
         */
        void call(Exception e);
    }

    /**
     * 斷言
     *
     * @param <T>
     */
    public interface Judgement<T> {
        /**
         * 判斷是否成功
         *
         * @param t
         * @return
         */
        boolean judge(T t);
    }

    /**
     * 非空判斷
     */
    public class IsNullJudgement implements Judgement<T> {

        @Override
        public boolean judge(T t) {
            return t == null;
        }
    }
}