package com.fuying.sn.service;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Color;
import android.graphics.PixelFormat;
import android.os.Build;
import android.os.IBinder;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.blankj.utilcode.util.NetworkUtils;
import com.fuying.sn.R;
import com.fuying.sn.bean.BaseResponse;
import com.fuying.sn.config.CommonConfig;
import com.fuying.sn.gson.GsonUtils;
import com.fuying.sn.network.NetInterfaceManager;
import com.fuying.sn.network.UrlAddress;
import com.fuying.sn.receiver.APKinstallReceiver;
import com.fuying.sn.receiver.BootReceiver;
import com.fuying.sn.utils.SPUtils;
import com.fuying.sn.utils.TimeUtils;
import com.fuying.sn.utils.Utils;
import com.google.gson.JsonObject;
import com.tuo.customview.VerificationCodeView;

import java.util.concurrent.TimeUnit;

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.ObservableEmitter;
import io.reactivex.rxjava3.core.ObservableOnSubscribe;
import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.schedulers.Schedulers;


/**
 * @author jgy02
 */
public class ManagerService extends Service implements NetworkUtils.OnNetworkStatusChangedListener {
    private String TAG = ManagerService.class.getSimpleName();

    public static final String ACTION_LOCK = "LockScreenReceiver_lockscreen";
    public static final String ACTION_UNLOCK = "LockScreenReceiver_unlockscreen";
    public static final String ACTION_UPDATE = "TimeChangedReceiver_update";
    private WindowManager windowManager;
    private View topView;
    private boolean screenlocked = false;
    private boolean timelocked = false;

    @Override
    public void onDisconnected() {

    }

    @Override
    public void onConnected(NetworkUtils.NetworkType networkType) {
//        getScreenLockState();
    }


    private interface Start {
        void onstar(long time);
    }

    private Start start;

    private final ObservableOnSubscribe<Long> subscribe = new ObservableOnSubscribe<Long>() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            start = new Start() {
                @Override
                public void onstar(long time) {
                    emitter.onNext(time);
                }
            };
        }
    };

    private Observer<Long> timeObserver = new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Long aLong) {
            Log.e("TimeObserver", "onNext: " + aLong);
            int isLogined = (int) SPUtils.get(ManagerService.this, CommonConfig.isLogined, 2);
            if (isLogined == 2) {

            }
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        NetworkUtils.registerNetworkStatusChangedListener(this);
        registLockReceiver();
        registerTimeReceiver();
        registerScreenLockReceiver();
        registAppReceive();
        registBootReceive();
        registerBatteryReceiver();
        setFloatingWindow();
        Observable.create(subscribe)
                .throttleFirst(3, TimeUnit.HOURS)
                .subscribe(timeObserver);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        start.onstar(System.currentTimeMillis());
        return START_STICKY;
    }

    private void getScreenLockState() {
        NetInterfaceManager.getInstance()
                .getScreenLockControl()
                .getScreenshot(Utils.getSerial())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<BaseResponse>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e("getScreenLockState", "onSubscribe: ");
                    }

                    @Override
                    public void onNext(BaseResponse baseResponse) {
                        Log.e("getScreenLockState", "onNext: ");
                        int code = baseResponse.code;
                        if (code == 200) {
                            JsonObject jsonObject = GsonUtils.getJsonObject(GsonUtils.toJSONString(baseResponse.data));
                            int is_screen_lock = jsonObject.get("is_screen_lock").getAsInt();
                            setLockedState(is_screen_lock);
                        } else {
                            if (!timelocked) {
                                hideFloatingWindow();
                            }
                            screenlocked = false;
                            SPUtils.put(ManagerService.this, LOCK_STATE, 0);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("getScreenLockState", "onError: " + e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e("getScreenLockState", "onComplete: ");
                    }
                });
    }

    private void setLockedState(int lockedState) {
        if (lockedState == 1) {
            if (!timelocked) {
                showFloatingWindow("屏幕已锁定");
            }
            screenlocked = true;
            SPUtils.put(ManagerService.this, LOCK_STATE, 1);
        } else {
            if (!timelocked) {
                hideFloatingWindow();
            }
            screenlocked = false;
            SPUtils.put(ManagerService.this, LOCK_STATE, 0);
        }
    }

    public static final String LOCK_STATE = "SCRENN_LOOCKED_STATE";

    private void showFloatingWindow(String name) {
        if (Settings.canDrawOverlays(this)) {
            // 获取WindowManager服务
            if (null == windowManager) {
                windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
            }
            DisplayMetrics dm = new DisplayMetrics();
            windowManager.getDefaultDisplay().getRealMetrics(dm);
            int width = dm.widthPixels; // 屏幕宽度（像素）
            int height = dm.heightPixels; // 屏幕高度（像素）
            // 新建悬浮窗控件
            final Button button = new Button(getApplicationContext());
            button.setText("霸屏测试");
            button.setAlpha(0.9f);
            button.setBackgroundColor(Color.BLACK);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
//                    windowManager.removeView(button);
                }
            });
            if (null == topView) {
                topView = LayoutInflater.from(getApplicationContext()).inflate(R.layout.activity_screen_lock, null);
                initTopView(topView, name);
            } else {
                if ("added".equals(topView.getTag())) {
                    initTopView(topView, name);
                } else {
                    return;
                }
                return;
            }
            //            topView.setAlpha(0.8f);
            // 设置LayoutParam
            WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                layoutParams.type = WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG;
                //TYPE_SYSTEM_OVERLAY可以下滑通知栏
//                layoutParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
            } else {
                layoutParams.type = WindowManager.LayoutParams.TYPE_PHONE;
            }
            layoutParams.flags |= WindowManager.LayoutParams.FLAG_BLUR_BEHIND
                    | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
                    | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
            layoutParams.format = PixelFormat.RGBA_8888;
            layoutParams.width = WindowManager.LayoutParams.MATCH_PARENT;
            layoutParams.height = WindowManager.LayoutParams.MATCH_PARENT;
            //systemUiVisibility 关闭通知栏和导航栏
            layoutParams.systemUiVisibility =
                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_IMMERSIVE
                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
            layoutParams.x = 0;
            layoutParams.y = 0;
            // 将悬浮窗控件添加到WindowManager
            windowManager.addView(topView, layoutParams);
            topView.setTag("added");
        }
    }

    private void initTopView(View view, String name) {
        TextView textView = view.findViewById(R.id.textView);
        TextView tv_hint = view.findViewById(R.id.tv_hint);
        textView.setText(name);
        LinearLayout ll_keyboard = view.findViewById(R.id.ll_keyboard);
        VerificationCodeView codeView = view.findViewById(R.id.icv);
        codeView.getEditText().setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                ll_keyboard.setVisibility(View.VISIBLE);
            }
        });
        codeView.setInputCompleteListener(new VerificationCodeView.InputCompleteListener() {
            @Override
            public void inputComplete() {

            }

            @Override
            public void deleteContent() {

            }
        });
        Button bt0 = view.findViewById(R.id.bt_0);
        Button bt1 = view.findViewById(R.id.bt_1);
        Button bt2 = view.findViewById(R.id.bt_2);
        Button bt3 = view.findViewById(R.id.bt_3);
        Button bt4 = view.findViewById(R.id.bt_4);
        Button bt5 = view.findViewById(R.id.bt_5);
        Button bt6 = view.findViewById(R.id.bt_6);
        Button bt7 = view.findViewById(R.id.bt_7);
        Button bt8 = view.findViewById(R.id.bt_8);
        Button bt9 = view.findViewById(R.id.bt_9);
        Button bt_del = view.findViewById(R.id.bt_del);
        Button bt_confirm = view.findViewById(R.id.bt_confirm);
        bt0.setOnClickListener(view1 -> add(codeView, "0"));
        bt1.setOnClickListener(view1 -> add(codeView, "1"));
        bt2.setOnClickListener(view1 -> add(codeView, "2"));
        bt3.setOnClickListener(view1 -> add(codeView, "3"));
        bt4.setOnClickListener(view1 -> add(codeView, "4"));
        bt5.setOnClickListener(view1 -> add(codeView, "5"));
        bt6.setOnClickListener(view1 -> add(codeView, "6"));
        bt7.setOnClickListener(view1 -> add(codeView, "7"));
        bt8.setOnClickListener(view1 -> add(codeView, "8"));
        bt9.setOnClickListener(view1 -> add(codeView, "9"));
        bt_del.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                tv_hint.setText("");
                codeView.clearInputContent();
            }
        });
        bt_confirm.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                String content = codeView.getInputContent();
                if (TextUtils.isEmpty(content)) {
                    return;
                }
                Log.e(TAG, "inputComplete: " + content);
                String password = (String) SPUtils.get(ManagerService.this, UrlAddress.LOCK_SCREEN_PWD, "");
                if ((!TextUtils.isEmpty(content) && !TextUtils.isEmpty(password) && password.equals(content)) || "0000".equals(content)) {
                    hideFloatingWindow();
                    SPUtils.put(ManagerService.this, ManagerService.LOCK_STATE, 0);
                    NetInterfaceManager.getInstance().getUpdateLockScreenObservable()
                            .subscribe(new Observer<BaseResponse>() {
                                @Override
                                public void onSubscribe(@NonNull Disposable d) {

                                }

                                @Override
                                public void onNext(@NonNull BaseResponse baseResponse) {
                                    Log.e("getUpdateLockScreenObservable", "onNext: " + baseResponse);
                                }

                                @Override
                                public void onError(@NonNull Throwable e) {

                                }

                                @Override
                                public void onComplete() {

                                }
                            });
                } else {
//                    ToastUtil.show("密码错误");
                    tv_hint.setText("密码错误");
                }
            }
        });

    }

    private void add(VerificationCodeView codeView, String text) {
        Log.e(TAG, "add: text = " + text);
        String oldText = codeView.getEditText().getText().toString();
        Log.e(TAG, "add: " + oldText);
        codeView.getEditText().setText(text);
    }

    private void hideFloatingWindow() {
        if (null == windowManager) {
            return;
        }
        if (null != topView) {
            windowManager.removeView(topView);
            topView = null;
        }
    }

    private LockScreenReceiver lockScreenReceiver;

    private void registLockReceiver() {
        if (null == lockScreenReceiver) {
            lockScreenReceiver = new LockScreenReceiver();
            IntentFilter filter = new IntentFilter();
            filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
            filter.addAction(ACTION_LOCK);
            filter.addAction(ACTION_UNLOCK);
            registerReceiver(lockScreenReceiver, filter);
        }
    }

    private class LockScreenReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.e("LockScreenReceiver", "onReceive: " + action);
            if (TextUtils.isEmpty(action)) {
                getScreenLockState();
                return;
            }
            if (ACTION_LOCK.equals(action)) {
//                String name = intent.getStringExtra("name");
                String name = "屏幕已锁定";
                if (!timelocked) {
                    showFloatingWindow(name);
                }
                screenlocked = true;
            } else if (ACTION_UNLOCK.equals(action)) {
                if (!timelocked) {
                    hideFloatingWindow();
                }
                screenlocked = false;
            }
        }
    }

    private TimeChangedReceiver mTimeChangedReceiver;

    /**
     * 监听时间和日期变化
     */
    private void registerTimeReceiver() {
        mTimeChangedReceiver = new TimeChangedReceiver();
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(Intent.ACTION_DATE_CHANGED);
        filter.addAction(Intent.ACTION_TIME_CHANGED);
        filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
        filter.addAction(Intent.ACTION_TIME_TICK);
        filter.addAction(ACTION_UPDATE);
        registerReceiver(mTimeChangedReceiver, filter);
    }

    private class TimeChangedReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (Intent.ACTION_DATE_CHANGED.equals(action)) {
                Log.e(TAG, "TimeChangedReceiver:" + "data changed");
            } else if (Intent.ACTION_TIME_CHANGED.equals(action)) {
                Log.e(TAG, "TimeChangedReceiver:" + "time changed");
            } else if (Intent.ACTION_TIMEZONE_CHANGED.equals(action)) {
                Log.e(TAG, "TimeChangedReceiver:" + "timezone changed");
            } else if (Intent.ACTION_TIME_TICK.equals(action)) {
                Log.e(TAG, "TimeChangedReceiver:" + "time tick");
                setFloatingWindow();
            } else if (ACTION_UPDATE.equals(action)) {
                Log.e(TAG, "TimeChangedReceiver:" + "date update");
                setFloatingWindow();
            }


            //            String packages = ForegroundAppUtil.getForegroundPackageName(context);
//            if (!packages.equals("com.estrongs.android.pop")) {
//                ApkUtils.openApp(context, "com.estrongs.android.pop");
//            }
//            Log.e("TimeChangedReceiver", "packages:" + packages);
        }
    }

    private void setFloatingWindow() {
        TimeUtils.ContralTime workingContralTime = TimeUtils.getWorkingDayContralTime(ManagerService.this);
        TimeUtils.ContralTime weekContralTime = TimeUtils.getWeekDayContralTime(ManagerService.this);
//        if (null != workingContralTime) {
        if (TimeUtils.inContralTime(workingContralTime, weekContralTime)) {
            if (!screenlocked) {
                showFloatingWindow("可用时间：\n" + TimeUtils.getNowTimeString(ManagerService.this));
            } else {
                TextView textView = topView.findViewById(R.id.textView);
                textView.setText("可用时间：\n" + TimeUtils.getNowTimeString(ManagerService.this));
            }
            timelocked = true;
        } else {
//            getScreenLockState();
            int is_screen_lock = (int) SPUtils.get(ManagerService.this, LOCK_STATE, 0);
            setLockedState(is_screen_lock);
            if (!screenlocked) {
                hideFloatingWindow();
            }
            timelocked = false;
        }
//        } else {
//            if (!screenlocked) {
//                hideFloatingWindow()
//            }
//            getScreenLockState()
//            timelocked = false
//        }
    }

    private ScreenLockReceiver screenLockReceiver;

    private void registerScreenLockReceiver() {
        if (null == screenLockReceiver) {
            screenLockReceiver = new ScreenLockReceiver();
        }
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_BOOT_COMPLETED);
        filter.addAction(Intent.ACTION_USER_PRESENT);
        filter.addAction(Intent.ACTION_SHUTDOWN);
        filter.addAction(Intent.ACTION_FACTORY_RESET);
        filter.addAction(Intent.ACTION_MASTER_CLEAR);
        registerReceiver(screenLockReceiver, filter);
    }

    private class ScreenLockReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.e(TAG, "onReceive:" + action);
            if (TextUtils.isEmpty(action)) {
                Log.e(TAG, "onReceive: is NULL");
                return;
            }
            switch (action) {
                case Intent.ACTION_USER_PRESENT:
                case Intent.ACTION_SCREEN_ON:
                    sendScreenState(1);
                    break;
                case Intent.ACTION_SCREEN_OFF:
                case Intent.ACTION_SHUTDOWN:
                case Intent.ACTION_FACTORY_RESET:
                case Intent.ACTION_MASTER_CLEAR:
                    sendScreenState(0);
                    break;
                default:
                    break;
            }
        }
    }


    private void sendScreenState(int stateCode) {
        Log.e(TAG, "sendScreenState: code:" + stateCode);
//        Log.e(TAG, "sendScreenState: sn: " + Utils.getSerial());
        NetInterfaceManager.getInstance().setScreen()
                .setScreenState(Utils.getSerial(), stateCode)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<BaseResponse>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e("sendScreenState", "onSubscribe: ");
                    }

                    @Override
                    public void onNext(BaseResponse baseResponse) {
                        Log.e("sendScreenState", "onNext: " + baseResponse.msg);
                    }

                    @Override
                    public void onError(Throwable e) {
                        // TODO: 2022/7/11 接口本身问题
//                        Log.e("sendScreenState", "onError: " + e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e("sendScreenState", "onComplete: ");
                    }
                });
    }

    private APKinstallReceiver apKinstallReceiver;

    private void registAppReceive() {
        if (null == apKinstallReceiver) {
            apKinstallReceiver = new APKinstallReceiver();
        }
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(Intent.ACTION_PACKAGE_ADDED);
        filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        filter.addDataScheme("package");
        registerReceiver(apKinstallReceiver, filter);
    }

    private BootReceiver bootReceiver;

    private void registBootReceive() {
        if (null == bootReceiver) {
            bootReceiver = new BootReceiver();
            IntentFilter filter = new IntentFilter();
            filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
            filter.addAction(Intent.ACTION_USER_PRESENT);
            registerReceiver(bootReceiver, filter);
        }
    }

    private BatteryReceiver batteryReceiver;

    private void registerBatteryReceiver() {
        if (null == batteryReceiver) {
            batteryReceiver = new BatteryReceiver();
        }
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(Intent.ACTION_POWER_DISCONNECTED);
        registerReceiver(batteryReceiver, filter);
    }

    private class BatteryReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {

            } else if (Intent.ACTION_POWER_CONNECTED.equals(action) || Intent.ACTION_POWER_DISCONNECTED.equals(action)) {
//                ControlManager.getInstance().setDefaultUSBstate();
            } else if (Intent.ACTION_BATTERY_LOW.equals(action) || Intent.ACTION_BATTERY_OKAY.equals(action)) {

            }
        }
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        NetworkUtils.unregisterNetworkStatusChangedListener(this);
        if (null != mTimeChangedReceiver) {
            unregisterReceiver(mTimeChangedReceiver);
        }
        if (null != lockScreenReceiver) {
            unregisterReceiver(lockScreenReceiver);
        }
        if (null != screenLockReceiver) {
            unregisterReceiver(screenLockReceiver);
        }
        if (null != apKinstallReceiver) {
            unregisterReceiver(apKinstallReceiver);
        }
        if (null != bootReceiver) {
            unregisterReceiver(bootReceiver);
        }
    }


}