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

import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;

import androidx.annotation.NonNull;

import java.lang.reflect.Method;
import java.util.LinkedList;
import java.util.concurrent.Executor;


/**
 * Created by Tong on 2023/01/03.
 */
public class MainThreadExecutor implements Executor {

    private final LinkedList<Runnable> mQueue = new LinkedList<>();

    private final IdleHandlerImpl mHandler = new IdleHandlerImpl(Looper.getMainLooper());

    private final Handler mainHandler = new Handler(Looper.getMainLooper());

    private MessageQueue mMessageQueue;

    private MainThreadExecutor() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            mMessageQueue = Looper.getMainLooper().getQueue();
        } else {
            try {
                Method getQueue = Looper.class.getDeclaredMethod("getQueue");
                mMessageQueue = (MessageQueue) getQueue.invoke(Looper.getMainLooper());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static class SingletonInstance {
        private static final MainThreadExecutor INSTANCE = new MainThreadExecutor();
    }

    public static MainThreadExecutor getInstance() {
        return SingletonInstance.INSTANCE;
    }


    private class IdleHandlerImpl extends Handler implements MessageQueue.IdleHandler {

        public IdleHandlerImpl(@NonNull Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            Runnable r;
            synchronized (mQueue) {
                if (mQueue.size() == 0) {
                    return;
                }
                r = mQueue.removeFirst();
            }
            r.run();
            synchronized (mQueue) {
                scheduleNextLocked();
            }
        }

        @Override
        public boolean queueIdle() {
            handleMessage(null);
            //ture执行多次，false执行一次
            return false;
        }
    }

    private static class IdleRunnable implements Runnable {
        Runnable mRunnable;

        IdleRunnable(Runnable r) {
            mRunnable = r;
        }

        public void run() {
            mRunnable.run();
        }
    }


    @Override
    public void execute(Runnable command) {
        if (Looper.getMainLooper() == Looper.myLooper()) {
            command.run();
        } else {
            mainHandler.post(command);
        }
    }


    public void post(Runnable runnable) {
        synchronized (mQueue) {
            mQueue.add(runnable);
            if (mQueue.size() == 1) {
                scheduleNextLocked();
            }
        }
    }

    public void postIdle(final Runnable runnable) {
        post(new IdleRunnable(runnable));
    }

    public void postIdle(final Runnable runnable, long delayMillis) {
        mHandler.postDelayed(runnable, delayMillis);
    }

    public void cancelAll() {
        synchronized (mQueue) {
            mQueue.clear();
        }
    }

    public void flush() {
        LinkedList<Runnable> queue;
        synchronized (mQueue) {
            queue = new LinkedList<>(mQueue);
            mQueue.clear();
        }
        for (Runnable r : queue) {
            r.run();
        }
    }

    private void scheduleNextLocked() {
        if (mQueue.size() > 0) {
            Runnable peek = mQueue.getFirst();
            if (peek instanceof IdleRunnable) {
                if (mMessageQueue != null) {
                    mMessageQueue.addIdleHandler(mHandler);
                }

            } else {
                mHandler.sendEmptyMessage(1);
            }
        }
    }


}