package com.nodka.zysjtest;

import android.app.ZysjSystemManager;
import android.content.Context;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class WhiteListActivity extends BaseTestActivity {
    private static final String SERVICE_NOT_FOUND_MESSAGE = "未获取到 ZysjSystemManager 系统服务";

    private ZysjSystemManager zysjSystemManager;

    @Override
    protected String getPageTitle() {
        return "白名单接口测试";
    }

    @Override
    protected List<TestItem> getTestItems() {
        return Arrays.asList(
                new TestItem(
                        "应用白名单开关（限制安装）",
                        "whiteListSwitch",
                        "enable：true 表示开启限制安装白名单，false 表示关闭。",
                        true,
                        "enabled",
                        true,
                        this::whiteListSwitch),
                new TestItem(
                        "获取白名单开关状态（限制安装）",
                        "whiteListSwitchState",
                        "获取限制安装白名单开关状态。",
                        this::whiteListSwitchState),
                new TestItem(
                        "添加应用白名单（限制安装）",
                        "addWhiteList",
                        "list：应用包名列表，支持逗号、换行或空白分隔。",
                        this::addWhiteList,
                        TestItem.InputField.text(
                                "请输入 packageList",
                                "com.android.test0,com.android.test1",
                                "packageList")),
                new TestItem(
                        "删除应用白名单（限制安装）",
                        "deleteWhiteList",
                        "list：需要删除的应用包名列表，支持逗号、换行或空白分隔。",
                        this::deleteWhiteList,
                        TestItem.InputField.text(
                                "请输入 packageList",
                                "com.android.test0",
                                "packageList")),
                new TestItem(
                        "查询应用白名单（限制安装）",
                        "queryWhiteList",
                        "查询限制安装白名单列表。",
                        this::queryWhiteList),
                new TestItem(
                        "应用白名单开关（限制卸载）",
                        "whiteListSwitchUn",
                        "enable：true 表示开启限制卸载白名单，false 表示关闭。",
                        true,
                        "enabled",
                        true,
                        this::whiteListSwitchUn),
                new TestItem(
                        "获取白名单开关状态（限制卸载）",
                        "whiteListSwitchStateUn",
                        "获取限制卸载白名单开关状态。",
                        this::whiteListSwitchStateUn),
                new TestItem(
                        "添加应用白名单（限制卸载）",
                        "addWhiteListUn",
                        "list：应用包名列表，支持逗号、换行或空白分隔。",
                        this::addWhiteListUn,
                        TestItem.InputField.text(
                                "请输入 packageList",
                                "com.android.test0,com.android.test1",
                                "packageList")),
                new TestItem(
                        "删除应用白名单（限制卸载）",
                        "deleteWhiteListUn",
                        "list：需要删除的应用包名列表，支持逗号、换行或空白分隔。",
                        this::deleteWhiteListUn,
                        TestItem.InputField.text(
                                "请输入 packageList",
                                "com.android.test0",
                                "packageList")),
                new TestItem(
                        "查询应用白名单（限制卸载）",
                        "queryWhiteListUn",
                        "查询限制卸载白名单列表。",
                        this::queryWhiteListUn)
        );
    }

    private ZysjSystemManager zysjSystemManager() {
        if (zysjSystemManager != null) {
            return zysjSystemManager;
        }

        for (String serviceName : getServiceNameCandidates()) {
            Object service = getSystemService(serviceName);
            if (service instanceof ZysjSystemManager) {
                zysjSystemManager = (ZysjSystemManager) service;
                return zysjSystemManager;
            }
        }

        throw new IllegalStateException(SERVICE_NOT_FOUND_MESSAGE);
    }

    private List<String> getServiceNameCandidates() {
        List<String> candidates = new ArrayList<>();
        addContextFieldCandidate(candidates, "ZYSJ_SYSTEM_SERVICE");
        addContextFieldCandidate(candidates, "ZYSJ_SERVICE");
        candidates.add("zysj_system");
        candidates.add("zysj");
        candidates.add("zysj_system_service");
        return candidates;
    }

    private void addContextFieldCandidate(List<String> candidates, String fieldName) {
        try {
            Field field = Context.class.getField(fieldName);
            Object value = field.get(null);
            if (value instanceof String && !candidates.contains(value)) {
                candidates.add((String) value);
            }
        } catch (NoSuchFieldException ignored) {
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("读取 Context." + fieldName + " 失败", e);
        }
    }

    private String whiteListSwitch(TestItem item, String[] inputs) {
        try {
            zysjSystemManager().whiteListSwitch(item.switchChecked);
            return "whiteListSwitch 调用完成，enabled=" + item.switchChecked;
        } catch (Throwable e) {
            return formatError("whiteListSwitch", e);
        }
    }

    private String whiteListSwitchState(TestItem item, String[] inputs) {
        try {
            boolean ret = zysjSystemManager().whiteListSwitchState();
            return "whiteListSwitchState ret=" + ret;
        } catch (Throwable e) {
            return formatError("whiteListSwitchState", e);
        }
    }

    private String addWhiteList(TestItem item, String[] inputs) {
        try {
            List<String> list = parsePackageList(readInput(inputs, 0));
            if (list.isEmpty()) {
                return "参数错误：包名列表为空";
            }
            zysjSystemManager().addWhiteList(list);
            return "addWhiteList 调用完成，list=" + list;
        } catch (Throwable e) {
            return formatError("addWhiteList", e);
        }
    }

    private String deleteWhiteList(TestItem item, String[] inputs) {
        try {
            List<String> list = parsePackageList(readInput(inputs, 0));
            if (list.isEmpty()) {
                return "参数错误：包名列表为空";
            }
            zysjSystemManager().deleteWhiteList(list);
            return "deleteWhiteList 调用完成，list=" + list;
        } catch (Throwable e) {
            return formatError("deleteWhiteList", e);
        }
    }

    private String queryWhiteList(TestItem item, String[] inputs) {
        try {
            List list = zysjSystemManager().queryWhiteList();
            return "queryWhiteList ret=" + String.valueOf(list);
        } catch (Throwable e) {
            return formatError("queryWhiteList", e);
        }
    }

    private String whiteListSwitchUn(TestItem item, String[] inputs) {
        try {
            zysjSystemManager().whiteListSwitchUn(item.switchChecked);
            return "whiteListSwitchUn 调用完成，enabled=" + item.switchChecked;
        } catch (Throwable e) {
            return formatError("whiteListSwitchUn", e);
        }
    }

    private String whiteListSwitchStateUn(TestItem item, String[] inputs) {
        try {
            boolean ret = zysjSystemManager().whiteListSwitchStateUn();
            return "whiteListSwitchStateUn ret=" + ret;
        } catch (Throwable e) {
            return formatError("whiteListSwitchStateUn", e);
        }
    }

    private String addWhiteListUn(TestItem item, String[] inputs) {
        try {
            List<String> list = parsePackageList(readInput(inputs, 0));
            if (list.isEmpty()) {
                return "参数错误：包名列表为空";
            }
            zysjSystemManager().addWhiteListUn(list);
            return "addWhiteListUn 调用完成，list=" + list;
        } catch (Throwable e) {
            return formatError("addWhiteListUn", e);
        }
    }

    private String deleteWhiteListUn(TestItem item, String[] inputs) {
        try {
            List<String> list = parsePackageList(readInput(inputs, 0));
            if (list.isEmpty()) {
                return "参数错误：包名列表为空";
            }
            zysjSystemManager().deleteWhiteListUn(list);
            return "deleteWhiteListUn 调用完成，list=" + list;
        } catch (Throwable e) {
            return formatError("deleteWhiteListUn", e);
        }
    }

    private String queryWhiteListUn(TestItem item, String[] inputs) {
        try {
            List list = zysjSystemManager().queryWhiteListUn();
            return "queryWhiteListUn ret=" + String.valueOf(list);
        } catch (Throwable e) {
            return formatError("queryWhiteListUn", e);
        }
    }

    private List<String> parsePackageList(String input) {
        List<String> list = new ArrayList<>();
        if (input == null) {
            return list;
        }

        String[] parts = input.split("[,，\\n\\r\\s]+");
        for (String part : parts) {
            if (part == null) {
                continue;
            }
            String pkg = part.trim();
            if (!pkg.isEmpty()) {
                list.add(pkg);
            }
        }
        return list;
    }

    private String readInput(String[] inputs, int index) {
        if (index >= inputs.length) {
            return "";
        }
        return inputs[index];
    }

    private String formatError(String methodName, Throwable e) {
        return methodName + " 调用失败：" + e.getClass().getName() + ": " + e.getMessage();
    }
}