package com.zy.ai.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zy.ai.entity.AiAutoTuneChange;
import com.zy.ai.entity.AiAutoTuneJob;
import com.zy.ai.entity.AiAutoTuneMcpCall;

import java.util.List;
import java.util.Locale;
import java.util.Map;

public final class AutoTuneWriteBehaviorUtils {

    public static final String WRITE_ANALYSIS_ONLY = "analysis_only";
    public static final String WRITE_DRY_RUN = "dry_run";
    public static final String WRITE_APPLY = "apply";
    public static final String WRITE_ROLLBACK = "rollback";
    public static final String WRITE_NO_CHANGE = "no_change";
    public static final String WRITE_READ_ONLY = "read_only";
    public static final String WRITE_FAILED = "failed";
    public static final String WRITE_REJECTED = "rejected";
    public static final String WRITE_UNKNOWN = "unknown";

    private AutoTuneWriteBehaviorUtils() {
    }

    public static void addWriteBehavior(Map<String, Object> item, String writeBehavior) {
        String safeWriteBehavior = isBlank(writeBehavior) ? WRITE_UNKNOWN : writeBehavior;
        item.put("writeBehavior", safeWriteBehavior);
        item.put("writeBehaviorLabel", writeBehaviorLabel(safeWriteBehavior));
    }

    public static String resolveJobWriteBehavior(AiAutoTuneJob job,
                                                 List<Map<String, Object>> mcpCalls,
                                                 List<Map<String, Object>> changes) {
        if (containsWriteBehavior(mcpCalls, WRITE_ANALYSIS_ONLY)
                || containsWriteBehavior(changes, WRITE_ANALYSIS_ONLY)
                || jobSummaryIndicatesAnalysisOnly(job)) {
            return WRITE_ANALYSIS_ONLY;
        }
        if (jobIndicatesSuccessfulRollback(job)
                || containsWriteBehavior(changes, WRITE_ROLLBACK)
                || hasSuccessfulRollbackCall(mcpCalls, changes)) {
            return WRITE_ROLLBACK;
        }
        if (containsWriteBehavior(mcpCalls, WRITE_APPLY) || containsWriteBehavior(changes, WRITE_APPLY)) {
            return WRITE_APPLY;
        }
        if (jobIndicatesStatus(job, WRITE_FAILED)
                || containsWriteBehavior(mcpCalls, WRITE_FAILED)
                || containsWriteBehavior(changes, WRITE_FAILED)) {
            return WRITE_FAILED;
        }
        if (jobIndicatesStatus(job, WRITE_REJECTED)
                || containsWriteBehavior(mcpCalls, WRITE_REJECTED)
                || containsWriteBehavior(changes, WRITE_REJECTED)) {
            return WRITE_REJECTED;
        }
        if (onlyReadOnlyCalls(mcpCalls, changes)) {
            return WRITE_READ_ONLY;
        }
        if (jobIndicatesNoChange(job, mcpCalls, changes)) {
            return WRITE_NO_CHANGE;
        }
        if (containsWriteBehavior(mcpCalls, WRITE_DRY_RUN) || containsWriteBehavior(changes, WRITE_DRY_RUN)) {
            return WRITE_DRY_RUN;
        }
        return WRITE_UNKNOWN;
    }

    public static String resolveMcpWriteBehavior(AiAutoTuneMcpCall mcpCall) {
        if (mcpCall == null) {
            return WRITE_UNKNOWN;
        }
        String toolName = normalizeLower(mcpCall.getToolName());
        if (isRollbackTool(toolName)) {
            return resolveRollbackMcpWriteBehavior(mcpCall);
        }
        String failedBehavior = failedOrRejectedBehavior(mcpCall.getStatus());
        if (isApplyTool(toolName)) {
            Boolean dryRun = toBoolean(mcpCall.getDryRun());
            if (Boolean.TRUE.equals(dryRun)) {
                JSONObject response = parseJsonObject(mcpCall.getResponseJson());
                if (responseIndicatesAnalysisOnly(response) || textIndicatesAnalysisOnly(mcpCall.getErrorMessage())) {
                    return WRITE_ANALYSIS_ONLY;
                }
                return failedBehavior == null ? WRITE_DRY_RUN : failedBehavior;
            }
            if (!Boolean.FALSE.equals(dryRun)) {
                return failedBehavior == null ? WRITE_UNKNOWN : failedBehavior;
            }
            return resolveRealApplyMcpWriteBehavior(mcpCall);
        }
        if (isReadOnlyTool(toolName)) {
            return failedBehavior == null ? WRITE_READ_ONLY : failedBehavior;
        }
        return WRITE_UNKNOWN;
    }

    public static String resolveChangeWriteBehavior(AiAutoTuneChange change) {
        return resolveChangeWriteBehavior(change, null);
    }

    public static String resolveChangeWriteBehavior(AiAutoTuneChange change, String ownerTriggerType) {
        if (change == null) {
            return WRITE_UNKNOWN;
        }
        String resultStatus = normalizeLower(change.getResultStatus());
        if (WRITE_DRY_RUN.equals(resultStatus)) {
            return WRITE_DRY_RUN;
        }
        if ("success".equals(resultStatus)) {
            return isRollbackOwnerTriggerType(ownerTriggerType) ? WRITE_ROLLBACK : WRITE_APPLY;
        }
        if (WRITE_NO_CHANGE.equals(resultStatus)) {
            return WRITE_NO_CHANGE;
        }
        if ("rejected".equals(resultStatus) && textIndicatesAnalysisOnly(change.getRejectReason())) {
            return WRITE_ANALYSIS_ONLY;
        }
        if (WRITE_REJECTED.equals(resultStatus)) {
            return WRITE_REJECTED;
        }
        if (WRITE_FAILED.equals(resultStatus)) {
            return WRITE_FAILED;
        }
        return WRITE_UNKNOWN;
    }

    public static String writeBehaviorLabel(String writeBehavior) {
        if (WRITE_ANALYSIS_ONLY.equals(writeBehavior)) {
            return "仅分析";
        }
        if (WRITE_DRY_RUN.equals(writeBehavior)) {
            return "试算";
        }
        if (WRITE_APPLY.equals(writeBehavior)) {
            return "正式写入";
        }
        if (WRITE_ROLLBACK.equals(writeBehavior)) {
            return "回滚";
        }
        if (WRITE_NO_CHANGE.equals(writeBehavior)) {
            return "无变更";
        }
        if (WRITE_READ_ONLY.equals(writeBehavior)) {
            return "只读";
        }
        if (WRITE_FAILED.equals(writeBehavior)) {
            return "失败";
        }
        if (WRITE_REJECTED.equals(writeBehavior)) {
            return "已拒绝";
        }
        return "未知";
    }

    private static boolean hasSuccessfulRollbackCall(List<Map<String, Object>> mcpCalls,
                                                     List<Map<String, Object>> changes) {
        if (mcpCalls == null || mcpCalls.isEmpty()) {
            return false;
        }
        for (Map<String, Object> mcpCall : mcpCalls) {
            if (!WRITE_ROLLBACK.equals(textValue(mcpCall.get("writeBehavior")))) {
                continue;
            }
            if (isSuccessStatus(mcpCall.get("status")) && rollbackHasAppliedChange(mcpCall, changes)) {
                return true;
            }
        }
        return false;
    }

    private static boolean rollbackHasAppliedChange(Map<String, Object> mcpCall,
                                                    List<Map<String, Object>> changes) {
        JSONObject response = parseJsonObject(textValue(mcpCall.get("responseJson")));
        if (isSuccessStatus(mcpCall.get("status")) && safeCount(mcpCall.get("successCount")) > 0) {
            return true;
        }
        return responseIndicatesSuccessfulChange(response) || changesContainSuccessfulWrite(changes);
    }

    private static boolean containsWriteBehavior(List<Map<String, Object>> items, String writeBehavior) {
        if (items == null || items.isEmpty()) {
            return false;
        }
        for (Map<String, Object> item : items) {
            if (item != null && writeBehavior.equals(textValue(item.get("writeBehavior")))) {
                return true;
            }
        }
        return false;
    }

    private static boolean onlyReadOnlyCalls(List<Map<String, Object>> mcpCalls,
                                             List<Map<String, Object>> changes) {
        if (mcpCalls == null || mcpCalls.isEmpty() || (changes != null && !changes.isEmpty())) {
            return false;
        }
        for (Map<String, Object> mcpCall : mcpCalls) {
            if (!WRITE_READ_ONLY.equals(textValue(mcpCall.get("writeBehavior")))) {
                return false;
            }
        }
        return true;
    }

    private static boolean jobIndicatesNoChange(AiAutoTuneJob job,
                                                List<Map<String, Object>> mcpCalls,
                                                List<Map<String, Object>> changes) {
        if (job != null && WRITE_NO_CHANGE.equals(normalizeLower(job.getStatus()))) {
            return true;
        }
        if (allChangesAreNoChange(changes)) {
            return true;
        }
        return containsWriteBehavior(mcpCalls, WRITE_NO_CHANGE);
    }

    private static boolean jobIndicatesStatus(AiAutoTuneJob job, String status) {
        return job != null && status.equals(normalizeLower(job.getStatus()));
    }

    private static boolean jobIndicatesSuccessfulRollback(AiAutoTuneJob job) {
        if (job == null || !isRollbackOwnerTriggerType(job.getTriggerType())) {
            return false;
        }
        return isSuccessStatus(job.getStatus()) && safeCount(job.getSuccessCount()) > 0;
    }

    private static boolean allChangesAreNoChange(List<Map<String, Object>> changes) {
        if (changes == null || changes.isEmpty()) {
            return false;
        }
        for (Map<String, Object> change : changes) {
            if (!WRITE_NO_CHANGE.equals(textValue(change.get("writeBehavior")))) {
                return false;
            }
        }
        return true;
    }

    private static boolean jobSummaryIndicatesAnalysisOnly(AiAutoTuneJob job) {
        if (job == null) {
            return false;
        }
        return textIndicatesAnalysisOnly(job.getSummary()) || textIndicatesAnalysisOnly(job.getErrorMessage());
    }

    private static String resolveRealApplyMcpWriteBehavior(AiAutoTuneMcpCall mcpCall) {
        JSONObject response = parseJsonObject(mcpCall.getResponseJson());
        if (responseIndicatesAnalysisOnly(response) || textIndicatesAnalysisOnly(mcpCall.getErrorMessage())) {
            return WRITE_ANALYSIS_ONLY;
        }
        if (hasSuccessfulApplyChange(mcpCall, response)) {
            return WRITE_APPLY;
        }
        String failedBehavior = failedOrRejectedBehavior(mcpCall.getStatus());
        if (failedBehavior != null) {
            return failedBehavior;
        }
        if (responseIndicatesNoChange(response)) {
            return WRITE_NO_CHANGE;
        }
        if (!isSuccessStatus(mcpCall.getStatus())) {
            return WRITE_UNKNOWN;
        }
        return WRITE_UNKNOWN;
    }

    private static String resolveRollbackMcpWriteBehavior(AiAutoTuneMcpCall mcpCall) {
        JSONObject response = parseJsonObject(mcpCall.getResponseJson());
        if (responseIndicatesAnalysisOnly(response) || textIndicatesAnalysisOnly(mcpCall.getErrorMessage())) {
            return WRITE_ANALYSIS_ONLY;
        }
        if (hasSuccessfulRollbackChange(mcpCall, response)) {
            return WRITE_ROLLBACK;
        }
        String failedBehavior = failedOrRejectedBehavior(mcpCall.getStatus());
        if (failedBehavior != null) {
            return failedBehavior;
        }
        if (responseIndicatesNoChange(response)) {
            return WRITE_NO_CHANGE;
        }
        return WRITE_UNKNOWN;
    }

    private static boolean hasSuccessfulApplyChange(AiAutoTuneMcpCall mcpCall, JSONObject response) {
        if (responseIndicatesSuccessfulChange(response)) {
            return true;
        }
        if (responseHasChangeDetails(response)) {
            return false;
        }
        return isSuccessStatus(mcpCall.getStatus()) && safeCount(mcpCall.getSuccessCount()) > 0;
    }

    private static boolean hasSuccessfulRollbackChange(AiAutoTuneMcpCall mcpCall, JSONObject response) {
        if (responseIndicatesSuccessfulChange(response)) {
            return true;
        }
        if (responseHasChangeDetails(response)) {
            return false;
        }
        return isSuccessStatus(mcpCall.getStatus()) && safeCount(mcpCall.getSuccessCount()) > 0;
    }

    private static String failedOrRejectedBehavior(Object status) {
        String normalizedStatus = normalizeLower(textValue(status));
        if (WRITE_FAILED.equals(normalizedStatus)) {
            return WRITE_FAILED;
        }
        if (WRITE_REJECTED.equals(normalizedStatus)) {
            return WRITE_REJECTED;
        }
        return null;
    }

    private static boolean isReadOnlyTool(String toolName) {
        return toolName.contains("get_auto_tune_snapshot") || toolName.contains("get_recent_auto_tune_jobs");
    }

    private static boolean isApplyTool(String toolName) {
        return toolName.contains("apply_auto_tune_changes");
    }

    private static boolean isRollbackTool(String toolName) {
        return toolName.contains("revert_last_auto_tune_job") || toolName.contains("rollback");
    }

    private static boolean responseIndicatesAnalysisOnly(JSONObject response) {
        if (response == null) {
            return false;
        }
        if (isTrue(response.get("analysisOnly")) || textIndicatesAnalysisOnly(textValue(response.get("summary")))) {
            return true;
        }
        return changesContainAnalysisOnly(response.get("changes"));
    }

    private static boolean responseIndicatesNoChange(JSONObject response) {
        if (response == null) {
            return false;
        }
        Object changes = response.get("changes");
        if (hasChangeDetails(changes)) {
            return allResponseChangesHaveStatus(changes, WRITE_NO_CHANGE);
        }
        if (isTrue(response.get("noApply"))) {
            return true;
        }
        return isTrue(response.get("success"))
                && safeCount(response.get("successCount")) == 0
                && safeCount(response.get("rejectCount")) == 0;
    }

    private static boolean responseIndicatesSuccessfulChange(JSONObject response) {
        if (response == null) {
            return false;
        }
        Object changes = response.get("changes");
        if (hasChangeDetails(changes)) {
            return responseChangesContainStatus(changes, "success");
        }
        return safeCount(response.get("successCount")) > 0;
    }

    private static boolean responseHasChangeDetails(JSONObject response) {
        return response != null && hasChangeDetails(response.get("changes"));
    }

    private static boolean hasChangeDetails(Object changes) {
        return changes instanceof List<?> && !((List<?>) changes).isEmpty();
    }

    private static boolean changesContainSuccessfulWrite(List<Map<String, Object>> changes) {
        if (changes == null || changes.isEmpty()) {
            return false;
        }
        for (Map<String, Object> change : changes) {
            if (change == null) {
                continue;
            }
            String writeBehavior = textValue(change.get("writeBehavior"));
            if (WRITE_APPLY.equals(writeBehavior) || WRITE_ROLLBACK.equals(writeBehavior)) {
                return true;
            }
            if ("success".equals(normalizeLower(textValue(change.get("resultStatus"))))) {
                return true;
            }
        }
        return false;
    }

    private static boolean changesContainAnalysisOnly(Object changes) {
        if (!(changes instanceof List<?>)) {
            return false;
        }
        for (Object change : (List<?>) changes) {
            if (!(change instanceof Map<?, ?>)) {
                continue;
            }
            Map<?, ?> changeMap = (Map<?, ?>) change;
            if (textIndicatesAnalysisOnly(textValue(changeMap.get("rejectReason")))) {
                return true;
            }
        }
        return false;
    }

    private static boolean allResponseChangesHaveStatus(Object changes, String status) {
        if (!(changes instanceof List<?>)) {
            return false;
        }
        List<?> changeList = (List<?>) changes;
        if (changeList.isEmpty()) {
            return false;
        }
        for (Object change : changeList) {
            if (!(change instanceof Map<?, ?>)) {
                return false;
            }
            Map<?, ?> changeMap = (Map<?, ?>) change;
            if (!status.equals(normalizeLower(textValue(changeMap.get("resultStatus"))))) {
                return false;
            }
        }
        return true;
    }

    private static boolean responseChangesContainStatus(Object changes, String status) {
        if (!(changes instanceof List<?>)) {
            return false;
        }
        for (Object change : (List<?>) changes) {
            if (!(change instanceof Map<?, ?>)) {
                continue;
            }
            Map<?, ?> changeMap = (Map<?, ?>) change;
            if (status.equals(normalizeLower(textValue(changeMap.get("resultStatus"))))) {
                return true;
            }
        }
        return false;
    }

    private static JSONObject parseJsonObject(String json) {
        if (isBlank(json)) {
            return null;
        }
        try {
            return JSON.parseObject(json);
        } catch (RuntimeException ignore) {
            return null;
        }
    }

    private static boolean textIndicatesAnalysisOnly(String text) {
        if (isBlank(text)) {
            return false;
        }
        String normalizedText = text.toLowerCase(Locale.ROOT);
        return normalizedText.contains("仅分析")
                || textContainsPositiveFlag(normalizedText, "analysisonly")
                || textContainsPositiveFlag(normalizedText, "analysis_only")
                || textContainsPositiveFlag(normalizedText, "noapply")
                || textContainsPositiveFlag(normalizedText, "no_apply")
                || normalizedText.contains("禁止实际应用");
    }

    private static boolean textContainsPositiveFlag(String text, String flag) {
        int matchIndex = text.indexOf(flag);
        while (matchIndex >= 0) {
            int valueStart = skipFlagSeparators(text, matchIndex + flag.length());
            if (startsWith(text, valueStart, "false") || startsWith(text, valueStart, "0")) {
                matchIndex = text.indexOf(flag, matchIndex + flag.length());
                continue;
            }
            return true;
        }
        return false;
    }

    private static int skipFlagSeparators(String text, int startIndex) {
        int index = startIndex;
        while (index < text.length()) {
            char character = text.charAt(index);
            if (!Character.isWhitespace(character)
                    && character != '='
                    && character != ':'
                    && character != '"'
                    && character != '\'') {
                break;
            }
            index++;
        }
        return index;
    }

    private static boolean startsWith(String text, int startIndex, String prefix) {
        return startIndex <= text.length() && text.startsWith(prefix, startIndex);
    }

    private static boolean isRollbackOwnerTriggerType(String ownerTriggerType) {
        return WRITE_ROLLBACK.equals(normalizeLower(ownerTriggerType));
    }

    private static Boolean toBoolean(Integer value) {
        if (value == null) {
            return null;
        }
        return value == 1;
    }

    private static boolean isSuccessStatus(Object status) {
        return "success".equals(normalizeLower(textValue(status)));
    }

    private static boolean isTrue(Object value) {
        if (value instanceof Boolean) {
            return Boolean.TRUE.equals(value);
        }
        return "true".equals(normalizeLower(textValue(value))) || "1".equals(textValue(value));
    }

    private static int safeCount(Object value) {
        if (value instanceof Number) {
            return ((Number) value).intValue();
        }
        if (value == null) {
            return 0;
        }
        try {
            return Integer.parseInt(String.valueOf(value));
        } catch (NumberFormatException ignore) {
            return 0;
        }
    }

    private static String normalizeLower(String value) {
        return isBlank(value) ? "" : value.trim().toLowerCase(Locale.ROOT);
    }

    private static String textValue(Object value) {
        return value == null ? "" : String.valueOf(value);
    }

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