package com.hdl.sdk.sourceos.utils.thread;

import android.os.Handler;
import android.os.Looper;
import android.util.ArrayMap;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Created by Tong on 2021/10/21.
 */
public class ThreadUtils {

    private static final Handler uiHandler = new Handler(Looper.getMainLooper());

    private static final ArrayMap<Integer, ExecutorService> mThreadPools = new ArrayMap<>();

    //后台处理线程池
    private static final int IO_TYPE = 0;

    //分发线程池
    private static final int DISPENSE_TYPE = 1;

    private static final Timer TIMER = new Timer();

    //cpu 最大线程容纳量
    private static final int coreSize = Runtime.getRuntime().availableProcessors() + 1;
    private static final int maxCoreSize = 2 * Runtime.getRuntime().availableProcessors() + 1;


    private volatile static ThreadUtils INSTANCE = null;

    private ThreadUtils() {
    }

    public static ThreadUtils getInstance() {
        if (INSTANCE == null) {
            synchronized (ThreadUtils.class) {
                if (INSTANCE == null) {
                    INSTANCE = new ThreadUtils();
                }
            }
        }
        return INSTANCE;
    }


    /**
     * @return 单线程，无限长度队列，会在调用线程执行，频繁用到这个线程说明并发超级多
     */
    private ExecutorService getSingleThread() {
        if (!mThreadPools.isEmpty() && mThreadPools.containsKey(DISPENSE_TYPE)) {
            ExecutorService thread = mThreadPools.get(DISPENSE_TYPE);
            if (thread != null && !thread.isShutdown()) {
                return thread;
            }
        }
        final ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(1, 1, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new RenameThreadFactory() {

            @Override
            public String getName(int poolNumber, int threadNumber) {
                return "app_dispense_" + poolNumber + "_" + threadNumber;
            }
        }, new ThreadPoolExecutor.DiscardPolicy());

        poolExecutor.allowCoreThreadTimeOut(true);

        mThreadPools.put(DISPENSE_TYPE, poolExecutor);
        return poolExecutor;
    }

    /**
     * 维护 cpu 最大线程容纳量+队列1024 用完在单线程调用
     */
    private ExecutorService getIOThread() {
        if (!mThreadPools.isEmpty() && mThreadPools.containsKey(IO_TYPE)) {
            ExecutorService thread = mThreadPools.get(IO_TYPE);
            if (thread != null && !thread.isShutdown()) {
                return thread;
            }
        }
        final ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(coreSize, coreSize, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1024), new RenameThreadFactory() {
            @Override
            public String getName(int poolNumber, int threadNumber) {
                return "app_io_" + poolNumber + "_" + threadNumber;
            }
            //满了，就使用备份线程池，会oom，使用task会捕抓异常
        }, new BackgroundRunsPolicy());

        poolExecutor.allowCoreThreadTimeOut(true);

        mThreadPools.put(IO_TYPE, poolExecutor);
        return poolExecutor;
    }


    /**
     * 线程数量固定的线程池
     */
    public static ExecutorService newFixedThreadPool(int size) {
        if (size == 0 || coreSize < size) {
            return Executors.newFixedThreadPool(coreSize);
        }
        return Executors.newFixedThreadPool(size);
    }

    /**
     * 定时任务线程池
     */
    public static ScheduledExecutorService newScheduledThreadPool(int size) {
        if (size == 0 || coreSize < size) {
            return Executors.newScheduledThreadPool(coreSize);
        }
        return Executors.newScheduledThreadPool(size);
    }


    /**
     * 切换回主线程
     */
    public static void runOnUiThread(Runnable run) {
        if (Looper.getMainLooper() == Looper.myLooper()) {
            try {
                run.run();
            } catch (Exception e) {
                e.printStackTrace();
            }

        } else {
            try {
                uiHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            run.run();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 延时更新Ui
     */
    public static void runOnUiThreadDelay(Runnable run, long delayMillis) {
        uiHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                try {
                    run.run();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, delayMillis);
    }


    /**
     * 后台耗时任务
     */
    public static void runAsyncThread(Runnable run) {
        try {
            getInstance().getIOThread().execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        run.run();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 删除后台任务
     */
    public static void removeTask(Task task) {
        if (task == null) {
            return;
        }
        try {
            task.cancel();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    /**
     * 有休眠
     * 后台耗时延迟任务
     */
    public static void runAsyncThread(Runnable run, long time) {
        try {
            final TimerTask timerTask = new TimerTask() {
                @Override
                public void run() {
                    try {
                        ExecutorService thread = getInstance().getIOThread();
                        if (!thread.isShutdown()) {
                            thread.execute(run);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            };
            TIMER.schedule(timerTask, time);
        } catch (Throwable e) {
            e.printStackTrace();
        }

    }

    public abstract static class Task implements ITask {

        private Thread thread;

        public abstract void doInBackground();

        private final AtomicBoolean isCancel = new AtomicBoolean();

        public Task() {
            isCancel.set(false);
        }

        @Override
        public void run() {
            thread = Thread.currentThread();
            try {
                if (!isCancel.get()) {
                    doInBackground();
                }
            } catch (Exception e) {
                e.printStackTrace();
                onError(e);
            }
            thread = null;
        }

        public void cancel() {
            try {
                isCancel.set(true);
                if (thread != null) {
                    thread.interrupt();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onError(Throwable t) {
            t.printStackTrace();
        }
    }


    public interface ITask extends Runnable {
        void onError(Throwable t);
    }


    public static class BackgroundRunsPolicy implements RejectedExecutionHandler {

        public BackgroundRunsPolicy() {
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                try {
                    backgroundRun(r);
                } catch (Exception e1) {
                    if (r instanceof ITask) {
                        ((ITask) r).onError(e1);
                    } else {
                        throw e1;
                    }

                }
            }
        }

        public void backgroundRun(Runnable runnable) {
            getInstance().getSingleThread().execute(new Runnable() {
                @Override
                public void run() {
                    runnable.run();
                }
            });

        }
    }


}