import { ref, watch, type Ref, type ComputedRef } from "vue";
import { useI18n } from "vue-i18n";
import { useQueryStore } from "@/stores/queryStore";
import { useHistoryStore } from "@/stores/historyStore";
import { useConnectionStore } from "@/stores/connectionStore";
import { useSettingsStore } from "@/stores/settingsStore";
import { useToast } from "@/composables/useToast";
import { isSingleDatabase, usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
import { supportsConnectionScopedQueryExecution } from "@/lib/database/databaseFeatureSupport";
import { supportsConnectionLevelSqlExecution } from "@/lib/connection/connectionLevelDatabaseBootstrap";
import { classifySqlActivityKind } from "@/lib/history/historyActivityKind";
import { sqlMetadataRefreshTarget } from "@/lib/sql/sqlMetadataRefresh";
import { invalidateObjectMetadataCache } from "@/lib/metadata/objectMetadataCache";
import { defaultViewForResult } from "@/lib/query/queryResultDefaultView";
import { isQueryExecutionErrorResult } from "@/lib/query/queryResultError";
import { classifyRedisCommandSafety } from "@/lib/redis/redisCommandSafety";
import { isSqlExecutionSnapshot, resolveExecutableSql, type SqlExecutionOverride, type SqlExecutionSnapshot } from "@/lib/sql/sqlExecutionTarget";
import { isElasticsearchRestRequestText, parseElasticsearchRestRequestTarget, splitSqlStatementRanges, sqlStatementParameterOptionsForCompatibility } from "@/lib/sql/sqlStatementRanges";
import { extractSqlParameterDescriptors, type SqlParameterDescriptor, type SqlParameterSyntax } from "@/lib/sql/sqlParameters";
import { expandSqlVariables } from "@/lib/sql/sqlVariables";
import { enabledSqlParameterSyntaxes, resolveSqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
import { assessProductionSql } from "@/lib/database/productionSafety";
import { ensureReadOnlyWriteAccess } from "@/lib/database/readOnlyWriteAccess";
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import type { SqlExecutionDangerRequest } from "@/stores/sqlExecutionDangerStore";
import type { ConnectionConfig, DatabaseType, QueryTab } from "@/types/database";
import type { MultiDbExecutionTarget, MultiDbResultRunExecution, MultiDbTargetExecutionResult } from "@/types/sqlExecution";
import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
import type { SqlExecutionTargetContext } from "@/lib/database/sqlExecutionTargetRegistry";
import { translateBackendError } from "@/i18n/backend-errors";

const DANGER_RE = /^\s*(DROP|DELETE|TRUNCATE|ALTER|UPDATE|MERGE|REPLACE)\b/i;

interface SqlExecutionOptions {
  openInNewResultTab?: boolean;
  editorViewportRequestId?: number;
  /** Tab that owns this execution request; resolved once, never re-read from the global active tab. */
  tabId?: string;
}

/**
 * Targeting context captured synchronously when an execution request starts.
 * Async resume points (danger / parameter dialogs, awaits) must keep using it
 * instead of re-reading the global active tab or active connection.
 */
interface SqlExecutionContext {
  tabId: string;
  connection: ConnectionConfig | undefined;
}

interface TargetSqlExecutionInput {
  tab: QueryTab;
  connection: ConnectionConfig;
  sql: string;
  executionTarget?: MultiDbExecutionTarget;
  resultRun?: {
    batchId: string;
    title: string;
    target: MultiDbExecutionTarget;
  };
  sourceOffset?: number;
  blockDangerousRedisCommands?: boolean;
  targetLabel?: string;
  scopeId?: string;
  isCancellationRequested?: () => boolean;
  targetContext?: SqlExecutionTargetContext;
}

export function stripSqlComments(sql: string): string {
  return sql
    .replace(/\/\*[\s\S]*?\*\//g, " ")
    .replace(/--.*$/gm, " ")
    .replace(/#.*$/gm, " ");
}

const ELASTICSEARCH_TRANSIENT_DELETE_PATHS = [/^\/_search\/scroll\/?$/i, /^\/_pit\/?$/i, /^\/_async_search\/[^/?]+\/?$/i];
const ELASTICSEARCH_DESTRUCTIVE_POST_PATHS = [/(?:^|\/)_(?:delete_by_query|update_by_query|bulk)(?:\/|$)/i, /^\/_reindex(?:\/|$)/i, /^\/_aliases(?:\/|$)/i, /\/_restore(?:\/|$)/i];

function isDangerousElasticsearchRequest(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD", path: string): boolean {
  const pathname = path.split("?", 1)[0].replace(/\/+$/, "") || "/";
  if (method === "DELETE") return !ELASTICSEARCH_TRANSIENT_DELETE_PATHS.some((pattern) => pattern.test(pathname));
  if (method === "PUT" || method === "PATCH") return true;
  return method === "POST" && ELASTICSEARCH_DESTRUCTIVE_POST_PATHS.some((pattern) => pattern.test(pathname));
}

function isDangerousMeilisearchRequest(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD", path: string): boolean {
  if (method === "GET" || method === "HEAD") return false;
  if (method === "DELETE" || method === "PUT" || method === "PATCH") return true;
  const pathname = path.split("?", 1)[0].replace(/\/+$/, "") || "/";
  return !(pathname === "/multi-search" || /\/search$/i.test(pathname) || /\/facet-search$/i.test(pathname) || /\/similar$/i.test(pathname) || /\/documents\/fetch$/i.test(pathname));
}

export function isDangerousSql(sql: string, databaseType?: DatabaseType): boolean {
  if (databaseType === "elasticsearch" || databaseType === "easysearch" || databaseType === "meilisearch") {
    const requests = splitSqlStatementRanges(sql, databaseType)
      .map((statement) => parseElasticsearchRestRequestTarget(statement.sql))
      .filter((request): request is NonNullable<typeof request> => request !== null);
    if (requests.length > 0) {
      return requests.some((request) => (databaseType === "meilisearch" ? isDangerousMeilisearchRequest(request.method, request.path) : isDangerousElasticsearchRequest(request.method, request.path)));
    }
  }
  const cleaned = stripSqlComments(sql);
  return cleaned.split(";").some((stmt) => DANGER_RE.test(stmt));
}

function primarySqlOperation(sql: string): string {
  const cleaned = stripSqlComments(sql);
  const statement = cleaned
    .split(";")
    .map((part) => part.trim())
    .find(Boolean);
  return statement?.match(/^([a-z]+)/i)?.[1]?.toUpperCase() || "SQL";
}

function firstQueryExecutionError(tab: Pick<QueryTab, "result" | "results">) {
  const activeResult = tab.result;
  if (activeResult && isQueryExecutionErrorResult(activeResult)) return activeResult;

  const results = tab.results?.length ? tab.results : tab.result ? [tab.result] : [];
  return results.find((result) => isQueryExecutionErrorResult(result));
}

export function useSqlExecution(deps: {
  activeTab: ComputedRef<QueryTab | undefined>;
  activeConnection: ComputedRef<ConnectionConfig | undefined>;
  executableSql: ComputedRef<string>;
  resolveExecutableSql?: (snapshot?: SqlExecutionSnapshot, tab?: QueryTab) => Promise<string>;
  activeOutputView: Ref<"result" | "summary" | "explain" | "chart" | "messages" | "profile">;
  blockDangerousRedisCommands?: Ref<boolean>;
  onMissingDatabase?: (tabId?: string) => void;
  requestDangerConfirmation?: (request: SqlExecutionDangerRequest) => Promise<boolean>;
  onExecutionStarted?: (editorViewportRequestId: number) => void;
  onExecutionCancelled?: (editorViewportRequestId: number) => void;
}) {
  const { t } = useI18n();
  const queryStore = useQueryStore();
  const historyStore = useHistoryStore();
  const connectionStore = useConnectionStore();
  const settingsStore = useSettingsStore();
  const productionSafetyStore = useProductionSafetyStore();
  const { toast } = useToast();

  const dangerSql = ref("");
  const pendingDangerSql = ref("");
  const showDangerDialog = ref(false);
  const suppressDangerConfirm = ref(false);
  const explainMode = ref<"explain" | "autotrace">("explain");
  const showSqlParameterDialog = ref(false);
  const sqlParameterSourceSql = ref("");
  const sqlParameterNames = ref<SqlParameterDescriptor[]>([]);
  const sqlParameterDatabaseType = ref<DatabaseType | undefined>();
  const sqlParameterEnabledSyntaxes = ref<SqlParameterSyntax[]>([]);
  const pendingSourceOffset = ref<number | undefined>();
  const pendingDangerKind = ref<"sql" | "redis">("sql");
  const pendingDangerSourceOffset = ref<number | undefined>();
  const pendingOpenInNewResultTab = ref(false);
  const pendingSqlParameterEditorViewportRequestId = ref<number | undefined>();
  const pendingDangerEditorViewportRequestId = ref<number | undefined>();
  const pendingDangerTabId = ref<string | undefined>();
  const pendingSqlParameterTabId = ref<string | undefined>();
  let pendingSqlParameterContinuation: ((sql: string, sourceOffset?: number) => Promise<void> | void) | undefined;

  function cancelEditorViewportRequest(editorViewportRequestId?: number) {
    if (editorViewportRequestId !== undefined) deps.onExecutionCancelled?.(editorViewportRequestId);
  }

  function resolveExecutionTab(tabId: string | undefined): QueryTab | undefined {
    if (!tabId) {
      return deps.activeTab.value;
    }
    const fromStore = queryStore.tabs.find((tab) => tab.id === tabId);
    if (fromStore) {
      return fromStore;
    }
    // The host may hold the acting tab outside the store array (multi-db
    // workers, hosts under test); identity still comes from the captured id.
    return deps.activeTab.value?.id === tabId ? deps.activeTab.value : undefined;
  }

  function resolveExecutionConnection(tabId: string | undefined): ConnectionConfig | undefined {
    const tab = resolveExecutionTab(tabId);
    return (tab ? connectionStore.getConfig(tab.connectionId) : undefined) ?? deps.activeConnection.value;
  }

  function captureExecutionContext(tabId?: string): SqlExecutionContext | undefined {
    const tab = resolveExecutionTab(tabId);
    if (!tab) {
      return undefined;
    }
    return { tabId: tab.id, connection: resolveExecutionConnection(tabId) };
  }

  async function resolvedExecutableSql(source: SqlExecutionOverride | undefined, context: SqlExecutionContext): Promise<{ sql: string; sourceOffset?: number; editorViewportRequestId?: number }> {
    const atSetEnabled = resolveSqlVariableSyntaxToggles(settingsStore.editorSettings.sqlVariableSyntaxOverrides, context.connection?.db_type, settingsStore.editorSettings.sqlVariableSubstitutionEnabled).atSet;
    const databaseType = effectiveDatabaseTypeForConnection(context.connection) ?? context.connection?.db_type;
    const expand = (sql: string, declarationSql?: string) => (atSetEnabled ? expandSqlVariables(sql, { declarationSql, databaseType }).sql : sql);
    if (typeof source === "string") return { sql: expand(source) };

    const resolved = deps.resolveExecutableSql ? await deps.resolveExecutableSql(source, resolveExecutionTab(context.tabId)) : isSqlExecutionSnapshot(source) ? resolveExecutableSql(source.fullSql, source.selectedSql, { cursorPos: source.cursorPos }) : deps.executableSql.value;
    const declarationSql = isSqlExecutionSnapshot(source) ? source.fullSql.slice(0, source.selectionTo) : resolved;
    const sql = expand(resolved, declarationSql);
    const editorViewportRequestId = isSqlExecutionSnapshot(source) ? source.editorViewportRequestId : undefined;
    if (!isSqlExecutionSnapshot(source) || !source.selectedSql.trim() || sql !== resolved) return { sql, editorViewportRequestId };

    const leadingWhitespace = source.selectedSql.length - source.selectedSql.trimStart().length;
    return { sql, sourceOffset: source.selectionFrom + leadingWhitespace, editorViewportRequestId };
  }

  async function tryExecute(sqlOverride?: SqlExecutionOverride, options: SqlExecutionOptions = {}) {
    const context = captureExecutionContext(options.tabId);
    if (!context) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    const { sql, sourceOffset, editorViewportRequestId } = await resolvedExecutableSql(sqlOverride, context);
    const executionOptions = { ...options, editorViewportRequestId, tabId: context.tabId };
    if (!sql.trim()) {
      cancelEditorViewportRequest(editorViewportRequestId);
      return;
    }
    const tab = resolveExecutionTab(context.tabId);
    if (!tab) {
      cancelEditorViewportRequest(editorViewportRequestId);
      return;
    }
    if (requiresDatabaseSelection(tab, context.connection, sql)) {
      deps.onMissingDatabase?.(context.tabId);
      cancelEditorViewportRequest(editorViewportRequestId);
      return;
    }
    if (supportsSqlTemplateParameters(context.connection, sql) && prepareSqlParameterDialog(sql, sourceOffset, executionOptions)) {
      return;
    }
    await continueExecute(context, sql, sourceOffset, executionOptions);
  }

  function tryExecuteInNewResultTab(sqlOverride?: SqlExecutionOverride, options: SqlExecutionOptions = {}) {
    return tryExecute(sqlOverride, { ...options, openInNewResultTab: true });
  }

  async function continueExecute(context: SqlExecutionContext, sql: string, sourceOffset?: number, options: SqlExecutionOptions = {}) {
    const tab = resolveExecutionTab(context.tabId);
    if (!tab) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    if (!(await ensureReadOnlyWriteAccess({ connection: context.connection, sql, source: t("production.sourceSqlEditor") }))) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    // Redis: block dangerous commands when toggle is on (scan entire batch for highest safety level)
    if (context.connection?.db_type === "redis" && deps.blockDangerousRedisCommands?.value !== false) {
      const commands = sql
        .split("\n")
        .map((line) => line.trim())
        .filter((line) => line.length > 0);
      let highestSafety: "allowed" | "write" | "confirm" | "blocked" = "allowed";
      for (const cmd of commands) {
        const safety = classifyRedisCommandSafety(cmd);
        if (safety === "blocked") {
          highestSafety = "blocked";
          break;
        }
        if (safety === "confirm") {
          highestSafety = "confirm";
        }
      }
      if (highestSafety === "blocked") {
        toast(t("redis.blockedCommand", { command: "Redis" }), 5000);
        cancelEditorViewportRequest(options.editorViewportRequestId);
        return;
      }
      if (highestSafety === "confirm") {
        dangerSql.value = sql;
        pendingDangerSql.value = sql;
        pendingDangerKind.value = "redis";
        pendingDangerSourceOffset.value = sourceOffset;
        pendingOpenInNewResultTab.value = options.openInNewResultTab === true;
        pendingDangerEditorViewportRequestId.value = options.editorViewportRequestId;
        pendingDangerTabId.value = context.tabId;
        suppressDangerConfirm.value = false;
        showDangerDialog.value = true;
        return;
      }
    }
    const productionAssessment = assessProductionSql(sql, context.connection, tab.database);
    if (productionAssessment.active && productionAssessment.isMutation) {
      // Production writes always need a new explicit decision; editor preferences cannot suppress this gate.
      const confirmed = await productionSafetyStore.requestConfirmation({
        sql,
        connectionName: context.connection?.name,
        database: tab.database,
        productionDatabases: productionAssessment.databases,
        source: t("production.sourceSqlEditor"),
      });
      if (confirmed) {
        await doExecute(sql, sourceOffset, options);
      } else {
        cancelEditorViewportRequest(options.editorViewportRequestId);
      }
      return;
    }
    if (isDangerousSql(sql, context.connection?.db_type) && settingsStore.editorSettings.confirmDangerousSqlExecution) {
      dangerSql.value = sql;
      pendingDangerSql.value = sql;
      pendingDangerKind.value = "sql";
      pendingDangerSourceOffset.value = sourceOffset;
      pendingOpenInNewResultTab.value = options.openInNewResultTab === true;
      pendingDangerEditorViewportRequestId.value = options.editorViewportRequestId;
      pendingDangerTabId.value = context.tabId;
      suppressDangerConfirm.value = false;
      showDangerDialog.value = true;
    } else {
      await doExecute(sql, sourceOffset, options);
    }
  }

  function prepareSqlParameterDialog(sql: string, sourceOffset?: number, options: SqlExecutionOptions = {}, continuation?: (sql: string, sourceOffset?: number) => Promise<void> | void): boolean {
    const connection = resolveExecutionConnection(options.tabId);
    const databaseType = effectiveDatabaseTypeForConnection(connection) ?? connection?.db_type;
    const toggles = resolveSqlVariableSyntaxToggles(settingsStore.editorSettings.sqlVariableSyntaxOverrides, databaseType, settingsStore.editorSettings.sqlVariableSubstitutionEnabled);
    const enabledSyntaxes = enabledSqlParameterSyntaxes(toggles);
    const parameters = extractSqlParameterDescriptors(sql, { databaseType, enabledSyntaxes });
    if (!parameters.length) {
      return false;
    }
    sqlParameterSourceSql.value = sql;
    sqlParameterNames.value = parameters;
    sqlParameterDatabaseType.value = databaseType;
    sqlParameterEnabledSyntaxes.value = enabledSyntaxes;
    pendingSourceOffset.value = sourceOffset;
    pendingOpenInNewResultTab.value = options.openInNewResultTab === true;
    pendingSqlParameterEditorViewportRequestId.value = options.editorViewportRequestId;
    pendingSqlParameterTabId.value = options.tabId;
    pendingSqlParameterContinuation = continuation;
    showSqlParameterDialog.value = true;
    return true;
  }

  async function prepareMultiExecute(onReady: (sql: string, sourceOffset?: number) => Promise<void> | void): Promise<boolean> {
    const context = captureExecutionContext();
    if (!context) {
      return false;
    }
    const { sql, sourceOffset } = await resolvedExecutableSql(undefined, context);
    if (!sql.trim()) return false;
    if (supportsSqlTemplateParameters(context.connection, sql) && prepareSqlParameterDialog(sql, sourceOffset, { tabId: context.tabId }, onReady)) {
      return true;
    }
    await onReady(sql, sourceOffset);
    return false;
  }

  // SQL Server batches that end in PRINT/DBCC-style messages with no rows of their own get
  // synthesized into a "Message" pseudo-result (server_message: true). The store's generic
  // "first result with columns" pick can land on that pseudo-result instead of real data, so
  // whenever it does, redirect focus to the first real data result (falling back to the
  // message itself only if there is no data result to show). Shared by every SQL execution
  // entry point so none of them can regress independently (see #6189).
  function focusSqlServerDataResult(executionTabId: string, executionDatabaseType: DatabaseType | undefined, tab: Pick<QueryTab, "results" | "result" | "activeResultIndex">) {
    if (executionDatabaseType !== "sqlserver") return;
    const sqlServerMessageResultIndex = tab.results?.findIndex((result) => result.server_message === true);
    if (sqlServerMessageResultIndex === undefined || sqlServerMessageResultIndex < 0) return;
    const activeSqlServerResult = tab.results && tab.activeResultIndex !== undefined ? tab.results[tab.activeResultIndex] : tab.result;
    if (activeSqlServerResult?.server_message !== true) return;
    const sqlServerDataResultIndex = tab.results?.findIndex((result) => result.server_message !== true && !isQueryExecutionErrorResult(result) && result.columns.length > 0);
    queryStore.setActiveResultIndex(executionTabId, sqlServerDataResultIndex !== undefined && sqlServerDataResultIndex >= 0 ? sqlServerDataResultIndex : sqlServerMessageResultIndex);
  }

  async function doExecute(sql?: string, sourceOffset?: number, options: SqlExecutionOptions = {}) {
    if (sql === undefined) {
      const context = captureExecutionContext(options.tabId);
      if (!context) {
        cancelEditorViewportRequest(options.editorViewportRequestId);
        return;
      }
      ({ sql, sourceOffset } = await resolvedExecutableSql(undefined, context));
    }
    const executionTabId = options.tabId ?? deps.activeTab.value?.id;
    if (!executionTabId || !sql || !sql.trim()) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    const tab = resolveExecutionTab(executionTabId);
    if (!tab) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    const executionConnection = connectionStore.getConfig(tab.connectionId) ?? deps.activeConnection.value;
    const executionDatabaseType = executionConnection?.db_type;
    if (requiresDatabaseSelection(tab, executionConnection, sql)) {
      deps.onMissingDatabase?.(executionTabId);
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    const statementCount = splitSqlStatementRanges(sql, executionDatabaseType, sqlStatementParameterOptionsForCompatibility(executionDatabaseType, executionDatabaseType === "opengauss" ? connectionStore.databaseCompatibilityMode(tab.connectionId, tab.database) : undefined)).length;
    // Output-view switching belongs to the tab the user is looking at — both
    // when the query starts and when it finishes.
    if (deps.activeTab.value?.id === executionTabId) {
      deps.activeOutputView.value = statementCount > 1 ? settingsStore.editorSettings.multiStatementDefaultView : "result";
    }
    const connName = executionConnection?.name || "";
    const start = Date.now();
    const isRedis = executionDatabaseType === "redis";
    const producedResult = await queryStore.executeCurrentSql(sql, {
      tabId: executionTabId,
      ...(isRedis ? { skipRedisSafetyCheck: deps.blockDangerousRedisCommands?.value === false } : {}),
      ...(sourceOffset !== undefined ? { sourceOffset } : {}),
      ...(options.openInNewResultTab ? { openInNewResultTab: true } : {}),
      ...(options.editorViewportRequestId !== undefined ? { onExecutionStarted: () => deps.onExecutionStarted?.(options.editorViewportRequestId!) } : {}),
    });
    if (producedResult === false) {
      cancelEditorViewportRequest(options.editorViewportRequestId);
      return;
    }
    const executionTabStillActive = deps.activeTab.value?.id === executionTabId;
    const sqlServerMessageResultIndex = executionDatabaseType === "sqlserver" ? tab.results?.findIndex((result) => result.server_message === true) : undefined;
    if (sqlServerMessageResultIndex !== undefined && sqlServerMessageResultIndex >= 0) {
      focusSqlServerDataResult(tab.id, executionDatabaseType, tab);
      if (executionTabStillActive) {
        deps.activeOutputView.value = tab.result?.server_message === true ? "messages" : "result";
      }
    } else if (executionDatabaseType === "sqlserver" && tab.result?.server_message === true) {
      if (executionTabStillActive) {
        deps.activeOutputView.value = "messages";
      }
    } else if (tab.result && !tab.result.columns.length && !tab.results?.some((result) => result.columns.length > 0)) {
      if (executionTabStillActive) {
        deps.activeOutputView.value = statementCount === 1 ? defaultViewForResult(tab.result) : "summary";
      }
    }
    const elapsed = Date.now() - start;
    const failure = firstQueryExecutionError(tab);
    const success = !failure;
    historyStore.add({
      connection_id: tab.connectionId,
      connection_name: connName,
      database: tab.database,
      sql,
      execution_time_ms: elapsed,
      success,
      error: failure ? (failure.error ? translateBackendError(t, failure.error, failure.rows?.[0]?.[0]) : String(failure.rows?.[0]?.[0] ?? "")) : undefined,
      activity_kind: classifySqlActivityKind(sql),
      operation: primarySqlOperation(sql),
      affected_rows: success ? tab.result?.affected_rows : undefined,
    });
    if (success) {
      const refreshTarget = sqlMetadataRefreshTarget(sql, tab.schema);
      if (refreshTarget.scope === "connection") {
        connectionStore.invalidateMetadataCache(tab.connectionId);
        await invalidateObjectMetadataCache({ connectionId: tab.connectionId });
        await connectionStore.loadDatabases(tab.connectionId, { force: true });
      } else if (refreshTarget.scope === "database") {
        await invalidateObjectMetadataCache({ connectionId: tab.connectionId, database: tab.database, schema: refreshTarget.schema });
        await connectionStore.refreshObjectListTreeNode(tab.connectionId, tab.database, refreshTarget.schema);
      }
    }
  }

  async function executeTargetSql(input: TargetSqlExecutionInput): Promise<MultiDbTargetExecutionResult> {
    const { tab, connection, sql, sourceOffset, targetLabel } = input;
    const startedAt = Date.now();
    const executionTab = input.executionTarget
      ? {
          ...tab,
          connectionId: input.executionTarget.connectionId,
          catalog: input.executionTarget.catalog,
          database: input.executionTarget.database,
          schema: input.executionTarget.schema,
        }
      : tab;
    const finish = (result: MultiDbTargetExecutionResult): MultiDbTargetExecutionResult => ({
      ...result,
      durationMs: Date.now() - startedAt,
    });
    const cancelRequested = () => input.isCancellationRequested?.() === true;
    const tabCancelRequested = (count: number) => (tab.cancelRequestCount ?? 0) !== count;
    if (cancelRequested()) return finish({ status: "cancelled" });
    if (!sql.trim()) return finish({ status: "failed", errorMessage: t("explain.emptySql") });
    if (!(await ensureReadOnlyWriteAccess({ connection, sql, source: t("production.sourceMultiDbSql") }))) {
      return finish({ status: "skipped", errorMessage: t("dangerDialog.cancel") });
    }
    if (requiresDatabaseSelection(executionTab, connection, sql)) {
      return finish({ status: "failed", errorMessage: t("editor.selectDatabaseRequired") });
    }

    const blockRedisCommands = input.blockDangerousRedisCommands !== false;
    if (connection.db_type === "redis" && blockRedisCommands) {
      const commands = sql
        .split("\n")
        .map((line) => line.trim())
        .filter((line) => line.length > 0);
      let highestSafety: "allowed" | "confirm" | "blocked" = "allowed";
      for (const command of commands) {
        const safety = classifyRedisCommandSafety(command);
        if (safety === "blocked") {
          highestSafety = "blocked";
          break;
        }
        if (safety === "confirm") highestSafety = "confirm";
      }
      if (highestSafety === "blocked") {
        return finish({ status: "skipped", errorMessage: t("redis.blockedCommand", { command: "Redis" }) });
      }
      if (highestSafety === "confirm") {
        const confirmed = await deps.requestDangerConfirmation?.({
          sql,
          kind: "redis",
          connectionName: connection.name,
          database: executionTab.database,
          targetLabel,
          databaseType: connection.db_type,
          scopeId: input.scopeId,
        });
        if (cancelRequested()) return finish({ status: "cancelled" });
        if (!confirmed) return finish({ status: "skipped", errorMessage: t("dangerDialog.cancel") });
      }
    }

    const productionAssessment = assessProductionSql(sql, connection, executionTab.database);
    if (productionAssessment.active && productionAssessment.isMutation) {
      const confirmed = await productionSafetyStore.requestConfirmation({
        sql,
        connectionName: connection.name,
        database: executionTab.database,
        productionDatabases: productionAssessment.databases,
        source: t("production.sourceMultiDbSql"),
        scopeId: input.scopeId,
      });
      if (cancelRequested()) return finish({ status: "cancelled" });
      if (!confirmed) return finish({ status: "skipped", errorMessage: t("dangerDialog.cancel") });
    }

    if (isDangerousSql(sql, connection.db_type) && settingsStore.editorSettings.confirmDangerousSqlExecution) {
      const confirmed = await deps.requestDangerConfirmation?.({
        sql,
        kind: "sql",
        connectionName: connection.name,
        database: executionTab.database,
        targetLabel,
        databaseType: connection.db_type,
        scopeId: input.scopeId,
      });
      if (cancelRequested()) return finish({ status: "cancelled" });
      if (!confirmed) return finish({ status: "skipped", errorMessage: t("dangerDialog.cancel") });
    }

    if (cancelRequested()) return finish({ status: "cancelled" });
    const cancelRequestCount = tab.cancelRequestCount ?? 0;
    const workerId = input.executionTarget ? queryStore.createMultiDbExecutionWorker(tab.id, input.executionTarget, input.scopeId ?? "") : undefined;
    if (input.executionTarget && !workerId) return finish({ status: "failed", errorMessage: t("multiDbExecute.targetMissingConnection") });
    const executionTabId = workerId ?? tab.id;
    const captureWorkerResult = (status: MultiDbResultRunExecution["status"], errorMessage?: string): string | undefined => {
      if (!workerId || !input.resultRun) return undefined;
      return queryStore.captureMultiDbExecutionWorkerResult(tab.id, workerId, sql, {
        kind: "multi-db",
        batchId: input.resultRun.batchId,
        target: input.resultRun.target,
        title: input.resultRun.title,
        status,
        durationMs: Date.now() - startedAt,
        errorMessage,
      });
    };
    try {
      await queryStore.executeTabSql(executionTabId, sql, {
        resultBaseSql: sql,
        ...(input.targetContext ? { targetContext: input.targetContext } : {}),
        ...(sourceOffset !== undefined ? { sourceOffset } : {}),
        ...(connection.db_type === "redis" ? { skipRedisSafetyCheck: !blockRedisCommands } : {}),
      });
      const latest = queryStore.getExecutionTab(executionTabId) ?? tab;
      if (cancelRequested() || tabCancelRequested(cancelRequestCount)) {
        return finish({ status: "cancelled" });
      }
      focusSqlServerDataResult(executionTabId, connection.db_type, latest);
      const failure = firstQueryExecutionError(latest);
      const errorMessage = failure ? (failure.error ? translateBackendError(t, failure.error, failure.rows?.[0]?.[0]) : String(failure.rows?.[0]?.[0] ?? t("common.failed"))) : undefined;
      const success = !failure;
      const resultStatus = success ? "success" : "failed";
      captureWorkerResult(resultStatus, errorMessage);
      historyStore.add({
        connection_id: executionTab.connectionId,
        connection_name: connection.name || "",
        database: executionTab.database,
        sql,
        execution_time_ms: Date.now() - startedAt,
        success,
        error: errorMessage,
        activity_kind: classifySqlActivityKind(sql),
        operation: primarySqlOperation(sql),
        affected_rows: success ? latest.result?.affected_rows : undefined,
      });
      if (success) {
        const refreshTarget = sqlMetadataRefreshTarget(sql, executionTab.schema);
        if (refreshTarget.scope === "connection") {
          connectionStore.invalidateMetadataCache(executionTab.connectionId);
          await invalidateObjectMetadataCache({ connectionId: executionTab.connectionId });
          await connectionStore.loadDatabases(executionTab.connectionId, { force: true });
        } else if (refreshTarget.scope === "database") {
          await invalidateObjectMetadataCache({ connectionId: executionTab.connectionId, database: executionTab.database, schema: refreshTarget.schema });
          await connectionStore.refreshObjectListTreeNode(executionTab.connectionId, executionTab.database, refreshTarget.schema);
        }
      }
      // 多库 worker 路径（workerId 存在）下不切主编辑器输出视图：并行 Promise.all
      // 会让多个 worker 几乎同时改这个共享 ref，导致主视图在 result/summary 间反复
      // 跳动（闪烁/竞态）。worker 结果已由 captureMultiDbExecutionWorkerResult 记录
      // 到 source tab 的 result run 并通过 projectResultRun 投影显示，无需再切主视图。
      if (!workerId && deps.activeTab.value?.id === tab.id) {
        deps.activeOutputView.value = success && latest.result?.server_message === true ? "messages" : success && (latest.result?.columns.length || latest.results?.some((result) => result.columns.length)) ? "result" : "summary";
      }
      return finish(success ? { status: "success", errorMessage } : { status: "failed", errorMessage });
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      captureWorkerResult("failed", errorMessage);
      return finish({ status: "failed", errorMessage });
    } finally {
      if (workerId) await queryStore.removeMultiDbExecutionWorker(workerId, input.scopeId);
    }
  }

  /**
   * Opens the danger dialog for an App-level flow (AI auto-execution) that has
   * already made its own gating decision. The acting tab id is captured here so
   * the confirmation resumes against the requesting tab, not whichever tab is
   * active when the user confirms.
   */
  function requestDangerConfirmation(sql: string, tabId?: string) {
    dangerSql.value = sql;
    pendingDangerSql.value = sql;
    pendingDangerKind.value = "sql";
    pendingOpenInNewResultTab.value = false;
    pendingDangerTabId.value = tabId;
    suppressDangerConfirm.value = false;
    showDangerDialog.value = true;
  }

  function cancelActiveExecution(tabId?: string) {
    const tab = resolveExecutionTab(tabId);
    if (!tab) {
      return;
    }
    if (tab.isExecuting) {
      void queryStore.cancelTabExecution(tab.id);
    } else if (tab.isExplaining) {
      void queryStore.cancelTabExplain(tab.id);
    }
  }

  function explainReasonMessage(reason: string): string {
    if (reason === "unsupported") {
      return t("explain.unsupported");
    }
    if (reason === "unsafe") {
      return t("explain.unsafe");
    }
    return t("explain.emptySql");
  }

  async function runExplain(sql: string, context: SqlExecutionContext) {
    const tab = resolveExecutionTab(context.tabId);
    if (!tab || !sql.trim()) {
      toast(t("explain.emptySql"));
      return;
    }

    if (deps.activeTab.value?.id === tab.id) {
      deps.activeOutputView.value = "explain";
    }
    const databaseType = effectiveDatabaseTypeForConnection(context.connection) ?? context.connection?.db_type;
    const result = await queryStore.explainTabSql(tab.id, sql, databaseType, explainMode.value);
    if (!result.ok) {
      toast(explainReasonMessage(result.reason), 5000);
      return;
    }

    const current = resolveExecutionTab(context.tabId);
    if (current?.explainError) {
      toast(current.explainError, 5000);
    }
  }

  async function tryExplain(sqlOverride?: SqlExecutionOverride, options: SqlExecutionOptions = {}) {
    const context = captureExecutionContext(options.tabId);
    if (!context) {
      return;
    }
    const { sql, sourceOffset } = await resolvedExecutableSql(sqlOverride, context);
    if (!sql.trim()) {
      toast(t("explain.emptySql"));
      return;
    }
    // Resolve SQL template variables exactly like tryExecute so EXPLAIN never runs the raw
    // placeholders (e.g. `EXPLAIN (FORMAT JSON) SELECT :var;` fails on PostgreSQL).
    if (supportsSqlTemplateParameters(context.connection, sql) && prepareSqlParameterDialog(sql, sourceOffset, { tabId: context.tabId }, (resolvedSql) => runExplain(resolvedSql, context))) {
      return;
    }
    await runExplain(sql, context);
  }

  async function onDangerConfirm() {
    const sql = pendingDangerSql.value;
    const sourceOffset = pendingDangerSourceOffset.value;
    const kind = pendingDangerKind.value;
    const openInNewResultTab = pendingOpenInNewResultTab.value;
    const editorViewportRequestId = pendingDangerEditorViewportRequestId.value;
    const tabId = pendingDangerTabId.value;
    pendingDangerSql.value = "";
    pendingDangerSourceOffset.value = undefined;
    pendingDangerKind.value = "sql";
    pendingOpenInNewResultTab.value = false;
    pendingDangerEditorViewportRequestId.value = undefined;
    pendingDangerTabId.value = undefined;
    if (suppressDangerConfirm.value && kind === "sql") {
      settingsStore.updateEditorSettings({ confirmDangerousSqlExecution: false });
    }
    suppressDangerConfirm.value = false;
    const tab = resolveExecutionTab(tabId);
    if (!tab) {
      return;
    }
    const connection = connectionStore.getConfig(tab.connectionId);
    if (!(await ensureReadOnlyWriteAccess({ connection, sql, source: t("production.sourceSqlEditor") }))) {
      cancelEditorViewportRequest(editorViewportRequestId);
      return;
    }
    await doExecute(sql, sourceOffset, { openInNewResultTab, editorViewportRequestId, tabId: tab.id });
  }

  async function onSqlParametersConfirm(sql: string) {
    const openInNewResultTab = pendingOpenInNewResultTab.value;
    const editorViewportRequestId = pendingSqlParameterEditorViewportRequestId.value;
    const tabId = pendingSqlParameterTabId.value;
    showSqlParameterDialog.value = false;
    sqlParameterSourceSql.value = "";
    sqlParameterNames.value = [];
    sqlParameterDatabaseType.value = undefined;
    sqlParameterEnabledSyntaxes.value = [];
    const sourceOffset = pendingSourceOffset.value;
    pendingSourceOffset.value = undefined;
    pendingOpenInNewResultTab.value = false;
    pendingSqlParameterEditorViewportRequestId.value = undefined;
    pendingSqlParameterTabId.value = undefined;
    const continuation = pendingSqlParameterContinuation;
    pendingSqlParameterContinuation = undefined;
    if (continuation) {
      await continuation(sql, sourceOffset);
      return;
    }
    const context = captureExecutionContext(tabId);
    if (!context) {
      return;
    }
    await continueExecute(context, sql, sourceOffset, { openInNewResultTab, editorViewportRequestId, tabId: context.tabId });
  }

  watch(showSqlParameterDialog, (open) => {
    if (open) return;
    const editorViewportRequestId = pendingSqlParameterEditorViewportRequestId.value;
    sqlParameterSourceSql.value = "";
    sqlParameterNames.value = [];
    sqlParameterDatabaseType.value = undefined;
    sqlParameterEnabledSyntaxes.value = [];
    pendingSourceOffset.value = undefined;
    pendingOpenInNewResultTab.value = false;
    pendingSqlParameterEditorViewportRequestId.value = undefined;
    pendingSqlParameterTabId.value = undefined;
    pendingSqlParameterContinuation = undefined;
    cancelEditorViewportRequest(editorViewportRequestId);
  });

  watch(showDangerDialog, (open) => {
    if (open) return;
    const editorViewportRequestId = pendingDangerEditorViewportRequestId.value;
    pendingDangerSql.value = "";
    pendingDangerSourceOffset.value = undefined;
    pendingDangerKind.value = "sql";
    pendingOpenInNewResultTab.value = false;
    pendingDangerEditorViewportRequestId.value = undefined;
    pendingDangerTabId.value = undefined;
    suppressDangerConfirm.value = false;
    cancelEditorViewportRequest(editorViewportRequestId);
  });

  return {
    dangerSql,
    pendingDangerSql,
    showDangerDialog,
    suppressDangerConfirm,
    tryExecute,
    tryExecuteInNewResultTab,
    doExecute,
    cancelActiveExecution,
    requestDangerConfirmation,
    tryExplain,
    onDangerConfirm,
    showSqlParameterDialog,
    sqlParameterSourceSql,
    sqlParameterNames,
    sqlParameterDatabaseType,
    sqlParameterEnabledSyntaxes,
    onSqlParametersConfirm,
    prepareMultiExecute,
    executeTargetSql,
    explainMode,
  };
}

export function supportsSqlTemplateParameters(connection: Pick<ConnectionConfig, "db_type"> | undefined, sql = ""): boolean {
  if (!connection) return false;
  if (connection.db_type === "meilisearch") return false;
  if (connection.db_type === "elasticsearch" || connection.db_type === "easysearch") return !isElasticsearchRestRequestText(sql);
  return connection.db_type !== "redis" && connection.db_type !== "mongodb" && connection.db_type !== "victoriametrics";
}

export function requiresDatabaseSelection(tab: QueryTab, connection: ConnectionConfig | undefined, _sql = ""): boolean {
  if (tab.mode !== "query") return false;
  if (!connection) return false;
  const databaseType = effectiveDatabaseTypeForConnection(connection) ?? connection.db_type;
  if (tab.database) return false;
  if (tab.database === "" && usesTreeSchemaMode(databaseType)) return false;
  if (isSingleDatabase(databaseType)) return false;
  // MySQL-compatible servers decide per statement whether a default database is required.
  // Keep interactive execution connection-scoped instead of rejecting valid qualified or constant queries.
  if (supportsConnectionLevelSqlExecution(connection)) return false;
  return !supportsConnectionScopedQueryExecution(databaseType);
}