// ----------------------------
// AutoFriendshipFight 主脚本
// - 通过 OCR 识别“突发事件”任务文本来判定是否触发
// - 通过地图路径文件导航到触发点/战斗点
// - 通过自动战斗任务完成战斗，并用 OCR 判定胜负/是否离开触发区域
// - 可选：后台检测是否出现经验/摩拉图标，用于提前终止循环
// ----------------------------

// 默认配置（当 settings.json 未设置或设置非法时使用）
const DEFAULT_RUNS = 10;
const DEFAULT_OCR_TIMEOUT_SECONDS = 10;
const DEFAULT_FIGHT_TIMEOUT_SECONDS = 120;
const DEFAULT_SWIM_CONSECUTIVE_LIMIT = 5;

const ERROR_CODES = {
    BATTLE_TIMEOUT: "BATTLE_TIMEOUT",
    SWIM_LIMIT: "SWIM_LIMIT",
    SWIM_RECOVERED: "SWIM_RECOVERED",
};

const ERR_MESSAGES = {
    BATTLE_TIMEOUT: "战斗超时，未检测到结果",
    SWIM_RECOVERED: "检测到游泳且自动回七天神像，视为本轮失败",
};

// 掉落检测状态
// detectedExpOrMora：上一轮是否识别到经验/摩拉图标（用于判断“连续两轮都没有掉落则停”）
// noExpOrMoraCount：连续“没有识别到掉落”的计数器
// running：后台循环 detectExpOrMora 的停止开关（必须在任何退出路径上关闭，避免后台占用）
let detectedExpOrMora = true;
let noExpOrMoraCount = 0;
let running = true;

const warnedEnemyTypes = new Set();

// 默认突发任务 OCR 关键词（敌人配置未提供时使用）
const DEFAULT_OCR_KEYWORDS = ["突发", "任务", "打倒", "消灭", "敌人", "所有"];

// 各敌人类型的参数配置
// - ocrKeywords：用于 detectTaskTrigger / waitForBattleResult 的 OCR 关键字
// - triggerPoint：触发点坐标（用于到位校验与二次导航）
// - targetCoords：战斗点坐标（用于到位校验）
// - preparePath：准备路径（通常是传送点->触发区域附近）
// - postBattlePath：战斗后补充路径（如拾取/对话）
// - failReturnPath：失败后的回退路径（通常回到准备点/触发点）
// - failReturnSleepMs：失败回退后额外等待（给加载/稳定留时间）
// - initialDelayMs：首轮额外等待（给地图/加载/触发留时间）
const ENEMY_CONFIG = {
    "愚人众": {
        ocrKeywords: ["买卖", "不成", "正义存", "愚人众", "禁止", "危险", "运输", "打倒", "盗宝团", "丘丘人", "今晚", "伙食", "所有人"],
        targetCoords: { x: 4840.55, y: -3078.01 },
        triggerPoint: { x: 4783.79, y: -3065.62 },
        preparePath: "愚人众-准备",
        failReturnPath: "愚人众-准备",
    },
    "盗宝团": {
        ocrKeywords: ["岛上", "无贼", "消灭", "鬼鬼祟祟", "盗宝团"],
        targetCoords: { x: -2753.04, y: -3459.3025 },
        triggerPoint: { x: -2736.60, y: -3415.44 },
    },
    "鳄鱼": {
        ocrKeywords: ["张牙", "舞爪", "恶党", "鳄鱼", "打倒", "所有", "鳄鱼"],
        targetCoords: { x: 3578.08, y: -500.75 },
        triggerPoint: { x: 3614.63, y: -521.60 },
        preparePath: "鳄鱼-准备",
        failReturnPath: "鳄鱼-准备",
        failReturnSleepMs: 5000,
        initialDelayMs: 5000,
        postBattlePath: "鳄鱼-拾取",
    },
    "蕈兽": {
        ocrKeywords: ["实验家", "变成", "实验品", "击败", "所有", "魔物"],
        targetCoords: { x: 3794.55, y: -350.60 },
        triggerPoint: { x: 3749.38, y: -391.91 },
        preparePath: "蕈兽-准备",
        postBattlePath: "蕈兽-对话",
    },
    "雷萤术士": {
        ocrKeywords: ["雷萤", "术士", "圆滚滚", "不可食用", "威撼", "攀岩", "消灭", "准备", "打倒", "所有", "魔物", "盗宝团", "击败", "成员", "盗亦无道"],
        targetCoords: { x: 883.91, y: 656.63 },
        triggerPoint: { x: 881.92, y: 616.85 },
        preparePath: "雷萤术士-准备",
    },
};

// 经验/摩拉模板匹配资源
// 这里保留 Mat 引用，便于脚本结束时主动释放，降低长时间运行的资源占用风险
let expMat = file.ReadImageMatSync("assets/exp.png");
const expRo = RecognitionObject.TemplateMatch(expMat, 74, 341, 207 - 74, 803 - 341);
expRo.Threshold = 0.85;
expRo.Use3Channels = true;
expRo.InitTemplate();

let moraMat = file.ReadImageMatSync("assets/mora.png");
const moraRo = RecognitionObject.TemplateMatch(moraMat, 74, 341, 207 - 74, 803 - 341);
moraRo.Threshold = 0.85;
moraRo.Use3Channels = true;
moraRo.InitTemplate();

/**
 * 脚本入口：读取配置并执行主循环；退出时停止后台检测并释放模板资源。
 */
(async function () {
    const startTime = Date.now();
    let enemyType = "盗宝团";
    try {
        // 可选：启用自动拾取实时任务
        if (convertToTrueIfNotBoolean(settings.pickupMode)) {
            dispatcher.addTimer(new RealtimeTimer("AutoPick"));
            log.info("已 启用 自动拾取任务");
        } else {
            log.info("已 禁用 自动拾取任务");
        }
        // 修复点：runTimes 必须用 let/const 声明，避免污染全局变量
        let runTimes = await calculateRunTimes();
        await switchPartyIfNeeded(settings.partyName);

        // 选择敌人类型（默认盗宝团）
        enemyType = settings.enemyType || "盗宝团";
        log.info(`当前选择的敌人类型: ${enemyType}`);
        log.info(`${enemyType}好感开始...`);

        // 敌人准备流程（部分敌人需要先走准备路径/清理）
        await prepareForEnemy(enemyType);
        // 超时设置校验（非法则回退默认值）
        const ocrTimeout = validateTimeoutSetting(settings.ocrTimeout, DEFAULT_OCR_TIMEOUT_SECONDS, "OCR");
        const fightTimeout = validateTimeoutSetting(settings.fightTimeout, DEFAULT_FIGHT_TIMEOUT_SECONDS, "战斗");

        // 主循环入口
        await AutoFriendshipDev(runTimes, ocrTimeout, fightTimeout, enemyType);
        log.info(`${enemyType}好感运行总时长：${LogTimeTaken(startTime)}`);
    } catch (error) {
        if (isCancellationError(error)) {
            SwimTracker(enemyType).resetConsecutiveIfNeeded();
            log.info("脚本已取消");
            return;
        }
        log.error(`脚本运行出错: ${error && error.message ? error.message : error}`);
        notification.error(`脚本运行出错: ${error && error.message ? error.message : error}`);
    } finally {
        // 修复点：无论成功/失败/异常，都必须停止后台循环与释放模板资源
        running = false;
        safeDispose(expMat);
        safeDispose(moraMat);
        expMat = null;
        moraMat = null;
    }
})();

/**
 * 将 settings 中非布尔值按默认 true 处理（未设置视为开启）。
 * @param {*} value
 * @returns {boolean}
 */
function convertToTrueIfNotBoolean(value) {
    // settings 里可能是 undefined/字符串等非布尔值，此处按“未设置则视为开启”处理
    return typeof value === 'boolean' ? value : true;
}

/**
 * 判断是否为取消任务导致的错误。
 * @param {*} error
 * @returns {boolean}
 */
function isCancellationError(error) {
    const msg = error && error.message ? String(error.message) : "";
    return msg.includes("取消自动任务") || msg.includes("A task was canceled.");
}

/**
 * 安全释放宿主对象资源（兼容 Dispose/dispose）。
 * @param {*} obj
 */
function safeDispose(obj) {
    if (!obj) return;
    const fn =
        (typeof obj.Dispose === "function" ? obj.Dispose : null) ||
        (typeof obj.dispose === "function" ? obj.dispose : null);
    if (!fn) return;
    try { fn.call(obj); } catch { }
}

/**
 * 创建带错误码的 Error，便于上层结构化处理。
 * @param {string} code
 * @param {string} message
 * @returns {Error}
 */
function createScriptError(code, message) {
    const err = new Error(message);
    err.code = code;
    return err;
}

/**
 * 判断 CancellationTokenSource 是否已请求取消（兼容不同字段命名）。
 * @param {*} cts
 * @returns {boolean}
 */
function isCtsCancellationRequested(cts) {
    try {
        const v =
            cts?.isCancellationRequested ??
            cts?.IsCancellationRequested ??
            cts?.token?.isCancellationRequested ??
            cts?.token?.IsCancellationRequested;
        return v === true;
    } catch {
        return false;
    }
}

/**
 * 获取地图坐标，失败时返回 null（取消错误会透传）。
 * @returns {{x:number,y:number}|null}
 */
function safeGetPositionFromMap() {
    try {
        return genshin.getPositionFromMap();
    } catch (error) {
        if (isCancellationError(error)) {
            throw error;
        }
        return null;
    }
}

/**
 * 获取敌人配置；未知 enemyType 仅提示一次并回退为空配置。
 * @param {string} enemyType
 * @returns {object}
 */
function getEnemyConfig(enemyType) {
    // 根据敌人类型返回配置对象（不存在则返回空对象，调用方负责兜底）
    const cfg = ENEMY_CONFIG[enemyType];
    if (!cfg && !warnedEnemyTypes.has(enemyType)) {
        warnedEnemyTypes.add(enemyType);
        log.warn(`未知 enemyType: ${enemyType}，将使用默认配置`);
    }
    return cfg || {};
}

/**
 * 敌人准备流程：执行 preparePath / 盗宝团可选清理丘丘人。
 * @param {string} enemyType
 * @returns {Promise<void>}
 */
async function prepareForEnemy(enemyType) {
    // 清理丘丘人（仅盗宝团需要）
    if (settings.qiuQiuRen && enemyType === "盗宝团") {
        log.info("清理原住民...");
        await AutoPath("盗宝团-准备");
    }

    const { preparePath } = getEnemyConfig(enemyType);
    if (preparePath) {
        log.info(`导航到${enemyType}触发点...`);
        await AutoPath(preparePath);
    }
}

/**
 * 战后附加流程：按敌人配置跑 postBattlePath；蕈兽包含对话交互。
 * @param {string} enemyType
 * @returns {Promise<void>}
 */
async function runPostBattle(enemyType) {
    // 战斗后处理：按敌人配置执行附加路径；部分敌人需要对话交互
    const { postBattlePath } = getEnemyConfig(enemyType);
    if (postBattlePath) {
        await AutoPath(postBattlePath);
    }

    if (enemyType === "蕈兽") {
        await sleep(50);
        keyPress("F");
        await sleep(50);
        keyPress("F");
        await sleep(500);
        await genshin.chooseTalkOption("下次");
        await sleep(500);
    }
}

/**
 * 失败恢复：回七天神像（可跳过）并走回退路径。
 * @param {string} enemyType
 * @param {boolean} [skipTp=false]
 * @returns {Promise<void>}
 */
async function recoverAfterFailure(enemyType, skipTp = false) {
    if (!skipTp) {
        await genshin.tpToStatueOfTheSeven();
    }
    const { failReturnPath, failReturnSleepMs, preparePath } = getEnemyConfig(enemyType);
    if (failReturnPath) {
        await AutoPath(failReturnPath);
    } else if (preparePath) {
        await AutoPath(preparePath);
    } else {
        await AutoPath(`${enemyType}-触发点`);
    }
    if (failReturnSleepMs) {
        await sleep(failReturnSleepMs);
    }
}
// 执行 path 任务
/**
 * 执行路径文件（AutoPath/*.json）；失败返回 false，取消错误透传。
 * @param {string} locationName
 * @returns {Promise<boolean>}
 */
async function AutoPath(locationName) {
    // 统一包装路径执行：避免 runFile 抛错导致整个脚本中断
    try {
        const filePath = `assets/AutoPath/${locationName}.json`;
        await pathingScript.runFile(filePath);
        return true;
    } catch (error) {
        if (isCancellationError(error)) {
            throw error;
        }
        log.error(`执行 ${locationName} 路径时发生错误: ${error.message}`);
        return false;
    }
}

/**
 * 生成当天日期键（YYYY-MM-DD）。
 * @returns {string}
 */
function getTodayKey() {
    const d = new Date();
    const yyyy = String(d.getFullYear());
    const mm = String(d.getMonth() + 1).padStart(2, "0");
    const dd = String(d.getDate()).padStart(2, "0");
    return `${yyyy}-${mm}-${dd}`;
}

/**
 * 统一路径字符串用于比较（反斜杠转正斜杠并去重）。
 * @param {string} p
 * @returns {string}
 */
function normalizePathForCompare(p) {
    if (!p || typeof p !== "string") return "";
    return p.replace(/\\/g, "/").replace(/\/+/g, "/");
}

/**
 * 安全判断文件是否存在（宿主缺少 exists API 时的兜底实现）。
 * @param {string} filePath
 * @returns {boolean}
 */
function fileExistsSafe(filePath) {
    try {
        if (!filePath || typeof filePath !== "string") return false;
        if (file.isFolder(filePath)) return false;
        const normalized = normalizePathForCompare(filePath);
        const lastSlash = normalized.lastIndexOf("/");
        const dir = lastSlash >= 0 ? normalized.slice(0, lastSlash) : ".";
        const name = lastSlash >= 0 ? normalized.slice(lastSlash + 1) : normalized;
        const items = file.readPathSync(dir);
        if (!items || items.length === 0) return false;
        for (const item of items) {
            const n = normalizePathForCompare(item);
            if (n === normalized) return true;
            const nLastSlash = n.lastIndexOf("/");
            const nName = nLastSlash >= 0 ? n.slice(nLastSlash + 1) : n;
            if (nName === name) return true;
        }
        return false;
    } catch {
        return false;
    }
}

/**
 * 游泳状态追踪（仅盗宝团启用）：记录连续触发次数并支持阈值中断。
 * @param {string} enemyType
 * @returns {{enabled:boolean, load:Function, resetConsecutiveIfNeeded:Function, recordAndCheck:Function}}
 */
function SwimTracker(enemyType) {
    const enabled = enemyType === "盗宝团";
    const statsPath = "swim_stats.json";
    const today = getTodayKey();

    /**
     * 读取当天统计。
     * @returns {{date:string,totalSwimCount:number,consecutiveSwimCount:number}}
     */
    function load() {
        if (!enabled) return { date: today, totalSwimCount: 0, consecutiveSwimCount: 0 };
        try {
            if (!fileExistsSafe(statsPath)) {
                return { date: today, totalSwimCount: 0, consecutiveSwimCount: 0 };
            }
            const raw = file.readTextSync(statsPath);
            const parsed = JSON.parse(raw);
            if (parsed && parsed.date === today) {
                const totalSwimCount = typeof parsed.totalSwimCount === "number"
                    ? parsed.totalSwimCount
                    : (typeof parsed.swimCount === "number" ? parsed.swimCount : 0);
                const consecutiveSwimCount = typeof parsed.consecutiveSwimCount === "number" ? parsed.consecutiveSwimCount : 0;
                return { date: today, totalSwimCount, consecutiveSwimCount };
            }
        } catch { }
        return { date: today, totalSwimCount: 0, consecutiveSwimCount: 0 };
    }

    /**
     * 保存统计（仅启用时生效）。
     * @param {{date:string,totalSwimCount:number,consecutiveSwimCount:number}} stats
     */
    function save(stats) {
        if (!enabled) return;
        try {
            file.writeTextSync(statsPath, JSON.stringify(stats, null, 2), false);
        } catch { }
    }

    /**
     * 若连续计数大于 0 则清零。
     */
    function resetConsecutiveIfNeeded() {
        if (!enabled) return;
        const stats = load();
        if (stats.consecutiveSwimCount > 0) {
            stats.consecutiveSwimCount = 0;
            save(stats);
        }
    }

    /**
     * 记录一次游泳事件并检查是否超过阈值。
     * @param {number|string} consecutiveLimit
     * @returns {{totalSwimCount:number,consecutiveSwimCount:number,consecutiveLimit:number,exceeded:boolean}}
     */
    function recordAndCheck(consecutiveLimit) {
        if (!enabled) {
            const limit = Number.isFinite(Number(consecutiveLimit)) ? Number(consecutiveLimit) : DEFAULT_SWIM_CONSECUTIVE_LIMIT;
            return { totalSwimCount: 0, consecutiveSwimCount: 0, consecutiveLimit: limit, exceeded: false };
        }
        const stats = load();
        stats.totalSwimCount = (Number(stats.totalSwimCount) || 0) + 1;
        stats.consecutiveSwimCount = (Number(stats.consecutiveSwimCount) || 0) + 1;
        save(stats);
        const limit = Number.isFinite(Number(consecutiveLimit)) ? Number(consecutiveLimit) : DEFAULT_SWIM_CONSECUTIVE_LIMIT;
        return {
            totalSwimCount: stats.totalSwimCount,
            consecutiveSwimCount: stats.consecutiveSwimCount,
            consecutiveLimit: limit,
            exceeded: stats.consecutiveSwimCount >= limit
        };
    }

    return { enabled, load, resetConsecutiveIfNeeded, recordAndCheck };
}

const battlePointCache = new Map();

/**
 * 从战斗点路径文件中推导最后一个坐标（缓存）；失败则回退配置的 targetCoords。
 * @param {string} enemyType
 * @returns {{x:number,y:number}|null}
 */
function getBattlePointFromBattlePath(enemyType) {
    if (battlePointCache.has(enemyType)) {
        return battlePointCache.get(enemyType);
    }
    const filePath = `assets/AutoPath/${enemyType}-战斗点.json`;
    let point = null;
    try {
        if (fileExistsSafe(filePath)) {
            const raw = file.readTextSync(filePath);
            const parsed = JSON.parse(raw);
            const positions = parsed && Array.isArray(parsed.positions) ? parsed.positions : null;
            if (positions && positions.length > 0) {
                const last = positions[positions.length - 1];
                if (last && Number.isFinite(Number(last.x)) && Number.isFinite(Number(last.y))) {
                    point = { x: Number(last.x), y: Number(last.y) };
                }
            }
        }
    } catch { }
    if (!point) {
        point = getTargetCoordinates(enemyType);
    }
    battlePointCache.set(enemyType, point);
    return point;
}

/**
 * 执行战斗点路径；可选在最后节点注入 fight action（用于盗宝团旧流程）。
 * @param {string} enemyType
 * @param {boolean} [injectFightAction=false]
 * @returns {Promise<void>}
 */
async function runBattlePathToBattlePoint(enemyType, injectFightAction = false) {
    const filePath = `assets/AutoPath/${enemyType}-战斗点.json`;
    if (!fileExistsSafe(filePath)) {
        throw new Error(`缺少战斗点路径文件: ${filePath}`);
    }
    if (!injectFightAction) {
        await pathingScript.runFile(filePath);
        return;
    }
    const raw = file.readTextSync(filePath);
    const parsed = JSON.parse(raw);
    const positions = parsed && Array.isArray(parsed.positions) ? parsed.positions : null;
    if (!positions || positions.length === 0) {
        throw new Error(`战斗点路径文件无有效 positions: ${filePath}`);
    }

    const last = positions[positions.length - 1];
    const clonedPositions = positions.map(p => ({ ...p }));
    clonedPositions[clonedPositions.length - 1] = {
        ...last,
        action: "fight",
        action_params: last && typeof last.action_params === "string" ? last.action_params : ""
    };

    const payload = {
        ...parsed,
        positions: clonedPositions
    };
    await pathingScript.run(JSON.stringify(payload));
}

// 计算运行时长
/**
 * 计算从 startTime 到现在的耗时字符串。
 * @param {number} startTimeParam
 * @returns {string}
 */
function LogTimeTaken(startTimeParam) {
    const currentTime = Date.now();
    const totalTimeInSeconds = (currentTime - startTimeParam) / 1000;
    const minutes = Math.floor(totalTimeInSeconds / 60);
    const seconds = totalTimeInSeconds % 60;
    return `${minutes} 分 ${seconds.toFixed(0).padStart(2, '0')} 秒`;
}

// 计算预估时间
/**
 * 估算完成时间（按平均单轮耗时线性推算）。
 * @param {number} startTime
 * @param {number} current
 * @param {number} total
 * @returns {string}
 */
function CalculateEstimatedCompletion(startTime, current, total) {
    if (current === 0) return "计算中...";

    const elapsedTime = Date.now() - startTime;
    const timePerTask = elapsedTime / current;
    const remainingTasks = total - current;
    const remainingTime = timePerTask * remainingTasks;
    const completionDate = new Date(Date.now() + remainingTime);
    return `${completionDate.toLocaleTimeString()} (约 ${Math.round(remainingTime / 60000)} 分钟)`;
}

// 检查并导航到触发点
/**
 * 导航到触发点并做一次距离校验，偏离则二次导航。
 * @param {string} enemyType
 * @returns {Promise<void>}
 */
async function navigateToTriggerPoint(enemyType) {
    await AutoPath(`${enemyType}-触发点`);
    const triggerPoint = getTriggerPoint(enemyType);
    if (!triggerPoint) {
        log.warn(`未配置 ${enemyType} 的 triggerPoint，跳过触发点距离校验`);
        return;
    }
    const pos = safeGetPositionFromMap();

    if (pos) {
        const distance = Math.sqrt(Math.pow(pos.x - triggerPoint.x, 2) + Math.pow(pos.y - triggerPoint.y, 2));
        if (distance <= 8) {
            log.info(`已到达触发点附近，距离: ${distance.toFixed(2)}米`);
        } else {
            log.info(`未到达触发点，当前距离: ${distance.toFixed(2)}米，正在导航...`);
            await AutoPath(`${enemyType}-触发点`);
        }
    }
}

// OCR检测突发任务
/**
 * OCR 检测是否触发突发任务。
 * @param {number} ocrTimeout 秒
 * @param {string} enemyType
 * @returns {Promise<boolean>}
 */
async function detectTaskTrigger(ocrTimeout, enemyType) {
    // 修复点：OCR 的截图对象与 findMulti 返回对象可能持有底层资源
    // 必须在 finally 中释放，避免长时间循环导致资源累积
    const ocrKeywords = getOcrKeywords(enemyType);
    let ocrStatus = false;
    let ocrStartTime = Date.now();

    while (Date.now() - ocrStartTime < ocrTimeout * 1000 && !ocrStatus) {
        let captureRegion = null;
        let resList = null;
        try {
            captureRegion = captureGameRegion();
            resList = captureRegion.findMulti(RecognitionObject.ocr(0, 200, 300, 300));
            for (let o = 0; o < resList.count; o++) {
                let res = resList[o];
                try {
                    for (let keyword of ocrKeywords) {
                        if (res && res.text && String(res.text).includes(keyword)) {
                            ocrStatus = true;
                            log.info("检测到突发任务触发");
                            break;
                        }
                    }
                    if (ocrStatus) break;
                } finally {
                    safeDispose(res);
                }
            }
        } catch (error) {
            if (isCancellationError(error)) {
                throw error;
            }
            log.error(`OCR检测突发任务过程中出错: ${error && error.message ? error.message : error}`);
        } finally {
            safeDispose(resList);
            safeDispose(captureRegion);
        }

        if (!ocrStatus) {
            await sleep(1000);
        }
    }

    return ocrStatus;
}

// 执行战斗任务（并发执行战斗和结果检测）
/**
 * 执行 AutoFight 并用 OCR 判定战斗结果（支持同步/异步模式与超时保护）。
 * @param {number} fightTimeout 秒
 * @param {string} enemyType
 * @param {*} cts CancellationTokenSource
 * @param {{x:number,y:number}|null} battlePointCoords
 * @returns {Promise<{success:boolean,status:string,errorMessage?:string}>}
 */
async function executeBattleTasks(fightTimeout, enemyType, cts, battlePointCoords) {
    // 修复点：
    // - 以前只要“检测任务 fulfilled”就当成功；现在明确区分 success/failure/out_of_area 等状态
    // - 取消只意味着停止战斗任务，不等价于“本轮战斗成功”
    log.info("开始战斗!");

    let battleTask;
    let battleDetectTask = null;
    let awaitBattleTask = true;
    const awaitBattleTaskMs = 2000;
    try {
        if (settings.disableAsyncFight) {
            // 同步战斗模式：依赖配置组的“战斗结束检测”让 AutoFight 自行退出
            // 额外增加 watchdog：超过 fightTimeout 仍未退出则取消任务，避免无限战斗
            const maxDetectMs = Math.max(0, Number(fightTimeout) * 1000);
            battleTask = dispatcher.RunTask(new SoloTask("AutoFight"), cts);
            const battleWrapped = battleTask
                .then(value => ({ kind: "battle_fulfilled", value }))
                .catch(error => ({ kind: "battle_rejected", error }));
            const first = await Promise.race([
                battleWrapped,
                sleep(maxDetectMs).then(() => ({ kind: "battle_timeout" }))
            ]);
            if (first.kind === "battle_timeout") {
                try { cts.cancel(); } catch { }
                awaitBattleTask = false;
                return { success: false, status: "auto_fight_ended" };
            }
            if (first.kind === "battle_rejected") {
                throw first.error;
            }
            const graceMs = Math.min(8000, maxDetectMs);
            try {
                const status = await waitForBattleResult(graceMs, enemyType, cts, battlePointCoords);
                return { success: status === "success", status };
            } catch (error) {
                if (error && (error.code === ERROR_CODES.BATTLE_TIMEOUT || (error.message && String(error.message).includes("战斗超时")))) {
                    return { success: false, status: "auto_fight_ended" };
                }
                throw error;
            }
        } else {
            // 异步战斗模式：并发启动战斗 + OCR 检测结果；检测到结果后取消战斗任务
            battleTask = dispatcher.RunTask(new SoloTask("AutoFight"), cts);
            battleDetectTask = waitForBattleResult(fightTimeout * 1000, enemyType, cts, battlePointCoords);
            const maxDetectMs = Math.max(0, Number(fightTimeout) * 1000);
            const graceMs = Math.min(8000, maxDetectMs);

            const battleWrapped = battleTask
                .then(value => ({ kind: "battle_fulfilled", value }))
                .catch(error => ({ kind: "battle_rejected", error }));

            const detectWrapped = battleDetectTask
                .then(status => ({ kind: "detect_fulfilled", status }))
                .catch(error => ({ kind: "detect_rejected", error }));

            const first = await Promise.race([battleWrapped, detectWrapped]);

            if (first.kind === "detect_fulfilled") {
                log.info("战斗检测任务完成");
                try { cts.cancel(); } catch { }
                return { success: first.status === "success", status: first.status };
            }
            if (first.kind === "detect_rejected") {
                throw first.error;
            }

            if (first.kind === "battle_rejected" && isCancellationError(first.error)) {
                throw first.error;
            }

            const second = await Promise.race([
                detectWrapped,
                sleep(graceMs).then(() => ({ kind: "detect_timeout" }))
            ]);

            if (second.kind === "detect_fulfilled") {
                log.info("战斗检测任务完成");
                try { cts.cancel(); } catch { }
                return { success: second.status === "success", status: second.status };
            }
            if (second.kind === "detect_rejected") {
                throw second.error;
            }

            try { cts.cancel(); } catch { }
            return { success: false, status: "auto_fight_ended" };
        }
    } catch (error) {
        if (isCancellationError(error)) throw error;
        const msg = error && error.message ? String(error.message) : "";
        if (SwimTracker(enemyType).enabled && (msg.includes("前往七天神像重试") || msg.includes("检测到游泳"))) {
            log.warn(`战斗执行异常（已自动回七天神像）: ${msg}`);
            return { success: false, status: "recovered_to_statue", errorMessage: msg };
        }
        log.error(`战斗执行过程中出错: ${msg}`);
        return { success: false, status: "error", errorMessage: msg };
    } finally {
        // 避免因 AutoFight 不响应取消导致 finally 永久挂起
        if (battleTask) {
            try {
                const done = await Promise.race([
                    battleTask.then(() => true),
                    sleep(awaitBattleTask ? awaitBattleTaskMs : 0).then(() => false)
                ]);
                if (!done) {
                    battleTask.catch(() => { });
                }
            } catch (error) {
                // 忽略 finally 块中的取消错误
                if (!isCancellationError(error)) {
                    log.warn(`清理战斗任务时出错: ${error.message}`);
                }
            }
        }
        keyUp("VK_LBUTTON");
    }
}

// 执行单次好感任务循环
/**
 * 执行单轮好感流程（触发检测→导航→战斗→判定→战后/恢复）。
 * @param {number} roundIndex
 * @param {number} ocrTimeout 秒
 * @param {number} fightTimeout 秒
 * @param {string} enemyType
 * @returns {Promise<boolean>} 返回 false 表示整体应提前结束
 */
async function executeSingleFriendshipRound(roundIndex, ocrTimeout, fightTimeout, enemyType) {
    const swim = SwimTracker(enemyType);
    // 单轮流程：
    // 1) 导航到触发点附近
    // 2) 通过 OCR 判断是否已触发突发任务
    // 3) 导航到战斗点（避免与失败回退路径并发冲突）
    // 4) 启动战斗 + OCR 判定胜负/是否离开区域
    // 5) 成功则执行战斗后流程；失败则回退到准备/触发点并进入下一轮
    // 导航到触发点
    await navigateToTriggerPoint(enemyType);
    const { initialDelayMs } = getEnemyConfig(enemyType);
    if (roundIndex === 0 && initialDelayMs) {
        await sleep(initialDelayMs);
    }
    let initialDetected = false;
    if (roundIndex === 0) {
        initialDetected = await detectTaskTrigger(Math.min(Number(ocrTimeout) || DEFAULT_OCR_TIMEOUT_SECONDS, DEFAULT_OCR_TIMEOUT_SECONDS), enemyType);
    }
    if (!detectedExpOrMora && settings.loopTillNoExpOrMora) {
        noExpOrMoraCount++;
        log.warn("上次运行未检测到经验或摩拉");
        if (noExpOrMoraCount >= 2) {
            log.warn("连续两次循环没有经验或摩拉掉落，提前终止");
            return false;
        }
    } else {
        noExpOrMoraCount = 0;
        detectedExpOrMora = false;
    }
    if (!initialDetected || roundIndex > 0) {
        if (settings.use1000Stars) {
            await genshin.wonderlandCycle();
        } else {
            await genshin.relogin();
        }
    }

    const ocrStatus = await detectTaskTrigger(ocrTimeout, enemyType);

    if (!ocrStatus) {
        // 本轮未检测到突发任务：按设计直接结束整个脚本循环
        notification.send(`未识别到突发任务，${enemyType}好感结束`);
        log.info(`未识别到突发任务，${enemyType}好感结束`);
        swim.resetConsecutiveIfNeeded();
        return false; // 返回 false 表示需要终止循环
    }

    // 修复点：先确认触发，再执行导航；避免“未触发时仍去战斗点”以及失败时多路径并发
    const battlePointCoords = getBattlePointFromBattlePath(enemyType);
    if (!battlePointCoords) {
        throw new Error(`未配置 ${enemyType} 的 targetCoords`);
    }

    if (enemyType === "盗宝团") {
        const maxDetectMs = Math.max(0, Number(fightTimeout) * 1000);
        const battleDetectCts = new CancellationTokenSource();
        const battleDetectPromise = waitForBattleResult(maxDetectMs, enemyType, battleDetectCts, battlePointCoords);
        log.info("开始战斗!");
        const pathPromise = runBattlePathToBattlePoint(enemyType, true);
        const pathWrapped = pathPromise
            .then(() => ({ kind: "path_fulfilled" }))
            .catch(error => ({ kind: "path_rejected", error }));
        const detectWrapped = battleDetectPromise
            .then(status => ({ kind: "detect_fulfilled", status }))
            .catch(error => ({ kind: "detect_rejected", error }));

        const first = await Promise.race([pathWrapped, detectWrapped]);
        if (first.kind === "path_rejected") {
            try { battleDetectCts.cancel(); } catch { }
            const e = first.error;
            if (isCancellationError(e)) throw e;
            const msg = e && e.message ? String(e.message) : "";
            if (swim.enabled && (msg.includes("前往七天神像重试") || msg.includes("检测到游泳"))) {
                const { totalSwimCount, consecutiveSwimCount, consecutiveLimit, exceeded } = swim.recordAndCheck(settings.swimConsecutiveLimit);
                log.warn(`检测到游泳异常，今日累计 ${totalSwimCount} 次，连续 ${consecutiveSwimCount}/${consecutiveLimit} 次`);
                if (exceeded) {
                    throw createScriptError(ERROR_CODES.SWIM_LIMIT, `当日连续触发游泳已达 ${consecutiveLimit} 次，战斗策略或配队严重不合理`);
                }
                throw createScriptError(ERROR_CODES.SWIM_RECOVERED, ERR_MESSAGES.SWIM_RECOVERED);
            }
            throw e;
        }

        const battleStatus = first.kind === "detect_fulfilled"
            ? first.status
            : await battleDetectPromise;

        if (first.kind === "detect_fulfilled") {
            const pathSettled = await Promise.race([
                pathPromise.then(() => true).catch(() => true),
                sleep(maxDetectMs).then(() => false)
            ]);
            if (!pathSettled) {
                throw createScriptError(ERROR_CODES.BATTLE_TIMEOUT, ERR_MESSAGES.BATTLE_TIMEOUT);
            }
        }

        if (battleStatus === "cancelled") {
            throw new Error("战斗任务已取消");
        }
        if (battleStatus === "success") {
            swim.resetConsecutiveIfNeeded();
            await runPostBattle(enemyType);
            return true;
        }
        await recoverAfterFailure(enemyType, false);
        throw new Error(`战斗失败: ${battleStatus}`);
    }

    try {
        await runBattlePathToBattlePoint(enemyType, false);
    } catch (e) {
        if (isCancellationError(e)) throw e;
        const msg = e && e.message ? String(e.message) : "";
        if (swim.enabled && (msg.includes("前往七天神像重试") || msg.includes("检测到游泳"))) {
            const { totalSwimCount, consecutiveSwimCount, consecutiveLimit, exceeded } = swim.recordAndCheck(settings.swimConsecutiveLimit);
            log.warn(`检测到游泳异常，今日累计 ${totalSwimCount} 次，连续 ${consecutiveSwimCount}/${consecutiveLimit} 次`);
            if (exceeded) {
                throw createScriptError(ERROR_CODES.SWIM_LIMIT, `当日连续触发游泳已达 ${consecutiveLimit} 次，战斗策略或配队严重不合理`);
            }
            throw createScriptError(ERROR_CODES.SWIM_RECOVERED, ERR_MESSAGES.SWIM_RECOVERED);
        }
        throw e;
    }

    const battleCts = new CancellationTokenSource();
    const battleResult = await executeBattleTasks(fightTimeout, enemyType, battleCts, battlePointCoords);

    if (battleResult.status === "success") {
        swim.resetConsecutiveIfNeeded();
        await runPostBattle(enemyType);
        return true;
    }

    if (battleResult.status === "recovered_to_statue") {
        if (swim.enabled) {
            const { totalSwimCount, consecutiveSwimCount, consecutiveLimit, exceeded } = swim.recordAndCheck(settings.swimConsecutiveLimit);
            log.warn(`检测到游泳异常，今日累计 ${totalSwimCount} 次，连续 ${consecutiveSwimCount}/${consecutiveLimit} 次`);
            if (exceeded) {
                throw createScriptError(ERROR_CODES.SWIM_LIMIT, `当日连续触发游泳已达 ${consecutiveLimit} 次，战斗策略或配队严重不合理`);
            }
            await recoverAfterFailure(enemyType, true);
            throw createScriptError(ERROR_CODES.SWIM_RECOVERED, ERR_MESSAGES.SWIM_RECOVERED);
        }
        await recoverAfterFailure(enemyType, false);
        throw new Error(battleResult.errorMessage ? String(battleResult.errorMessage) : `战斗失败: ${battleResult.status}`);
    }

    await recoverAfterFailure(enemyType, false);
    const msg = battleResult.errorMessage ? String(battleResult.errorMessage) : `战斗失败: ${battleResult.status}`;
    throw new Error(msg);
}

// 记录进度信息
/**
 * 输出当前进度与预计完成时间。
 * @param {number} startTime
 * @param {number} currentRound
 * @param {number} totalRounds
 */
function logProgress(startTime, currentRound, totalRounds) {
    const estimatedCompletion = CalculateEstimatedCompletion(startTime, currentRound + 1, totalRounds);
    const currentTime = LogTimeTaken(startTime);
    log.info(`当前进度：${currentRound + 1}/${totalRounds} (${((currentRound + 1) / totalRounds * 100).toFixed(1)}%)`);
    log.info(`当前运行总时长：${currentTime}`);
    log.info(`预计完成时间：${estimatedCompletion}`);
}

// 执行 N 次好感任务并输出日志 - 重构后的主函数
/**
 * 主循环：执行指定次数；在未触发/连续无掉落等条件下提前退出。
 * @param {number} times
 * @param {number} ocrTimeout 秒
 * @param {number} fightTimeout 秒
 * @param {string} enemyType
 * @returns {Promise<void>}
 */
async function AutoFriendshipDev(times, ocrTimeout, fightTimeout, enemyType = "盗宝团") {
    // 主循环：执行指定次数或在 detectTaskTrigger 判定“未触发”时提前退出
    // 修复点：finally 中统一关闭 running 并等待 detectExpOrMoraTask 退出，避免后台循环残留
    const startFirstTime = Date.now();
    let detectExpOrMoraTask;
    let cancelled = false;
    let successCount = 0;
    let failureCount = 0;
    try {
        if (settings.loopTillNoExpOrMora) {
            detectExpOrMoraTask = detectExpOrMora();
        }
        for (let i = 0; i < times; i++) {
            try { await sleep(1); } catch (e) { break; }
            try {
                const success = await executeSingleFriendshipRound(i, ocrTimeout, fightTimeout, enemyType);
                if (!success)
                    break;
                successCount++;
                logProgress(startFirstTime, i, times);
            } catch (error) {
                if (isCancellationError(error)) {
                    cancelled = true;
                    throw error;
                }
                failureCount++;
                log.error(`第 ${i + 1} 轮好感任务失败: ${error.message}`);
                if (error && error.code === ERROR_CODES.BATTLE_TIMEOUT) {
                    throw error;
                }
                if (error && error.code === ERROR_CODES.SWIM_LIMIT) {
                    throw error;
                }
                if (error.message && error.message.includes("战斗超时")) {
                    throw error;
                }
                if (error.message && error.message.includes("当日连续触发游泳")) {
                    throw error;
                }
                continue;
            }
        }
        if (!cancelled) {
            log.info(`${enemyType} 好感已完成`);
        }
    } finally {
        if (!cancelled) {
            const swim = SwimTracker(enemyType);
            if (swim.enabled) {
                const stats = swim.load();
                const limit = Number.isFinite(Number(settings.swimConsecutiveLimit)) ? Number(settings.swimConsecutiveLimit) : DEFAULT_SWIM_CONSECUTIVE_LIMIT;
                log.info(`本次运行统计：成功 ${successCount} 次，失败 ${failureCount} 次，今日游泳累计 ${stats.totalSwimCount} 次，连续游泳 ${stats.consecutiveSwimCount}/${limit} 次`);
            } else {
                log.info(`本次运行统计：成功 ${successCount} 次，失败 ${failureCount} 次`);
            }
        }
        running = false;
        if (detectExpOrMoraTask) {
            try { await detectExpOrMoraTask; } catch { }
        }
    }
}

/**
 * 后台循环：模板匹配检测经验/摩拉掉落图标（用于提前终止循环）。
 * @returns {Promise<void>}
 */
async function detectExpOrMora() {
    // 后台循环：通过模板匹配检测经验/摩拉图标
    // 注意：该循环依赖 running 停止；必须保证任何退出路径都会把 running=false
    while (running) {
        try { await sleep(1); } catch (e) { break; }
        let gameRegion;
        if (!detectedExpOrMora) {
            let res1 = null;
            let res2 = null;
            try {
                gameRegion = captureGameRegion();
                res1 = gameRegion.find(expRo);
                if (res1.isExist()) {
                    log.info("识别到经验");
                    detectedExpOrMora = true;
                    continue;
                }
                res2 = gameRegion.find(moraRo);
                if (res2.isExist()) {
                    log.info("识别到摩拉");
                    detectedExpOrMora = true;
                    continue;
                }
            } catch (e) {
                log.error(`检测经验和摩拉掉落过程中出现错误 ${e.message}`);
            } finally {
                safeDispose(res1);
                safeDispose(res2);
                safeDispose(gameRegion);
            }
        } else {
            //无需检测时额外等待200
            await sleep(200);
        }
        await sleep(200);
    }
}

/**
 * 读取并校验运行次数设置，非法则回退默认值。
 * @returns {Promise<number>}
 */
async function calculateRunTimes() {
    // 从 settings 读取次数并校验；非法则回退默认值
    log.info(`'请确保队伍满员，并为队伍配置相应的战斗策略'`);
    // 计算运行次数
    let runTimes = Number(settings.runTimes);
    if (!isPositiveInteger(runTimes)) {
        log.warn("请输入正确的次数，必须是正整数！");
        log.warn(`运行次数重置为 ${DEFAULT_RUNS} 次！`);
        runTimes = DEFAULT_RUNS;
    }

    log.info(`当前设置的运行次数: ${runTimes}`);
    return runTimes;
}

// 验证输入是否是正整数
/**
 * 判断是否为正整数。
 * @param {*} value
 * @returns {boolean}
 */
function isPositiveInteger(value) {
    return Number.isInteger(value) && value > 0;
}

// 根据敌人类型获取OCR关键词
/**
 * 获取 OCR 关键词（优先敌人配置，否则回退默认）。
 * @param {string} enemyType
 * @returns {string[]}
 */
function getOcrKeywords(enemyType) {
    // OCR 关键词获取：优先使用敌人类型配置，否则回退到默认关键词
    const { ocrKeywords } = getEnemyConfig(enemyType);
    return ocrKeywords || DEFAULT_OCR_KEYWORDS;
}

// 根据敌人类型获取目标战斗点坐标
/**
 * 获取目标战斗点坐标配置。
 * @param {string} enemyType
 * @returns {{x:number,y:number}|undefined}
 */
function getTargetCoordinates(enemyType) {
    const { targetCoords } = getEnemyConfig(enemyType);
    return targetCoords;
}

/**
 * 获取触发点坐标配置。
 * @param {string} enemyType
 * @returns {{x:number,y:number}|undefined}
 */
function getTriggerPoint(enemyType) {
    const { triggerPoint } = getEnemyConfig(enemyType);
    return triggerPoint;
}

// 验证日期格式
/**
 * 可选切换队伍；失败则尝试回七天神像后重试。
 * @param {string} partyName
 * @returns {Promise<void>}
 */
async function switchPartyIfNeeded(partyName) {
    // 可选队伍切换：为空则直接回到主界面，避免停留在菜单/对话等状态
    if (!partyName) {
        await genshin.returnMainUi();
        return;
    }
    try {
        log.info("正在尝试切换至" + partyName);
        if (!await genshin.switchParty(partyName)) {
            log.info("切换队伍失败，前往七天神像重试");
            await genshin.tpToStatueOfTheSeven();
            await genshin.switchParty(partyName);
        }
    } catch {
        log.error("队伍切换失败，可能处于联机模式或其他不可切换状态");
        notification.error(`队伍切换失败，可能处于联机模式或其他不可切换状态`);
        await genshin.returnMainUi();
    }
}

/**
 * OCR 轮询战斗结果：success/failure/out_of_area/cancelled；超时抛 BATTLE_TIMEOUT。
 * @param {number} timeout 毫秒
 * @param {string} enemyType
 * @param {*} cts CancellationTokenSource
 * @param {{x:number,y:number}|null} battlePointCoords
 * @returns {Promise<"success"|"failure"|"out_of_area"|"cancelled">}
 */
async function waitForBattleResult(timeout = 2 * 60 * 1000, enemyType = "盗宝团", cts = null, battlePointCoords = null) {
    // 战斗结果 OCR 判定：
    // - 返回 "success"：识别到成功关键字/特殊条件
    // - 返回 "failure"：识别到失败关键字
    // - 返回 "out_of_area"：连续多次识别不到事件关键字，认为离开触发区域
    // - 超时：抛出 Error("战斗超时，未检测到结果")
    //
    // 修复点：这里不做 tp/跑路径，只做“结果判定 + cts.cancel()”
    // 失败后的恢复统一在 executeSingleFriendshipRound 中串行处理，避免路径并发冲突
    const fightStartTime = Date.now();
    const successKeywords = ["事件", "完成"];
    const failureKeywords = ["失败"];
    const eventKeywords = getOcrKeywords(enemyType);
    const pollIntervalMs = 1000;
    let notFind = 0;

    while (Date.now() - fightStartTime < timeout) {
        if (!cts) cts = new CancellationTokenSource();
        if (isCtsCancellationRequested(cts)) {
            return "cancelled";
        }
        let capture = null;
        let result = null;
        let result2 = null;
        try {
            capture = captureGameRegion();
            // 沿用最初版写死的 OCR 框（1080p 下的“事件完成”识别区域）
            result = capture.find(RecognitionObject.ocr(850, 150, 200, 80));
            result2 = capture.find(RecognitionObject.ocr(0, 200, 300, 300));
            let text = result && result.text ? String(result.text) : "";
            text = text ? text.replace(/\s+/g, "") : "";
            let text2 = result2 && result2.text ? String(result2.text) : "";
            text2 = text2 ? text2.replace(/\s+/g, "") : "";
            if (enemyType === "蕈兽" && text2.includes("维沙瓦")) {
                log.info("战斗结果：成功");
                cts.cancel();
                return "success";
            }

            // 检查成功关键词：只要开战后识别到“事件/完成”等关键词即可认为本轮结束
            if (Date.now() - fightStartTime >= 2000) {
                for (let keyword of successKeywords) {
                    if (text.includes(keyword)) {
                        log.info("检测到战斗成功关键词: {0}", keyword);
                        log.info("战斗结果：成功");
                        cts.cancel(); // 取消任务
                        return "success";
                    }
                }
            }

            // 检查失败关键词
            for (let keyword of failureKeywords) {
                if (text.includes(keyword)) {
                    log.warn("检测到战斗失败关键词: {0}", keyword);
                    cts.cancel(); // 取消任务
                    return "failure";
                }
            }
            if (enemyType !== "蕈兽") {
                // 检查事件关键词
                let find = 0;
                for (let keyword of eventKeywords) {
                    if (text2.includes(keyword)) {
                        find++;
                    }
                }

                if (find === 0) {
                    notFind++;
                    log.info("未检测到任务触发关键词：{0} 次", notFind);
                } else {
                    notFind = 0;
                }

                if (notFind > 10) {
                    let nearBattlePoint = false;
                    if (battlePointCoords && Number.isFinite(Number(battlePointCoords.x)) && Number.isFinite(Number(battlePointCoords.y))) {
                        const pos = safeGetPositionFromMap();
                        if (pos && typeof pos === "object") {
                            const dx = Number(pos.x) - Number(battlePointCoords.x);
                            const dy = Number(pos.y) - Number(battlePointCoords.y);
                            const dist = Math.sqrt(dx * dx + dy * dy);
                            nearBattlePoint = Number.isFinite(dist) && dist <= 25;
                        }
                    }

                    if (nearBattlePoint) {
                        log.info("触发关键词消失但仍在战斗点附近，视为本轮结束");
                        cts.cancel();
                        return "success";
                    }

                    log.warn("不在任务触发区域，战斗失败");
                    cts.cancel(); // 取消任务
                    return "out_of_area";

                }
            }
        }
        catch (error) {
            log.error("OCR过程中出错: {0}", error);
            // 出错后继续循环，不进行额外嵌套处理
        }
        finally {
            safeDispose(result);
            safeDispose(result2);
            safeDispose(capture);
        }

        // 统一的检查间隔
        await sleep(pollIntervalMs);
    }

    log.warn("在超时时间内未检测到战斗结果");
    cts.cancel(); // 取消任务
    throw createScriptError(ERROR_CODES.BATTLE_TIMEOUT, ERR_MESSAGES.BATTLE_TIMEOUT);
}

/**
 * 验证超时时间设置
 * @param {number|string} value - 用户设置的超时时间（秒）
 * @param {number} defaultValue - 默认超时时间（秒）
 * @param {string} timeoutType - 超时类型名称
 * @returns {number} - 验证后的超时时间（秒）
 */
function validateTimeoutSetting(value, defaultValue, timeoutType) {
    // 转换为数字
    const timeout = Number(value);

    // 检查是否为有效数字且大于0
    if (!isFinite(timeout) || timeout <= 0) {
        log.warn(`${timeoutType} 超时设置无效，必须是大于0的数字，将使用默认值 ${defaultValue} 秒`);
        return defaultValue;
    }

    log.info(`${timeoutType}超时设置为 ${timeout} 秒`);
    return timeout;
}