package com.zy.system.entity.license;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class LicenseBindingSupport {

    private LicenseBindingSupport() {
    }

    public static boolean isV2Extra(Object extra) {
        if (extra == null) {
            return false;
        }
        if (extra instanceof LicenseBindModel) {
            return true;
        }
        if (extra instanceof JSONObject) {
            return isV2Json((JSONObject) extra);
        }
        if (extra instanceof String) {
            String text = ((String) extra).trim();
            if (isBlank(text) || !text.startsWith("{")) {
                return false;
            }
            return isV2Json(JSON.parseObject(text));
        }
        return false;
    }

    public static LicenseBindModel parseBindModel(Object extra) {
        if (extra == null) {
            return null;
        }
        if (extra instanceof LicenseBindModel) {
            return normalizeBindModel((LicenseBindModel) extra);
        }
        if (extra instanceof JSONObject) {
            return normalizeBindModel(((JSONObject) extra).toJavaObject(LicenseBindModel.class));
        }
        if (extra instanceof String) {
            String text = ((String) extra).trim();
            if (isBlank(text)) {
                return null;
            }
            return normalizeBindModel(JSON.parseObject(text, LicenseBindModel.class));
        }
        return normalizeBindModel(JSON.parseObject(JSON.toJSONString(extra), LicenseBindModel.class));
    }

    public static LicenseCheck parseLegacyLicenseCheck(Object extra) {
        if (extra == null) {
            return null;
        }
        if (extra instanceof LicenseCheck) {
            return (LicenseCheck) extra;
        }
        if (extra instanceof JSONObject) {
            return ((JSONObject) extra).toJavaObject(LicenseCheck.class);
        }
        if (extra instanceof String) {
            String text = ((String) extra).trim();
            if (isBlank(text)) {
                return null;
            }
            return JSON.parseObject(text, LicenseCheck.class);
        }
        return JSON.parseObject(JSON.toJSONString(extra), LicenseCheck.class);
    }

    public static boolean matches(LicenseBindModel licenseBind, LicenseCheck serverCheck) {
        if (licenseBind == null) {
            return false;
        }
        if ("UNLIMITED".equalsIgnoreCase(trimToEmpty(licenseBind.getBindMode()))) {
            return true;
        }
        List<LicenseNodeCheck> nodes = licenseBind.getNodes();
        if (nodes == null || nodes.isEmpty()) {
            return true;
        }
        for (LicenseNodeCheck node : nodes) {
            if (matchesNode(node, serverCheck)) {
                return true;
            }
        }
        return false;
    }

    private static boolean isV2Json(JSONObject jsonObject) {
        if (jsonObject == null) {
            return false;
        }
        return jsonObject.containsKey("nodes")
                || jsonObject.containsKey("bindMode")
                || jsonObject.containsKey("matchMode")
                || Integer.valueOf(2).equals(jsonObject.getInteger("version"));
    }

    private static LicenseBindModel normalizeBindModel(LicenseBindModel source) {
        if (source == null) {
            return null;
        }
        LicenseBindModel target = new LicenseBindModel();
        target.setVersion(source.getVersion() == null ? 2 : source.getVersion());
        target.setBindMode(isBlank(source.getBindMode()) ? "MULTI_NODE" : source.getBindMode().trim());
        target.setMatchMode(isBlank(source.getMatchMode()) ? "ANY" : source.getMatchMode().trim());

        List<LicenseNodeCheck> normalizedNodes = new ArrayList<>();
        if (source.getNodes() != null) {
            for (LicenseNodeCheck node : source.getNodes()) {
                if (node == null) {
                    continue;
                }
                LicenseNodeCheck normalizedNode = new LicenseNodeCheck();
                normalizedNode.setNodeId(trimToEmpty(node.getNodeId()));
                normalizedNode.setIpAddress(normalizeList(node.getIpAddress(), false));
                normalizedNode.setMacAddress(normalizeList(node.getMacAddress(), true));
                normalizedNode.setCpuSerial(trimToEmpty(node.getCpuSerial()));
                normalizedNode.setMainBoardSerial(trimToEmpty(node.getMainBoardSerial()));
                normalizedNodes.add(normalizedNode);
            }
        }
        target.setNodes(normalizedNodes);
        return target;
    }

    private static boolean matchesNode(LicenseNodeCheck node, LicenseCheck serverCheck) {
        if (node == null || serverCheck == null) {
            return false;
        }
        if (!checkList(node.getIpAddress(), serverCheck.getIpAddress())) {
            return false;
        }
        if (!checkList(node.getMacAddress(), serverCheck.getMacAddress())) {
            return false;
        }
        if (!checkSerial(node.getMainBoardSerial(), serverCheck.getMainBoardSerial())) {
            return false;
        }
        return checkSerial(node.getCpuSerial(), serverCheck.getCpuSerial());
    }

    private static boolean checkList(List<String> expectedList, List<String> actualList) {
        if (expectedList == null || expectedList.isEmpty()) {
            return true;
        }
        if (actualList == null || actualList.isEmpty()) {
            return false;
        }
        for (String expected : expectedList) {
            if (!isBlank(expected) && actualList.contains(expected.trim())) {
                return true;
            }
        }
        return false;
    }

    private static boolean checkSerial(String expectedSerial, String actualSerial) {
        if (isBlank(expectedSerial)) {
            return true;
        }
        return !isBlank(actualSerial) && expectedSerial.equals(actualSerial);
    }

    private static List<String> normalizeList(List<String> values, boolean upperCase) {
        List<String> result = new ArrayList<>();
        if (values == null || values.isEmpty()) {
            return result;
        }
        for (String value : values) {
            if (isBlank(value)) {
                continue;
            }
            String normalized = value.trim();
            normalized = upperCase ? normalized.toUpperCase() : normalized.toLowerCase();
            if (!result.contains(normalized)) {
                result.add(normalized);
            }
        }
        Collections.sort(result);
        return result;
    }

    private static boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }

    private static String trimToEmpty(String value) {
        return value == null ? "" : value.trim();
    }
}