import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
import { Br as ErrorCodes, Vr as errorShape, oa as parseSessionLabel } from "./protocol-BvHKcb_2.js";
import { t as loadCombinedSessionStoreForGateway } from "./combined-store-gateway-DUcp2q7F.js";
import { t as loadSessionStore } from "./store-load-8x3UDRSN.js";
import { o as updateSessionStore } from "./store-B46AdBNl.js";
import "./sessions-D8ZHV39C.js";
import { c as resolveDeletedAgentIdFromSessionKey, d as resolveGatewaySessionStoreTarget, o as migrateAndPruneGatewaySessionStoreKey, r as listSessionsFromStore } from "./session-utils-B30-zGfl.js";
//#region src/gateway/sessions-resolve.ts
function resolveSessionVisibilityFilterOptions(p) {
	return {
		includeGlobal: p.includeGlobal === true,
		includeUnknown: p.includeUnknown === true,
		spawnedBy: p.spawnedBy,
		agentId: p.agentId
	};
}
function noSessionFoundResult(key) {
	return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, `No session found: ${key}`)
	};
}
/** Rejects sessions whose owning agent no longer exists in config (#65524). */
function validateSessionAgentExists(cfg, key) {
	const deletedAgentId = resolveDeletedAgentIdFromSessionKey(cfg, key);
	if (deletedAgentId === null) return null;
	return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, `Agent "${deletedAgentId}" no longer exists in configuration`)
	};
}
function isResolvedSessionKeyVisible(params) {
	if (typeof params.p.spawnedBy !== "string" || params.p.spawnedBy.trim().length === 0) return true;
	return listSessionsFromStore({
		cfg: params.cfg,
		storePath: params.storePath,
		store: params.store,
		opts: resolveSessionVisibilityFilterOptions(params.p)
	}).sessions.some((session) => session.key === params.key);
}
async function resolveSessionKeyFromResolveParams(params) {
	const { cfg, p } = params;
	const key = normalizeOptionalString(p.key) ?? "";
	const hasKey = key.length > 0;
	const sessionId = normalizeOptionalString(p.sessionId) ?? "";
	const hasSessionId = sessionId.length > 0;
	const selectionCount = [
		hasKey,
		hasSessionId,
		(normalizeOptionalString(p.label) ?? "").length > 0
	].filter(Boolean).length;
	if (selectionCount > 1) return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, "Provide either key, sessionId, or label (not multiple)")
	};
	if (selectionCount === 0) return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, "Either key, sessionId, or label is required")
	};
	if (hasKey) {
		const target = resolveGatewaySessionStoreTarget({
			cfg,
			key
		});
		const store = loadSessionStore(target.storePath);
		if (store[target.canonicalKey]) {
			if (!isResolvedSessionKeyVisible({
				cfg,
				p,
				storePath: target.storePath,
				store,
				key: target.canonicalKey
			})) return noSessionFoundResult(key);
			const agentCheck = validateSessionAgentExists(cfg, target.canonicalKey);
			if (agentCheck) return agentCheck;
			return {
				ok: true,
				key: target.canonicalKey
			};
		}
		const legacyKey = target.storeKeys.find((candidate) => store[candidate]);
		if (!legacyKey) return noSessionFoundResult(key);
		await updateSessionStore(target.storePath, (s) => {
			const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
				cfg,
				key,
				store: s
			});
			if (!s[primaryKey] && s[legacyKey]) s[primaryKey] = s[legacyKey];
		});
		if (!isResolvedSessionKeyVisible({
			cfg,
			p,
			storePath: target.storePath,
			store: loadSessionStore(target.storePath),
			key: target.canonicalKey
		})) return noSessionFoundResult(key);
		const agentCheckLegacy = validateSessionAgentExists(cfg, target.canonicalKey);
		if (agentCheckLegacy) return agentCheckLegacy;
		return {
			ok: true,
			key: target.canonicalKey
		};
	}
	if (hasSessionId) {
		const { storePath, store } = loadCombinedSessionStoreForGateway(cfg);
		const matches = listSessionsFromStore({
			cfg,
			storePath,
			store,
			opts: {
				includeGlobal: p.includeGlobal === true,
				includeUnknown: p.includeUnknown === true,
				spawnedBy: p.spawnedBy,
				agentId: p.agentId
			}
		}).sessions.filter((session) => session.sessionId === sessionId || session.key === sessionId);
		if (matches.length === 0) return {
			ok: false,
			error: errorShape(ErrorCodes.INVALID_REQUEST, `No session found: ${sessionId}`)
		};
		if (matches.length > 1) {
			const keys = matches.map((session) => session.key).join(", ");
			return {
				ok: false,
				error: errorShape(ErrorCodes.INVALID_REQUEST, `Multiple sessions found for sessionId: ${sessionId} (${keys})`)
			};
		}
		const agentCheckSessionId = validateSessionAgentExists(cfg, matches[0].key);
		if (agentCheckSessionId) return agentCheckSessionId;
		return {
			ok: true,
			key: matches[0].key
		};
	}
	const parsedLabel = parseSessionLabel(p.label);
	if (!parsedLabel.ok) return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, parsedLabel.error)
	};
	const { storePath, store } = loadCombinedSessionStoreForGateway(cfg);
	const list = listSessionsFromStore({
		cfg,
		storePath,
		store,
		opts: {
			includeGlobal: p.includeGlobal === true,
			includeUnknown: p.includeUnknown === true,
			label: parsedLabel.label,
			agentId: p.agentId,
			spawnedBy: p.spawnedBy,
			limit: 2
		}
	});
	if (list.sessions.length === 0) return {
		ok: false,
		error: errorShape(ErrorCodes.INVALID_REQUEST, `No session found with label: ${parsedLabel.label}`)
	};
	if (list.sessions.length > 1) {
		const keys = list.sessions.map((s) => s.key).join(", ");
		return {
			ok: false,
			error: errorShape(ErrorCodes.INVALID_REQUEST, `Multiple sessions found with label: ${parsedLabel.label} (${keys})`)
		};
	}
	const agentCheckLabel = validateSessionAgentExists(cfg, list.sessions[0].key);
	if (agentCheckLabel) return agentCheckLabel;
	return {
		ok: true,
		key: list.sessions[0].key
	};
}
//#endregion
export { resolveSessionKeyFromResolveParams as t };
