package com.xuexispace.ai.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.text.TextUtils;
import android.util.Log;

import androidx.annotation.NonNull;

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;
import com.tencent.mmkv.MMKV;
import com.xuexispace.ai.BuildConfig;
import com.xuexispace.ai.bean.BaseResponse;
import com.xuexispace.ai.config.CommonConfig;
import com.xuexispace.ai.network.NetInterfaceManager;

import java.io.Serializable;
import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;

public class AppUsedTimeUtils {
    private static final String TAG = "AppUsedTimeUtils";

    @SuppressLint("StaticFieldLeak")
    private static AppUsedTimeUtils sInstance;
    private Context mContext;
    private MMKV mMMKV = MMKV.mmkvWithID(CommonConfig.MMKV_ID, MMKV.MULTI_PROCESS_MODE);

    private SimpleDateFormat ruleSDF = new SimpleDateFormat("HH:mm:ss");
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private AppTimeinfo appTimeinfo;
    private static final String RUNNING_APP_INFO_KEY = "running_app_info";

    private AppUsedTimeUtils(Context context) {
        this.mContext = context;
        appTimeinfo = getAppTimeinfo();
    }

    public static void init(Context context) {
        if (sInstance == null) {
            sInstance = new AppUsedTimeUtils(context);
        }
    }

    public static AppUsedTimeUtils getInstance() {
        if (sInstance == null) {
            throw new IllegalStateException("You must be init TimeUtils first");
        }
        return sInstance;
    }

    private static String normalStartTime = "8:00:00";
    private static String unusualStartTime = "22:00:00";

    static class AppTimeinfo implements Serializable {
        private static final long serialVersionUID = 5373751133823666192L;

        AppTimeinfo() {
            this.appPackageName = "";
            this.endTime = 0;
            this.startTime = 0;
        }

        private String appPackageName;
        private long endTime;
        private long startTime;

        public String getAppPackageName() {
            return appPackageName;
        }

        public void setAppPackageName(String appPackageName) {
            this.appPackageName = appPackageName;
        }

        public long getEndTime() {
            return endTime;
        }

        public void setEndTime(long endTime) {
            this.endTime = endTime;
        }

        public long getStartTime() {
            return startTime;
        }

        public void setStartTime(long startTime) {
            this.startTime = startTime;
        }

        @NonNull
        @Override
        public String toString() {
            return JsonParser.parseString(new Gson().toJson(this)).getAsJsonObject().toString();
        }
    }

    synchronized public void setAppPackageName(String name) {
        appTimeinfo.setAppPackageName(name);
        setAppTimeinfo();
    }

    synchronized public String getAppPackageName() {
        return appTimeinfo.getAppPackageName();
    }

    synchronized public void setStartTime(long time) {
        appTimeinfo.setStartTime(time);
        setAppTimeinfo();
    }

    synchronized public long getStartTime() {
        return appTimeinfo.getStartTime();
    }

    synchronized public void setEndTime(long time) {
        appTimeinfo.setEndTime(time);
        setAppTimeinfo();
    }

    synchronized public long getEndTime() {
        return appTimeinfo.getEndTime();
    }

    synchronized private AppTimeinfo getAppTimeinfo() {
        String jsonString = mMMKV.decodeString(RUNNING_APP_INFO_KEY);
        if (TextUtils.isEmpty(jsonString)) {
            return new AppTimeinfo();
        }
        Log.e(TAG, "getAppTimeinfo: " + jsonString);
        Type type = new TypeToken<AppTimeinfo>() {
        }.getType();
        Gson gson = new Gson();
        AppTimeinfo appTimeinfo = gson.fromJson(jsonString, type);
        return appTimeinfo;
    }

    synchronized private void setAppTimeinfo() {
        String jsonString = JsonParser.parseString(appTimeinfo.toString()).getAsJsonObject().toString();
        mMMKV.encode(RUNNING_APP_INFO_KEY, jsonString);
    }

    private static final long DAY_TIME = 1000 * 60 * 60 * 24;

    public boolean isNormalTime() {
        long nowTime = System.currentTimeMillis();
        String nowTimeString = ruleSDF.format(new Date(nowTime)); // 时间戳转换日期
        try {
            Date startDate = ruleSDF.parse(normalStartTime);
            Date endDate = ruleSDF.parse(unusualStartTime);
            Date now = ruleSDF.parse(nowTimeString);
            Log.e(TAG, "isScreenshot: startDate = " + startDate);
            Log.e(TAG, "isScreenshot: endDate = " + endDate);
            Log.e(TAG, "isScreenshot: now = " + now);
            if (startDate.getTime() <= now.getTime() && now.getTime() <= endDate.getTime()) {
                return true;
            } else if (endDate.getTime() < now.getTime() && now.getTime() <= startDate.getTime() + DAY_TIME) {
                return false;
            }
        } catch (ParseException e) {
            e.printStackTrace();
            Log.e(TAG, "isScreenshot: " + e.getMessage());
        }
        return false;
    }

    public interface RunningAppCallback {
        void onComplete();
    }

    public void sendRunningApp(RunningAppCallback runningAppCallback) {
        boolean activation = ActivationUtil.getInstance().isActivation();
        if (!activation) {
            return;
        }
        String packageName = getAppPackageName();
        if (BuildConfig.APPLICATION_ID.equals(packageName)) {
            return;
        }
        long time = getStartTime();
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("app_package", packageName);
        jsonObject.addProperty("version_name", ApkUtils.getAPPVersionName(mContext, packageName));
        jsonObject.addProperty("start_time", time / 1000);
        String jsonString = jsonObject.toString();
        Log.e(TAG, "SendRunningApp: " + jsonString);
        NetInterfaceManager.getInstance()
                .getRunningAppObservable(jsonString)
                .subscribe(new Observer<BaseResponse>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e("SendRunningApp", "onSubscribe: ");
                    }

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

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

                    @Override
                    public void onComplete() {
                        Log.e("SendRunningApp", "onComplete: ");
                        if (runningAppCallback != null) {
                            runningAppCallback.onComplete();
                        }
                    }
                });
    }
}