import { mcpResourceMetadata } from "./mcp-resources";
import type {
  CapabilityMetadata,
  CapabilityReference,
  CapabilityPolicyConfiguration,
} from "../shared/capability-policy";
import { effectiveCapabilityPolicy } from "../shared/capability-policy";
import {
  selectableMcpTool,
  enabledMcpTools,
  mcpCapabilityMetadata,
} from "../shared/mcp-tools";
import type { McpConnection } from "../shared/mcp";
import type { McpConnections } from "./mcp-connections";
import type { SkillExternalAuthority } from "./skill-execution-permissions";

export { mcpCapabilityMetadata } from "../shared/mcp-tools";
export function resolveMcpCapability(
  connections: McpConnections,
  reference: CapabilityReference,
): CapabilityMetadata | undefined {
  if (reference.source.kind !== "mcp") return;
  const connection = connections.find(reference.source.id);
  return connection
    ? resolveConnectionCapability(connection, reference)
    : undefined;
}

/** Canonical choices and connection-attempt revisions retire old Skill grants. */
export function resolveMcpSkillAuthority(
  connections: McpConnections,
  reference: CapabilityReference,
): SkillExternalAuthority | undefined {
  if (reference.source.kind !== "mcp") return;
  const connection = connections.find(reference.source.id);
  if (!connection) return;
  const metadata = resolveConnectionCapability(connection, reference);
  if (!metadata) return;
  return {
    metadata,
    revision: JSON.stringify([
      connection.id,
      connection.revision,
      connection.settingsRevision,
      connection.authorityEpoch,
    ]),
  };
}

function resolveConnectionCapability(
  connection: McpConnection,
  reference: CapabilityReference,
): CapabilityMetadata | undefined {
  const tool = connection.capabilities.find((tool) => tool.id === reference.id);
  if (tool && selectableMcpTool(tool))
    return mcpCapabilityMetadata(connection, tool);
  const reader = mcpResourceMetadata(connection);
  if (reader?.id === reference.id) return reader;
}
export function mcpDefinitions(
  connections: McpConnection[],
  policy: CapabilityPolicyConfiguration,
) {
  const sources = new Map(
    connections.map((connection) => [connection.id, connection]),
  );
  return enabledMcpTools(connections).filter((tool) => {
    const connection = sources.get(tool.serverId);
    return (
      connection &&
      effectiveCapabilityPolicy(mcpCapabilityMetadata(connection, tool), policy)
        .policy !== "never"
    );
  });
}