package cn.wandersnail.commons.base;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.Application;
import android.content.Context;
import android.os.Bundle;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * AppHolder - 全局 Application 和 Activity 管理工具类
 *
 * 功能：
 * 1. 全局持有 Application 上下文。
 * 2. 管理所有 Activity 的生命周期。
 * 3. 支持 Fragment 生命周期监听。
 * 4. 提供应用状态判断、Activity 操作等功能。
 *
 * 使用方式：
 * 1. 在 Application 中初始化：AppHolder.initialize(this);
 * 2. 通过 AppHolder.getInstance() 获取单例对象。
 */
public class AppHolder extends FragmentManager.FragmentLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

    // 单例实例
    private static final class Holder {
        private static final AppHolder INSTANCE = new AppHolder();
    }

    // 正在运行的 Activity 信息
    private static class RunningActivity {
        String name; // Activity 类名
        WeakReference<Activity> weakActivity; // Activity 弱引用

        RunningActivity(String name, WeakReference<Activity> weakActivity) {
            this.name = name;
            this.weakActivity = weakActivity;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof RunningActivity)) return false;
            RunningActivity that = (RunningActivity) o;
            return name.equals(that.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }

    // 成员变量
    private final Map<String, RunningActivity> runningActivities = new ConcurrentHashMap<>(); // 正在运行的 Activity
    private final Map<String, WeakReference<Fragment>> runningFragments = new ConcurrentHashMap<>(); // 正在运行的 Fragment
    private boolean isCompleteExit = false; // 是否完全退出
    private Application application; // Application 实例
    private Looper mainLooper; // 主线程 Looper
    private RunningActivity topActivity; // 栈顶 Activity

    // 私有构造方法
    private AppHolder() {
        mainLooper = Looper.getMainLooper();
    }

    /**
     * 获取 AppHolder 单例实例
     */
    @NonNull
    public static AppHolder getInstance() {
        return Holder.INSTANCE;
    }

    /**
     * 初始化 AppHolder
     *
     * @param application Application 实例
     */
    public static void initialize(@NonNull Application application) {
        Objects.requireNonNull(application, "Application cannot be null");
        Holder.INSTANCE.application = application;
        application.registerActivityLifecycleCallbacks(Holder.INSTANCE);
    }

    /**
     * 获取全局上下文
     */
    @NonNull
    public Context getContext() {
        if (application == null) {
            throw new IllegalStateException("AppHolder has not been initialized. Call AppHolder.initialize(app) first.");
        }
        return application;
    }

    /**
     * 判断当前是否在主线程
     */
    public boolean isMainThread() {
        return Looper.myLooper() == mainLooper;
    }

    /**
     * 获取主线程 Looper
     */
    @NonNull
    public Looper getMainLooper() {
        return mainLooper;
    }

    /**
     * 判断应用是否在前台
     */
    public boolean isAppOnForeground() {
        ActivityManager am = (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
        if (am != null) {
            List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses();
            if (processes != null) {
                for (ActivityManager.RunningAppProcessInfo process : processes) {
                    if (application.getPackageName().equals(process.processName)) {
                        return process.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 获取栈顶 Activity
     */
    @Nullable
    public Activity getTopActivity() {
        return topActivity == null ? null : topActivity.weakActivity.get();
    }

    /**
     * 获取所有正在运行的 Activity
     */
    @NonNull
    public List<Activity> getAllActivities() {
        List<Activity> activities = new ArrayList<>();
        for (RunningActivity runningActivity : runningActivities.values()) {
            Activity activity = runningActivity.weakActivity.get();
            if (activity != null) {
                activities.add(activity);
            }
        }
        return activities;
    }

    /**
     * 关闭指定 Activity
     *
     * @param className  目标 Activity 类名
     * @param classNames 其他目标 Activity 类名（可选）
     */
    public void finish(@NonNull String className, @Nullable String... classNames) {
        for (RunningActivity runningActivity : runningActivities.values()) {
            Activity activity = runningActivity.weakActivity.get();
            if (activity != null && (activity.getClass().getName().equals(className) || contains(classNames, activity.getClass().getName()))) {
                activity.finish();
            }
        }
    }

    /**
     * 关闭所有 Activity
     */
    public void finishAll() {
        for (RunningActivity runningActivity : runningActivities.values()) {
            Activity activity = runningActivity.weakActivity.get();
            if (activity != null) {
                activity.finish();
            }
        }
    }

    /**
     * 完全退出应用
     */
    public void completeExit() {
        isCompleteExit = true;
        finishAll();
        if (runningActivities.isEmpty()) {
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(0);
        }
    }

    // Activity 生命周期回调
    @Override
    public void onActivityCreated(@NonNull Activity activity, Bundle savedInstanceState) {
        RunningActivity runningActivity = new RunningActivity(activity.getClass().getName(), new WeakReference<>(activity));
        runningActivities.put(activity.getClass().getName(), runningActivity);
        topActivity = runningActivity;
    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {
        runningActivities.remove(activity.getClass().getName());
        if (isCompleteExit && runningActivities.isEmpty()) {
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(0);
        }
    }

    // 其他生命周期方法（略）
    @Override
    public void onActivityStarted(@NonNull Activity activity) {}
    @Override
    public void onActivityResumed(@NonNull Activity activity) {}
    @Override
    public void onActivityPaused(@NonNull Activity activity) {}
    @Override
    public void onActivityStopped(@NonNull Activity activity) {}
    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {}

    // Fragment 生命周期回调（略）
    @Override
    public void onFragmentCreated(@NonNull FragmentManager fm, @NonNull Fragment f, @Nullable Bundle savedInstanceState) {
        runningFragments.put(f.getClass().getName(), new WeakReference<>(f));
    }

    @Override
    public void onFragmentDestroyed(@NonNull FragmentManager fm, @NonNull Fragment f) {
        runningFragments.remove(f.getClass().getName());
    }

    // 工具方法：判断数组是否包含某元素
    private boolean contains(String[] array, String value) {
        if (array != null) {
            for (String item : array) {
                if (item.equals(value)) {
                    return true;
                }
            }
        }
        return false;
    }
}