import { z } from 'zod';
import { db } from '../db/client.js';
import { chatRuntimeService } from './chat-runtime-service.js';
import { parseChatMessageParts, stringifyChatMessageParts, type ChatMessagePart } from './chat-message-parts.js';
import { NOTIFICATION_TOKEN_TABLE, WEB_PUSH_SUBSCRIPTION_TABLE } from './notification-service.js';
import { cleanupNotificationMessagesForStaleTargetClients } from './notification-message-service.js';

export const CHAT_CONVERSATION_TABLE = 'chat_conversations';
export const CHAT_CONVERSATION_MESSAGE_TABLE = 'chat_conversation_messages';
export const CHAT_CONVERSATION_CLIENT_TABLE = 'chat_conversation_clients';
export const CHAT_CONVERSATION_REQUEST_TABLE = 'chat_conversation_requests';
export const CHAT_CONVERSATION_ACTIVITY_TABLE = 'chat_conversation_request_activities';
export const CHAT_CONVERSATION_SOURCE_CHANGE_TABLE = 'chat_conversation_source_changes';
export const CHAT_CONVERSATION_REQUEST_REQUIRED_COLUMN_NAMES = [
  'session_id',
  'request_id',
  'requester_client_id',
  'chat_type_id',
  'chat_type_label',
  'request_origin',
  'parent_request_id',
  'status',
  'status_message',
  'user_message_id',
  'user_text',
  'response_message_id',
  'response_text',
  'usage_snapshot',
  'total_tokens',
  'manual_prompt_completed_at',
  'manual_verification_completed_at',
  'answered_at',
  'terminal_at',
  'created_at',
  'updated_at',
] as const;
export const MANAGED_CHAT_SHARE_SESSION_PREFIX = 'chat-share-room-';
const CHAT_ACTIVITY_MESSAGE_PREFIX = '[[activity-log]]';
export const CHAT_CONTEXT_DESCRIPTION_MAX_LENGTH = 10000;
const STALE_CHAT_REQUEST_TIMEOUT_MS = 2 * 60 * 1000;
const CURRENT_SOURCE_PREFIXES = ['src/', 'docs/', 'public/', 'scripts/', 'etc/'] as const;

const conversationPayloadSchema = z.object({
  sessionId: z.string().trim().min(1).max(120),
  clientId: z.string().trim().max(120).nullable().optional(),
  title: z.string().trim().max(200).nullable().optional(),
  draftText: z.string().max(200000).nullable().optional(),
  requestBadgeLabel: z.string().trim().max(120).nullable().optional(),
  codexModel: z.string().trim().max(120).nullable().optional(),
  chatTypeId: z.string().trim().max(120).nullable().optional(),
  lastChatTypeId: z.string().trim().max(120).nullable().optional(),
  generalSectionName: z.string().trim().max(120).nullable().optional(),
  contextLabel: z.string().trim().max(200).nullable().optional(),
  contextDescription: z.string().trim().max(CHAT_CONTEXT_DESCRIPTION_MAX_LENGTH).nullable().optional(),
  notifyOffline: z.boolean().optional(),
});

const conversationMessagePayloadSchema = z.object({
  sessionId: z.string().trim().min(1).max(120),
  messageId: z.number().int().positive(),
  author: z.enum(['codex', 'system', 'user']),
  text: z.string().max(200000),
  timestamp: z.string().trim().max(40),
  clientRequestId: z.string().trim().max(120).nullable().optional(),
  parts: z.array(z.custom<ChatMessagePart>()).optional(),
});

export type ChatConversationItem = {
  sessionId: string;
  clientId: string | null;
  draftText: string;
  title: string;
  requestBadgeLabel: string | null;
  codexModel: string | null;
  chatTypeId: string | null;
  lastChatTypeId: string | null;
  generalSectionName: string | null;
  contextLabel: string | null;
  contextDescription: string | null;
  roomScope: Record<string, unknown> | null;
  notifyOffline: boolean;
  hasUnreadResponse: boolean;
  hasPendingAttention: boolean;
  currentRequestId: string | null;
  currentJobStatus: 'queued' | 'started' | 'completed' | 'failed' | null;
  currentJobMessage: string | null;
  currentQueueSize: number;
  currentStatusUpdatedAt: string | null;
  isPendingWork: boolean;
  pendingWorkReason: 'prompt' | 'analysis' | 'design' | null;
  lastRequestPreview: string;
  lastMessagePreview: string;
  lastResponsePreview: string;
  createdAt: string;
  updatedAt: string;
  lastMessageAt: string | null;
};

export type StoredChatMessage = {
  id: number;
  author: 'codex' | 'system' | 'user';
  text: string;
  timestamp: string;
  clientRequestId?: string | null;
  parts?: ChatMessagePart[];
};

export type ChatConversationRequestStatus =
  | 'accepted'
  | 'queued'
  | 'started'
  | 'completed'
  | 'failed'
  | 'cancelled'
  | 'removed';

export type ChatConversationRequestUsageSnapshot = {
  tokenTotals: {
    total: number;
    input: number;
    output: number;
    cached: number;
    reasoning: number;
  };
  totalTokens: number;
};

export type ChatConversationRequestItem = {
  sessionId: string;
  requestId: string;
  requesterClientId: string | null;
  chatTypeId?: string | null;
  chatTypeLabel?: string;
  requestOrigin: 'composer' | 'prompt' | null;
  sharedResourceTokenId: string | null;
  parentRequestId: string | null;
  status: ChatConversationRequestStatus;
  statusMessage: string | null;
  userMessageId: number | null;
  userText: string;
  responseMessageId: number | null;
  responseText: string;
  usageSnapshot: ChatConversationRequestUsageSnapshot | null;
  totalTokens: number | null;
  hasResponse: boolean;
  canDelete: boolean;
  manualPromptCompletedAt?: string | null;
  manualVerificationCompletedAt?: string | null;
  createdAt: string;
  updatedAt: string;
  answeredAt: string | null;
  terminalAt: string | null;
};

export type ChatConversationActivityLogItem = {
  sessionId: string;
  requestId: string;
  lines: string[];
  updatedAt: string | null;
};

type ChatPromptStepSelectionPatch = {
  stepKey: string;
  stepTitle?: string | null;
  selectedValues: string[];
  freeText?: string | null;
  skipped?: boolean;
};

type ChatPromptSelectionPatch = {
  promptIndex: number;
  promptTitle: string;
  promptSignature: string;
  sourceMessageId?: number;
  selectedValues: string[];
  freeText?: string | null;
  stepSelections?: ChatPromptStepSelectionPatch[];
  summaryText?: string | null;
  attachments?: Array<{
    id: string;
    name: string;
    path: string;
    publicUrl: string;
    size: number;
    mimeType: string;
  }>;
};

export type ChatSourceChangeSnapshotItem = {
  id: string;
  sessionId: string;
  clientId: string | null;
  conversationTitle: string;
  chatTypeId: string | null;
  chatTypeLabel: string;
  requestId: string;
  requestTitle: string;
  questionText: string;
  answerText: string;
  status: ChatConversationRequestStatus;
  sourceChangedAt: string;
  updatedAt: string;
  featureTags: string[];
  changedFiles: string[];
  currentSourceFiles: string[];
  diffBlocks: string[];
  hasSourceChanges: boolean;
  reviewStatus: 'reviewed' | 'not-reviewed';
  sourceChangeKind: 'request' | 'verification-group';
  sourceEntryIds: string[];
  conversationDeletedAt: string | null;
};

export type RecoverableChatConversationRequestItem = {
  sessionId: string;
  clientId: string | null;
  chatTypeId: string | null;
  lastChatTypeId: string | null;
  generalSectionName: string | null;
  contextLabel: string | null;
  contextDescription: string | null;
  currentRequestId: string | null;
  currentJobStatus: ChatConversationItem['currentJobStatus'];
  requestId: string;
  requestOrigin: 'composer' | 'prompt' | null;
  sharedResourceTokenId: string | null;
  parentRequestId: string | null;
  status: ChatConversationRequestStatus;
  userText: string;
  createdAt: string;
  updatedAt: string;
  currentStatusUpdatedAt: string | null;
};

export type ChatConversationDetailPage = {
  messages: StoredChatMessage[];
  requests: ChatConversationRequestItem[];
  activityLogs: ChatConversationActivityLogItem[];
  oldestLoadedMessageId: number | null;
  hasOlderMessages: boolean;
};

type ChatConversationRequestStatusPatch = {
  requestId: string;
  status?: ChatConversationRequestStatus;
  userMessageId?: number | null;
  userText?: string | null;
  responseMessageId?: number | null;
  responseText?: string | null;
};

type ChatConversationResponseCandidate = {
  id: number;
  messageId: number;
  author: StoredChatMessage['author'];
  text: string;
  clientRequestId: string | null;
  createdAt: string | null;
};

type ChatConversationClientPreference = {
  sessionId: string;
  clientId: string;
  notifyOffline: boolean;
  lastReadResponseMessageId: number | null;
};

type ChatConversationOfflineNotificationClientRow = {
  clientId: string;
  notifyOffline: boolean;
  hasActivePushRegistration: boolean;
};

function normalizeDateTimeValue(value: unknown) {
  if (value == null) {
    return null;
  }

  if (value instanceof Date) {
    return value.toISOString();
  }

  const normalized = String(value).trim();

  if (!normalized) {
    return null;
  }

  const parsed = new Date(normalized);
  return Number.isNaN(parsed.getTime()) ? normalized : parsed.toISOString();
}

function normalizeChatConversationUsageMetric(value: unknown) {
  const numericValue = Number(value);
  return Number.isFinite(numericValue) ? Math.max(0, Math.round(numericValue)) : 0;
}

function mapChatConversationRequestUsageSnapshot(value: unknown): ChatConversationRequestUsageSnapshot | null {
  const parsedValue =
    typeof value === 'string' && value.trim()
      ? (() => {
          try {
            return JSON.parse(value);
          } catch {
            return null;
          }
        })()
      : value;

  if (!parsedValue || typeof parsedValue !== 'object') {
    return null;
  }

  const snapshot = parsedValue as Partial<ChatConversationRequestUsageSnapshot> & {
    tokenTotals?: Partial<ChatConversationRequestUsageSnapshot['tokenTotals']> | null;
  };
  const tokenTotals: Partial<ChatConversationRequestUsageSnapshot['tokenTotals']> =
    snapshot.tokenTotals && typeof snapshot.tokenTotals === 'object'
      ? snapshot.tokenTotals
      : {};

  return {
    tokenTotals: {
      total: normalizeChatConversationUsageMetric(tokenTotals.total),
      input: normalizeChatConversationUsageMetric(tokenTotals.input),
      output: normalizeChatConversationUsageMetric(tokenTotals.output),
      cached: normalizeChatConversationUsageMetric(tokenTotals.cached),
      reasoning: normalizeChatConversationUsageMetric(tokenTotals.reasoning),
    },
    totalTokens: normalizeChatConversationUsageMetric(snapshot.totalTokens),
  };
}

function parseStringArray(value: unknown) {
  if (typeof value !== 'string') {
    return [] as string[];
  }

  try {
    const parsed = JSON.parse(value) as unknown;

    if (!Array.isArray(parsed)) {
      return [] as string[];
    }

    return parsed
      .map((item) => String(item ?? '').trim())
      .filter(Boolean);
  } catch {
    return [] as string[];
  }
}

function stringifyStringArray(value: string[]) {
  return JSON.stringify(
    Array.from(
      new Set(
        value.map((item) => String(item ?? '').trim()).filter(Boolean),
      ),
    ),
  );
}

function createPreview(text: string) {
  const normalized = String(text ?? '').replace(/\s+/g, ' ').trim();
  return normalized.length > 140 ? `${normalized.slice(0, 137).trimEnd()}...` : normalized;
}

function createCompactText(value: string | null | undefined, limit = 88) {
  const normalized = String(value ?? '').replace(/\s+/g, ' ').trim();

  if (!normalized) {
    return '';
  }

  return normalized.length > limit ? `${normalized.slice(0, limit - 1)}…` : normalized;
}

function normalizeClientIdSet(clientIds: Iterable<string | null | undefined>) {
  return new Set(
    Array.from(clientIds, (item) => String(item ?? '').trim()).filter(Boolean),
  );
}

export function collectRegisteredNotificationClientIds(
  rows: Array<{
    device_id?: unknown;
    client_id?: unknown;
  }>,
) {
  return new Set(
    rows
      .flatMap((row) => [row.device_id, row.client_id])
      .map((value) => String(value ?? '').trim())
      .filter(Boolean),
  );
}

export function selectStaleOfflineNotificationClientIds(
  rows: ChatConversationOfflineNotificationClientRow[],
  options?: {
    keepClientIds?: Iterable<string | null | undefined>;
  },
) {
  const keepClientIds = normalizeClientIdSet(options?.keepClientIds ?? []);

  return rows
    .filter((row) => {
      if (!row.notifyOffline) {
        return false;
      }

      if (!row.clientId) {
        return false;
      }

      if (keepClientIds.has(row.clientId)) {
        return false;
      }

      return row.hasActivePushRegistration !== true;
    })
    .map((row) => row.clientId);
}

const SOURCE_CHANGE_VERIFICATION_PATTERN = /^\s*\[\[source-change-verification:(.+?)\]\]\s*$/iu;
const PROMPT_PART_PATTERN = /^\s*\[\[prompt:(.+?)\]\]\s*$/iu;

type SourceChangeVerificationFeature = {
  key: string;
  label: string;
  entryRefs: Array<{
    sessionId: string;
    requestId: string;
  }>;
};

type SourceChangeVerificationMetadata = {
  version: number;
  features: SourceChangeVerificationFeature[];
};

function parseJsonRecord(value: string) {
  try {
    const parsed = JSON.parse(value) as unknown;
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
      ? parsed as Record<string, unknown>
      : null;
  } catch {
    return null;
  }
}

function parseSourceChangeVerificationMetadata(text: string) {
  const lines = String(text ?? '').split('\n');

  for (const line of lines) {
    const matched = line.match(SOURCE_CHANGE_VERIFICATION_PATTERN);

    if (!matched?.[1]) {
      continue;
    }

    const record = parseJsonRecord(matched[1]);
    if (!record) {
      continue;
    }

    const features = Array.isArray(record.features)
      ? record.features.flatMap((feature) => {
          if (!feature || typeof feature !== 'object' || Array.isArray(feature)) {
            return [];
          }

          const featureRecord = feature as Record<string, unknown>;
          const key = String(featureRecord.key ?? '').trim();
          const label = String(featureRecord.label ?? '').trim();
          const entryRefs = Array.isArray(featureRecord.entryRefs)
            ? featureRecord.entryRefs.flatMap((entryRef) => {
                if (!entryRef || typeof entryRef !== 'object' || Array.isArray(entryRef)) {
                  return [];
                }

                const entryRefRecord = entryRef as Record<string, unknown>;
                const sessionId = String(entryRefRecord.sessionId ?? '').trim();
                const requestId = String(entryRefRecord.requestId ?? '').trim();

                return sessionId && requestId ? [{ sessionId, requestId }] : [];
              })
            : [];

          return key && label && entryRefs.length > 0 ? [{ key, label, entryRefs }] : [];
        })
      : [];

    if (features.length === 0) {
      continue;
    }

    return {
      version: Number(record.version ?? 1) || 1,
      features,
    } satisfies SourceChangeVerificationMetadata;
  }

  return null;
}

function parseSelectedPromptValues(text: string) {
  const selectedValues = new Set<string>();
  const lines = String(text ?? '').split('\n');

  for (const line of lines) {
    const matched = line.match(PROMPT_PART_PATTERN);

    if (!matched?.[1]) {
      continue;
    }

    const record = parseJsonRecord(matched[1]);
    if (!record) {
      continue;
    }

    (Array.isArray(record.selectedValues) ? record.selectedValues : []).forEach((value) => {
      const normalized = String(value ?? '').trim();

      if (normalized) {
        selectedValues.add(normalized);
      }
    });
  }

  return selectedValues;
}

function normalizePromptSelectionValues(values: unknown) {
  return (Array.isArray(values) ? values : [])
    .map((value) => String(value ?? '').trim())
    .filter(Boolean)
    .filter((value, index, items) => items.indexOf(value) === index);
}

export function buildChatPromptTargetSignature(part: Extract<ChatMessagePart, { type: 'prompt' }>) {
  const stepsSignature = (part.steps ?? [])
    .map((step) =>
      [
        step.key,
        step.title,
        step.description ?? '',
        step.multiple ? 'multi' : 'single',
        step.optional ? 'optional' : 'required',
        step.mode ?? '',
        step.freeTextLabel ?? '',
        step.freeTextPlaceholder ?? '',
        ...step.options.map((option) => [option.value, option.label, option.description ?? ''].join('~')),
      ].join('|'),
    )
    .join('||');
  const optionsSignature = part.options
    .map((option) => [option.value, option.label, option.description ?? ''].join('~'))
    .join('|');

  return [
    part.title,
    part.description ?? '',
    part.mode ?? '',
    part.multiple ? 'multi' : 'single',
    part.submitLabel ?? '',
    part.freeTextLabel ?? '',
    part.freeTextPlaceholder ?? '',
    part.responseTemplate ?? '',
    part.currentStepKey ?? '',
    optionsSignature,
    stepsSignature,
  ].join('::');
}

export function applyChatPromptSelectionPatch(
  parts: ChatMessagePart[] | undefined,
  selection: ChatPromptSelectionPatch,
  resolvedAt: string,
) {
  const promptParts = (parts ?? []).flatMap((part, index) => (part.type === 'prompt' ? [{ index, part }] : []));
  const directMatch = promptParts[selection.promptIndex] ?? null;
  const matchedPrompt =
    directMatch &&
    directMatch.part.title === selection.promptTitle &&
    buildChatPromptTargetSignature(directMatch.part) === selection.promptSignature
      ? directMatch
      : promptParts.find(
          ({ part }) =>
            part.title === selection.promptTitle && buildChatPromptTargetSignature(part) === selection.promptSignature,
        ) ?? null;

  if (!matchedPrompt) {
    return null;
  }

  const nextSelectedValues = normalizePromptSelectionValues(selection.selectedValues);
  const stepSelectionMap = new Map(
    (selection.stepSelections ?? []).map((step) => [
      String(step.stepKey ?? '').trim(),
      {
        selectedValues: normalizePromptSelectionValues(step.selectedValues),
      },
    ]),
  );
  const nextParts = [...(parts ?? [])];
  const currentPart = matchedPrompt.part;
  const nextSteps = currentPart.steps?.map((step) => {
    const matchedStep = stepSelectionMap.get(step.key);
    return matchedStep
      ? {
          ...step,
          selectedValues: matchedStep.selectedValues,
        }
      : step;
  });
  const aggregatedStepSelectedValues =
    nextSteps?.flatMap((step) => normalizePromptSelectionValues(step.selectedValues ?? [])).filter(Boolean) ?? [];
  const resolvedSelectedValues = nextSelectedValues.length > 0 ? nextSelectedValues : aggregatedStepSelectedValues;
  const lastStepKey = (selection.stepSelections ?? [])
    .map((step) => String(step.stepKey ?? '').trim())
    .filter(Boolean)
    .at(-1);

  nextParts[matchedPrompt.index] = {
    ...currentPart,
    steps: nextSteps,
    currentStepKey: lastStepKey || currentPart.currentStepKey,
    selectedValues: resolvedSelectedValues,
    readOnly: true,
    resolvedBy: 'user',
    resolvedAt,
    resultText: String(selection.summaryText ?? '').trim() || String(selection.freeText ?? '').trim() || null,
    attachments: Array.isArray(selection.attachments) ? selection.attachments : [],
  };

  return nextParts;
}

function selectChatPromptSelectionMessageCandidate(
  messageRows: Record<string, unknown>[],
  selection: ChatPromptSelectionPatch,
  resolvedAt: string,
) {
  for (const messageRow of messageRows) {
    const nextParts = applyChatPromptSelectionPatch(parseChatMessageParts(messageRow.parts_json), selection, resolvedAt);

    if (!nextParts) {
      continue;
    }

    return {
      messageRow,
      nextParts,
    };
  }

  return null;
}

function normalizePromptSelectionSourceMessageId(selection: ChatPromptSelectionPatch) {
  return Number.isInteger(selection.sourceMessageId) && (selection.sourceMessageId ?? 0) > 0
    ? Math.trunc(selection.sourceMessageId as number)
    : null;
}

export function collectPromptSelectionCandidateRequestIds(
  requestRows: Array<{
    request_id?: unknown;
    parent_request_id?: unknown;
    created_at?: unknown;
  }>,
  parentRequestId: string,
) {
  const normalizedParentRequestId = parentRequestId.trim();

  if (!normalizedParentRequestId) {
    return [];
  }

  const normalizedRows = requestRows
    .map((row, index) => ({
      requestId: String(row.request_id ?? '').trim(),
      parentRequestId: String(row.parent_request_id ?? '').trim(),
      createdAt: normalizeDateTimeValue(row.created_at) ?? '',
      order: index,
    }))
    .filter((row) => row.requestId);

  const childRowsByParentRequestId = new Map<string, typeof normalizedRows>();

  normalizedRows.forEach((row) => {
    const parentId = row.parentRequestId;

    if (!parentId) {
      return;
    }

    const currentRows = childRowsByParentRequestId.get(parentId) ?? [];
    currentRows.push(row);
    childRowsByParentRequestId.set(parentId, currentRows);
  });

  const includedRequestIds = new Set<string>([normalizedParentRequestId]);
  const pendingParentRequestIds = [normalizedParentRequestId];

  while (pendingParentRequestIds.length > 0) {
    const currentParentRequestId = pendingParentRequestIds.shift() ?? '';
    const childRows = childRowsByParentRequestId.get(currentParentRequestId) ?? [];

    childRows.forEach((row) => {
      if (includedRequestIds.has(row.requestId)) {
        return;
      }

      includedRequestIds.add(row.requestId);
      pendingParentRequestIds.push(row.requestId);
    });
  }

  return normalizedRows
    .filter((row) => includedRequestIds.has(row.requestId))
    .sort((left, right) => {
      const createdAtDiff = right.createdAt.localeCompare(left.createdAt);

      if (createdAtDiff !== 0) {
        return createdAtDiff;
      }

      return right.order - left.order;
    })
    .map((row) => row.requestId);
}

function sanitizeSourceChangeGroupKey(value: string, fallback: string) {
  const normalized = String(value ?? '')
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .slice(0, 24);

  return normalized || fallback;
}

function buildVerificationGroupRequestId(requestId: string, featureKey: string, index: number) {
  const normalizedRequestId = String(requestId ?? '').trim() || 'verification';
  const safeKey = sanitizeSourceChangeGroupKey(featureKey, `group-${index + 1}`);
  const suffix = `::vf:${index + 1}:${safeKey}`;
  const baseLimit = Math.max(1, 120 - suffix.length);
  return `${normalizedRequestId.slice(0, baseLimit)}${suffix}`;
}

function createRequestTitle(userText: string, fallback: string) {
  const compact = createCompactText(userText, 72);
  return compact || fallback;
}

export function hasMeaningfulChatSourceArtifacts(snapshot: {
  changedFiles?: string[] | null;
  currentSourceFiles?: string[] | null;
  diffBlocks?: string[] | null;
}) {
  return [snapshot.changedFiles, snapshot.currentSourceFiles, snapshot.diffBlocks].some((items) =>
    Array.isArray(items) && items.some((item) => typeof item === 'string' && item.trim().length > 0),
  );
}

function extractDiffBlocks(text: string) {
  return Array.from(text.matchAll(/```diff[^\n]*\n([\s\S]*?)```/g))
    .map((match) => match[1]?.trim() ?? '')
    .filter(Boolean);
}

function normalizeWorkspaceFilePath(value: string) {
  const normalized = String(value ?? '')
    .trim()
    .replace(/\\/g, '/')
    .replace(/^file:\/\//, '')
    .replace(/[)>.,]+$/, '')
    .replace(/:\d+(?::\d+)?$/, '');

  if (!normalized) {
    return '';
  }

  const resourceMarker = '/resource/';
  const resourceIndex = normalized.lastIndexOf(resourceMarker);

  if (resourceIndex >= 0) {
    const innerPath = normalized.slice(resourceIndex + resourceMarker.length).replace(/^\/+/, '');
    return innerPath;
  }

  const apiResourceMarker = '/api/chat/resources/';
  const apiResourceIndex = normalized.lastIndexOf(apiResourceMarker);

  if (apiResourceIndex >= 0) {
    return normalized.slice(apiResourceIndex + apiResourceMarker.length).replace(/^\/+/, '');
  }

  const legacyWorkspaceMarker = '/workspace/main-project/';
  const legacyWorkspaceIndex = normalized.lastIndexOf(legacyWorkspaceMarker);

  if (legacyWorkspaceIndex >= 0) {
    return normalized.slice(legacyWorkspaceIndex + legacyWorkspaceMarker.length);
  }

  for (const prefix of CURRENT_SOURCE_PREFIXES) {
    const marker = `/${prefix}`;
    const markerIndex = normalized.lastIndexOf(marker);

    if (markerIndex >= 0) {
      return normalized.slice(markerIndex + 1);
    }

    if (normalized.startsWith(prefix)) {
      return normalized;
    }
  }

  return normalized.replace(/^\/+/, '').replace(/^\.\//, '');
}

function isCurrentSourcePath(path: string) {
  return CURRENT_SOURCE_PREFIXES.some((prefix) => path.startsWith(prefix));
}

function extractChangedFiles(text: string) {
  const matches = Array.from(
    text.matchAll(/^(?:diff --git a\/[^\s]+ b\/([^\s]+)|\+\+\+ b\/([^\s]+)|--- a\/([^\s]+))$/gm),
  )
    .flatMap((match) => [match[1], match[2], match[3]])
    .filter((value): value is string => Boolean(value));

  return Array.from(
    new Set(
      matches
        .map((item) => normalizeWorkspaceFilePath(item))
        .filter(Boolean),
    ),
  ).slice(0, 60);
}

function extractCurrentSourceFiles(text: string) {
  const textWithoutChatResourcePaths = text
    .replace(/\/api\/chat\/resources\/[^\s)`]+/g, ' ')
    .replace(/\/?(?:public\/)?\.codex_chat\/[^\s)`]+\/resource\/[^\s)`]+/g, ' ');

  const diffPathMatches = Array.from(
    text.matchAll(/^(?:diff --git a\/[^\s]+ b\/([^\s]+)|\+\+\+ b\/([^\s]+)|--- a\/([^\s]+))$/gm),
  )
    .flatMap((match) => [match[1], match[2], match[3]])
    .filter((value): value is string => Boolean(value))
    .map((item) => normalizeWorkspaceFilePath(item))
    .filter((path) => path && isCurrentSourcePath(path));

  const workspacePathMatches = [
    ...(text.match(/\[[^\]]*]\((\/[^)\s]+)\)/g) ?? []).map((item) => item.replace(/^[^\(]*\(/, '').replace(/\)$/, '')),
    ...(text.match(/\/(?:[^/\s)]+\/)*(?:src|docs|etc|public|scripts)\/[^\s)`]+/g) ?? []),
  ]
    .map((item) => normalizeWorkspaceFilePath(item))
    .filter((path) => path && isCurrentSourcePath(path));

  const directRelativeMatches = (textWithoutChatResourcePaths.match(/\b(?:src|docs|etc|public|scripts)\/[A-Za-z0-9._\-\/]+(?:\.[A-Za-z0-9]+)?\b/g) ?? [])
    .map((item) => normalizeWorkspaceFilePath(item))
    .filter((path) => path && isCurrentSourcePath(path));

  return Array.from(new Set([...diffPathMatches, ...workspacePathMatches, ...directRelativeMatches])).slice(0, 60);
}

function deriveFeatureTags(files: string[]) {
  const tags = new Set<string>();

  files.forEach((file) => {
    const segments = file.split('/').filter(Boolean);

    if (segments[0] === 'src' && segments[1] === 'features' && segments[2]) {
      tags.add(`feature:${segments[2]}`);
      return;
    }

    if (segments[0] === 'src' && segments[1] === 'components' && segments[2]) {
      tags.add(`component:${segments[2]}`);
      return;
    }

    if (segments[0] === 'src' && segments[1] === 'widgets' && segments[2]) {
      tags.add(`widget:${segments[2]}`);
      return;
    }

    if (segments[0] === 'docs' && segments[1]) {
      tags.add(`docs:${segments[1]}`);
      return;
    }

    if (segments[0]) {
      tags.add(segments[0]);
    }
  });

  return Array.from(tags);
}

const SOURCE_CHANGE_MENU_RULES: Array<{
  title: string;
  patterns: RegExp[];
}> = [
  {
    title: 'Preview App / 모바일 앱 열기',
    patterns: [
      /^src\/app\/main\/PreviewAppOverlay\.(?:ts|tsx)$/u,
      /^src\/app\/main\/PreviewAppWindow\.(?:ts|tsx)$/u,
      /^src\/app\/main\/previewRuntime\.(?:ts|tsx|js)$/u,
      /^src\/app\/main\/appUpdate\.(?:ts|tsx|js)$/u,
    ],
  },
  {
    title: '리소스 관리 / 리소스 관리',
    patterns: [
      /^src\/app\/main\/ResourceManagementPage\.(?:ts|tsx)$/u,
      /^src\/app\/main\/resourceManagerApi\.(?:ts|tsx)$/u,
      /^etc\/servers\/work-server\/src\/routes\/resource-manager\.(?:ts|js)$/u,
      /^etc\/servers\/work-server\/src\/services\/resource-manager-service\.(?:ts|js)$/u,
    ],
  },
  {
    title: 'Codex Live / 변경 이력',
    patterns: [/^src\/app\/main\/ChatSourceChangesPage\.(?:ts|tsx)$/u],
  },
  {
    title: '앱로그 / 에러 로그',
    patterns: [
      /^src\/app\/main\/errorLogApi\.(?:ts|js)$/u,
      /^src\/app\/main\/mainChatPanel\/ErrorLogViewer\.(?:ts|tsx|js)$/u,
      /^src\/app\/main\/mainChatPanel\/useErrorLogs\.(?:ts|js)$/u,
    ],
  },
  {
    title: '채팅 관리 / 유형 권한 관리',
    patterns: [/^src\/app\/main\/chatTypeAccess\.(?:ts|tsx)$/u],
  },
  {
    title: '채팅 관리 / 공통 문맥 관리',
    patterns: [/^src\/app\/main\/chatContextSettingsAccess\.(?:ts|tsx)$/u],
  },
  {
    title: '작업 / release 검수',
    patterns: [/^src\/features\/planBoard\/ReleaseReviewPage\.(?:ts|tsx)$/u],
  },
  {
    title: '작업 / 작업 요청',
    patterns: [
      /^src\/features\/planBoard\/PlanBoardPage\.(?:ts|tsx)$/u,
      /^etc\/servers\/work-server\/src\/routes\/plan\.(?:ts|js)$/u,
      /^etc\/servers\/work-server\/src\/services\/plan-service\.(?:ts|js)$/u,
      /^etc\/servers\/work-server\/src\/services\/plan-schedule-service\.(?:ts|js)$/u,
    ],
  },
  {
    title: 'Servers / Command',
    patterns: [
      /^src\/features\/serverCommand\/.+\.(?:ts|tsx)$/u,
      /^etc\/servers\/work-server\/src\/routes\/server-command\.(?:ts|js)$/u,
      /^etc\/servers\/work-server\/src\/services\/server-command-service\.(?:ts|js)$/u,
    ],
  },
  {
    title: 'Play / Layout Editor',
    patterns: [
      /^src\/features\/layout\/.+\.(?:ts|tsx)$/u,
      /^src\/views\/play\/LayoutPlaygroundView\.(?:ts|tsx)$/u,
    ],
  },
  {
    title: 'APIs / Components',
    patterns: [/^src\/components\/.+/u],
  },
  {
    title: 'APIs / Widgets',
    patterns: [/^src\/widgets\/.+/u],
  },
  {
    title: 'Codex Live / Codex Live',
    patterns: [
      /^src\/app\/main\/MainChatPanel\.(?:ts|tsx)$/u,
      /^src\/app\/main\/mainChatPanel\/.+/u,
      /^etc\/servers\/work-server\/src\/routes\/chat\.(?:ts|js)$/u,
      /^etc\/servers\/work-server\/src\/services\/chat-(?:message-parts|room-service|service)\.(?:ts|js)$/u,
    ],
  },
];

function resolveDocsScreenTitle(filePath: string) {
  const matched = filePath.match(/^docs\/([^/]+)/u);

  if (!matched?.[1]) {
    return null;
  }

  if (matched[1] === 'project') {
    return 'Docs / 프로젝트 구조';
  }

  return `Docs / ${matched[1]}`;
}

export function inferSourceChangeScreenTitle(
  files: string[],
  fallbackTitle?: string | null,
) {
  const normalizedFiles = Array.from(
    new Set(
      files
        .map((file) => normalizeWorkspaceFilePath(file))
        .map((file) => file.trim())
        .filter(Boolean),
    ),
  );

  for (const rule of SOURCE_CHANGE_MENU_RULES) {
    if (normalizedFiles.some((file) => rule.patterns.some((pattern) => pattern.test(file)))) {
      return rule.title;
    }
  }

  for (const file of normalizedFiles) {
    const docsTitle = resolveDocsScreenTitle(file);

    if (docsTitle) {
      return docsTitle;
    }
  }

  const normalizedFallback = String(fallbackTitle ?? '').trim();
  return normalizedFallback || '새 대화';
}

const PENDING_WORK_ANALYSIS_PATTERNS = [
  /분석/u,
  /검토/u,
  /조사/u,
  /원인/u,
  /파악/u,
  /\banalysis\b/i,
  /\binvestigat(?:e|ion)\b/i,
] as const;

const PENDING_WORK_DESIGN_PATTERNS = [
  /설계/u,
  /프롬프트/u,
  /시안/u,
  /구조/u,
  /방향/u,
  /기획/u,
  /플로우/u,
  /아키텍처/u,
  /\bdesign\b/i,
  /\barchitecture\b/i,
] as const;

const PENDING_WORK_IMPLEMENTATION_PATTERNS = [
  /구현했/u,
  /수정했/u,
  /반영했/u,
  /적용했/u,
  /완료했/u,
  /마무리했/u,
  /배포했/u,
  /검증했/u,
  /빌드.*통과/u,
  /테스트.*통과/u,
  /캡처/u,
  /preview/iu,
  /변경 파일/u,
  /diff/u,
  /\bimplement(?:ed|ation)?\b/i,
  /\bfix(?:ed)?\b/i,
  /\bverified?\b/i,
  /\btested?\b/i,
] as const;

const PENDING_WORK_RESPONSE_HOLD_PATTERNS = [
  /원하시면/u,
  /진행해드릴/u,
  /이어(?:서|가)/u,
  /다음 단계/u,
  /선택/u,
  /옵션/u,
  /후속/u,
  /\bif you want\b/i,
  /\bnext step\b/i,
] as const;

function normalizePendingWorkText(text: string | null | undefined) {
  return String(text ?? '').replace(/\s+/g, ' ').trim();
}

function hasPendingWorkPattern(text: string, patterns: readonly RegExp[]) {
  return patterns.some((pattern) => pattern.test(text));
}

function resolvePendingWorkReasonFromText(text: string) {
  if (!text) {
    return null;
  }

  if (hasPendingWorkPattern(text, PENDING_WORK_DESIGN_PATTERNS)) {
    return 'design' as const;
  }

  if (hasPendingWorkPattern(text, PENDING_WORK_ANALYSIS_PATTERNS)) {
    return 'analysis' as const;
  }

  return null;
}

function hasOpenPromptParts(parts: ChatMessagePart[] | undefined) {
  return (parts ?? []).some((part) => {
    if (part.type !== 'prompt' || part.readOnly === true) {
      return false;
    }

    if ((part.selectedValues?.length ?? 0) > 0) {
      return false;
    }

    if ((part.resultText?.trim() ?? '').length > 0) {
      return false;
    }

    if ((part.resolvedAt?.trim() ?? '').length > 0 || part.resolvedBy != null) {
      return false;
    }

    return true;
  });
}

function resolvePendingWorkState(args: {
  requestText?: string | null;
  responseText?: string | null;
  latestCodexParts?: ChatMessagePart[] | undefined;
}) {
  if (hasOpenPromptParts(args.latestCodexParts)) {
    return {
      isPendingWork: true,
      pendingWorkReason: 'prompt' as const,
    };
  }

  const requestText = normalizePendingWorkText(args.requestText);
  const responseText = normalizePendingWorkText(args.responseText);
  const requestReason = resolvePendingWorkReasonFromText(requestText);

  if (!requestReason) {
    return {
      isPendingWork: false,
      pendingWorkReason: null,
    };
  }

  if (hasPendingWorkPattern(responseText, PENDING_WORK_IMPLEMENTATION_PATTERNS)) {
    return {
      isPendingWork: false,
      pendingWorkReason: null,
    };
  }

  if (!responseText) {
    return {
      isPendingWork: true,
      pendingWorkReason: requestReason,
    };
  }

  const responseReason = resolvePendingWorkReasonFromText(responseText);

  if (responseReason || hasPendingWorkPattern(responseText, PENDING_WORK_RESPONSE_HOLD_PATTERNS)) {
    return {
      isPendingWork: true,
      pendingWorkReason: responseReason ?? requestReason,
    };
  }

  return {
    isPendingWork: false,
    pendingWorkReason: null,
  };
}

function isPendingAttentionPromptPart(
  part: NonNullable<ChatMessagePart>,
): part is Extract<ChatMessagePart, { type: 'prompt' }> {
  return (
    part.type === 'prompt'
    && part.readOnly !== true
    && part.resolvedBy == null
    && !(part.resolvedAt?.trim() ?? '')
  );
}

function hasPendingAttentionPromptMessageParts(parts: ChatMessagePart[] | undefined) {
  return (parts ?? []).some((part) => isPendingAttentionPromptPart(part));
}

function hasPendingAttentionVerificationTarget(text: string | null | undefined) {
  const normalized = String(text ?? '').trim();

  if (!normalized) {
    return false;
  }

  if (normalized.length > 720) {
    return true;
  }

  return /```diff[\s\S]*?```|\[\[preview:|\[\[link-card:|\[\[prompt:/i.test(normalized);
}

function isConversationAttentionPending(options: {
  request: ChatConversationRequestItem;
  relatedMessages: StoredChatMessage[];
  childRequestCountByParentId: Map<string, number>;
}) {
  const { request, relatedMessages, childRequestCountByParentId } = options;

  if (request.status === 'accepted' || request.status === 'queued' || request.status === 'started') {
    return true;
  }

  if (!request.manualPromptCompletedAt) {
    const hasOpenPrompt = relatedMessages.some(
      (message) =>
        (message.author === 'codex' || message.author === 'system')
        && hasPendingAttentionPromptMessageParts(message.parts),
    );

    if (hasOpenPrompt) {
      return true;
    }
  }

  if ((childRequestCountByParentId.get(request.requestId.trim()) ?? 0) > 0) {
    return false;
  }

  const hasVerificationTarget = relatedMessages.some(
    (message) =>
      (message.author === 'codex' || message.author === 'system')
      && hasPendingAttentionVerificationTarget(message.text),
  );

  if (!hasVerificationTarget) {
    return false;
  }

  return !request.manualVerificationCompletedAt;
}

async function getConversationPendingAttentionMap(sessionIds: string[]) {
  const normalizedSessionIds = Array.from(new Set(sessionIds.map((item) => item.trim()).filter(Boolean)));

  if (normalizedSessionIds.length === 0) {
    return new Map<string, boolean>();
  }

  const [requestRows, messageRows] = await Promise.all([
    db(CHAT_CONVERSATION_REQUEST_TABLE)
      .select('*')
      .whereIn('session_id', normalizedSessionIds)
      .orderBy('created_at', 'asc')
      .orderBy('request_id', 'asc'),
    db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .select('session_id', 'message_id', 'author', 'text', 'parts_json', 'client_request_id', 'display_timestamp')
      .whereIn('session_id', normalizedSessionIds)
      .andWhere((builder) => {
        applyVisibleConversationMessageCondition(builder);
      })
      .orderBy('created_at', 'asc')
      .orderBy('message_id', 'asc')
      .orderBy('id', 'asc'),
  ]);

  const requestRowsBySession = new Map<string, ChatConversationRequestItem[]>();
  requestRows.forEach((row) => {
    const request = mapRequestRow(row);
    const current = requestRowsBySession.get(request.sessionId) ?? [];
    current.push(request);
    requestRowsBySession.set(request.sessionId, current);
  });

  const messageRowsBySession = new Map<string, StoredChatMessage[]>();
  messageRows.forEach((row) => {
    const message = mapMessageRow(row);
    const sessionId = String(row.session_id ?? '').trim();

    if (!sessionId) {
      return;
    }

    const current = messageRowsBySession.get(sessionId) ?? [];
    current.push(message);
    messageRowsBySession.set(sessionId, current);
  });

  return normalizedSessionIds.reduce<Map<string, boolean>>((result, sessionId) => {
    const requests = requestRowsBySession.get(sessionId) ?? [];
    const messages = messageRowsBySession.get(sessionId) ?? [];
    const childRequestCountByParentId = requests.reduce<Map<string, number>>((map, request) => {
      const parentRequestId = request.parentRequestId?.trim() || '';

      if (parentRequestId) {
        map.set(parentRequestId, (map.get(parentRequestId) ?? 0) + 1);
      }

      return map;
    }, new Map());
    const requestMessagesById = messages.reduce<Map<string, StoredChatMessage[]>>((map, message) => {
      const requestId = message.clientRequestId?.trim() || '';

      if (!requestId) {
        return map;
      }

      const current = map.get(requestId) ?? [];
      current.push(message);
      map.set(requestId, current);
      return map;
    }, new Map());

    result.set(
      sessionId,
      requests.some((request) =>
        isConversationAttentionPending({
          request,
          relatedMessages: requestMessagesById.get(request.requestId.trim()) ?? [],
          childRequestCountByParentId,
        }),
      ),
    );

    return result;
  }, new Map());
}

const CONTEXT_DEPENDENT_REQUEST_PATTERNS = [
  /이전\s*(채팅|대화|문맥)/u,
  /이전\s*요청/u,
  /마지막\s*요청/u,
  /요청내역/u,
  /두\s*단어/u,
  /최근\s*작업\s*(뱃지|badge|라벨)/iu,
  /(?:이어서|이어진|이어가|계속|추가로|연달아|후속|마저)/u,
  /^(?:그리고|그럼|그러면|또|또한|근데|그런데|여기도|여기서도|이것도|그것도|저것도|이거|그거|저거)/u,
  /\b(?:also|continue|continued|follow[\s-]?up|same|again)\b/i,
] as const;

function normalizeRequestPreviewText(text: string) {
  return String(text ?? '').replace(/\s+/g, ' ').trim();
}

function isContextDependentRequestPreview(text: string) {
  const normalized = normalizeRequestPreviewText(text);

  if (!normalized) {
    return false;
  }

  if (CONTEXT_DEPENDENT_REQUEST_PATTERNS.some((pattern) => pattern.test(normalized))) {
    return true;
  }

  if (normalized.length <= 16) {
    return true;
  }

  return false;
}

function buildLatestRequestPreview(
  requests: Array<{ text: string; createdAt: string | null }>,
): { text: string; createdAt: string | null } | null {
  const normalizedRequests = requests
    .map((request) => ({
      text: normalizeRequestPreviewText(request.text),
      createdAt: request.createdAt,
    }))
    .filter((request) => Boolean(request.text));

  const latestRequest = normalizedRequests[0];

  if (!latestRequest) {
    return null;
  }

  if (!isContextDependentRequestPreview(latestRequest.text)) {
    return latestRequest;
  }

  const previousRequest =
    normalizedRequests.slice(1).find((request) => !isContextDependentRequestPreview(request.text)) ??
    normalizedRequests[1] ??
    null;

  if (!previousRequest) {
    return latestRequest;
  }

  return {
    text: `${previousRequest.text} ${latestRequest.text}`.trim(),
    createdAt: latestRequest.createdAt,
  };
}

function isPreviewableConversationMessage(row: { author?: unknown; text?: unknown }) {
  const author = String(row.author ?? '');
  const text = String(row.text ?? '').trim();

  if (!text) {
    return false;
  }

  if (author === 'system' && text.startsWith(`${CHAT_ACTIVITY_MESSAGE_PREFIX}\n`)) {
    return false;
  }

  return author === 'user' || author === 'codex';
}

const CHAT_CONVERSATION_LIST_CONTEXT_DESCRIPTION_MAX_LENGTH = 240;

function deriveIsolatedChatRoomScopeFromContextDescription(value: string | null | undefined) {
  const normalized = String(value ?? '').trim();

  if (!normalized.includes('## 격리 채팅방 범위')) {
    return null;
  }

  const lines = normalized.split('\n').map((line) => line.trim());
  const sectionStartIndex = lines.findIndex((line) => line === '## 격리 채팅방 범위');

  if (sectionStartIndex < 0) {
    return null;
  }

  const values = new Map<string, string>();

  for (const line of lines.slice(sectionStartIndex + 1)) {
    if (!line.startsWith('- ')) {
      if (line.startsWith('## ')) {
        break;
      }

      continue;
    }

    const separatorIndex = line.indexOf(':');

    if (separatorIndex <= 2) {
      continue;
    }

    const key = line.slice(2, separatorIndex).trim();
    const rawValue = line.slice(separatorIndex + 1).trim();
    values.set(key, rawValue === '없음' ? '' : rawValue);
  }

  const menuTitle = values.get('현재 활성 메뉴')?.trim() ?? '';
  const featureTitle = values.get('현재 기능')?.trim() ?? '';
  const pageUrl = values.get('pageUrl')?.trim() ?? '';

  if (!menuTitle && !featureTitle && !pageUrl) {
    return null;
  }

  return {
    topMenu: values.get('topMenu')?.trim() || 'unknown',
    menuTitle: menuTitle || '현재 메뉴',
    featureTitle: featureTitle || menuTitle || '현재 기능',
    focusedComponentId: values.get('focusedComponentId')?.trim() || null,
    pageUrl,
    selectionSummary: values.get('현재 선택')?.trim() || null,
    selectionIds: (values.get('선택 ID') ?? '')
      .split(',')
      .map((item) => item.trim())
      .filter(Boolean),
    errorSummary: null,
    sourceAppId: null,
    launchedAt: '',
  } satisfies Record<string, unknown>;
}

function summarizeConversationListContextDescription(value: string | null | undefined) {
  const normalized = String(value ?? '').replace(/\s+/g, ' ').trim();

  if (!normalized) {
    return null;
  }

  if (normalized.length <= CHAT_CONVERSATION_LIST_CONTEXT_DESCRIPTION_MAX_LENGTH) {
    return normalized;
  }

  return `${normalized.slice(0, CHAT_CONVERSATION_LIST_CONTEXT_DESCRIPTION_MAX_LENGTH - 3).trimEnd()}...`;
}

function mapConversationRow(row: Record<string, unknown>): ChatConversationItem {
  const contextDescription = row.context_description == null ? null : String(row.context_description);

  return {
    sessionId: String(row.session_id ?? ''),
    clientId: row.client_id == null ? null : String(row.client_id),
    draftText: row.draft_text == null ? '' : String(row.draft_text),
    title: String(row.title ?? '새 대화'),
    requestBadgeLabel: row.request_badge_label == null ? null : String(row.request_badge_label),
    codexModel: row.codex_model == null ? null : String(row.codex_model),
    chatTypeId: row.chat_type_id == null ? null : String(row.chat_type_id),
    lastChatTypeId: row.last_chat_type_id == null ? null : String(row.last_chat_type_id),
    generalSectionName: row.general_section_name == null ? null : String(row.general_section_name),
    contextLabel: row.context_label == null ? null : String(row.context_label),
    contextDescription,
    roomScope: deriveIsolatedChatRoomScopeFromContextDescription(contextDescription),
    notifyOffline: Boolean(row.notify_offline),
    hasUnreadResponse: Boolean(row.has_unread_response),
    hasPendingAttention: false,
    currentRequestId: row.current_request_id == null ? null : String(row.current_request_id),
    currentJobStatus: row.current_job_status == null ? null : String(row.current_job_status) as ChatConversationItem['currentJobStatus'],
    currentJobMessage: row.current_job_message == null ? null : String(row.current_job_message),
    currentQueueSize: Number(row.current_queue_size ?? 0),
    currentStatusUpdatedAt: normalizeDateTimeValue(row.current_status_updated_at),
    isPendingWork: false,
    pendingWorkReason: null,
    lastRequestPreview: '',
    lastMessagePreview: String(row.last_message_preview ?? ''),
    lastResponsePreview: '',
    createdAt: normalizeDateTimeValue(row.created_at) ?? '',
    updatedAt: normalizeDateTimeValue(row.updated_at) ?? '',
    lastMessageAt: normalizeDateTimeValue(row.last_message_at),
  };
}

function mapMessageRow(row: Record<string, unknown>): StoredChatMessage {
  return {
    id: Number(row.message_id ?? row.id ?? 0),
    author: String(row.author ?? 'codex') as StoredChatMessage['author'],
    text: String(row.text ?? ''),
    timestamp: String(row.display_timestamp ?? ''),
    clientRequestId: row.client_request_id == null ? null : String(row.client_request_id),
    parts: parseChatMessageParts(row.parts_json),
  };
}

export function isVisibleConversationMessage(message: StoredChatMessage) {
  if (message.author !== 'system') {
    return true;
  }

  return message.text.startsWith(`${CHAT_ACTIVITY_MESSAGE_PREFIX}\n`);
}

function applyVisibleConversationMessageCondition(builder: any) {
  builder.whereNot('author', 'system').orWhere((nestedBuilder: any) => {
    nestedBuilder.where('author', '=', 'system').andWhere('text', 'like', `${CHAT_ACTIVITY_MESSAGE_PREFIX}\n%`);
  });
}

function mapClientPreferenceRow(row: Record<string, unknown>): ChatConversationClientPreference {
  return {
    sessionId: String(row.session_id ?? ''),
    clientId: String(row.client_id ?? ''),
    notifyOffline: Boolean(row.notify_offline),
    lastReadResponseMessageId:
      row.last_read_response_message_id == null ? null : Number(row.last_read_response_message_id),
  };
}

function mapRequestRow(row: Record<string, unknown>): ChatConversationRequestItem {
  const status = String(row.status ?? 'accepted') as ChatConversationRequestStatus;
  const hasResponse = row.response_message_id != null || String(row.response_text ?? '').trim().length > 0;
  const canDelete = !hasResponse && !['queued', 'started', 'completed'].includes(status);
  const requestOrigin = String(row.request_origin ?? '').trim();
  const parentRequestId = String(row.parent_request_id ?? '').trim();

  return {
    sessionId: String(row.session_id ?? ''),
    requestId: String(row.request_id ?? ''),
    requesterClientId: row.requester_client_id == null ? null : String(row.requester_client_id),
    chatTypeId: row.chat_type_id == null ? null : String(row.chat_type_id),
    chatTypeLabel: row.chat_type_label == null ? '' : String(row.chat_type_label),
    requestOrigin: requestOrigin === 'prompt' || requestOrigin === 'composer' ? requestOrigin : null,
    sharedResourceTokenId: row.shared_resource_token_id == null ? null : String(row.shared_resource_token_id),
    parentRequestId: parentRequestId || null,
    status,
    statusMessage: row.status_message == null ? null : String(row.status_message),
    userMessageId: row.user_message_id == null ? null : Number(row.user_message_id),
    userText: String(row.user_text ?? ''),
    responseMessageId: row.response_message_id == null ? null : Number(row.response_message_id),
    responseText: String(row.response_text ?? ''),
    usageSnapshot: mapChatConversationRequestUsageSnapshot(row.usage_snapshot),
    totalTokens:
      row.total_tokens == null || row.total_tokens === ''
        ? null
        : Number.isFinite(Number(row.total_tokens))
          ? Math.max(0, Math.round(Number(row.total_tokens)))
          : null,
    hasResponse,
    canDelete,
    manualPromptCompletedAt: normalizeDateTimeValue(row.manual_prompt_completed_at),
    manualVerificationCompletedAt: normalizeDateTimeValue(row.manual_verification_completed_at),
    createdAt: normalizeDateTimeValue(row.created_at) ?? '',
    updatedAt: normalizeDateTimeValue(row.updated_at) ?? '',
    answeredAt: normalizeDateTimeValue(row.answered_at),
    terminalAt: normalizeDateTimeValue(row.terminal_at),
  };
}

function mapSourceChangeSnapshotRow(row: Record<string, unknown>): ChatSourceChangeSnapshotItem {
  const sessionId = String(row.session_id ?? '').trim();
  const requestId = String(row.request_id ?? '').trim();
  const changedFiles = parseStringArray(row.changed_files_json);
  const currentSourceFiles = parseStringArray(row.current_source_files_json);

  return {
    id: `${sessionId}:${requestId}`,
    sessionId,
    clientId: row.client_id == null ? null : String(row.client_id),
    conversationTitle: inferSourceChangeScreenTitle(
      [...changedFiles, ...currentSourceFiles],
      String(row.conversation_title ?? '새 대화'),
    ),
    chatTypeId: row.chat_type_id == null ? null : String(row.chat_type_id),
    chatTypeLabel: row.chat_type_label == null ? '' : String(row.chat_type_label),
    requestId,
    requestTitle: String(row.request_title ?? requestId),
    questionText: String(row.question_text ?? ''),
    answerText: String(row.answer_text ?? ''),
    status: String(row.status ?? 'completed') as ChatConversationRequestStatus,
    sourceChangedAt: normalizeDateTimeValue(row.source_changed_at) ?? normalizeDateTimeValue(row.answered_at) ?? '',
    updatedAt: normalizeDateTimeValue(row.updated_at) ?? '',
    featureTags: parseStringArray(row.feature_tags_json),
    changedFiles,
    currentSourceFiles,
    diffBlocks: parseStringArray(row.diff_blocks_json),
    hasSourceChanges: Boolean(row.has_source_changes),
    reviewStatus: String(row.review_status ?? 'not-reviewed') === 'reviewed' ? 'reviewed' : 'not-reviewed',
    sourceChangeKind: String(row.source_change_kind ?? 'request') === 'verification-group' ? 'verification-group' : 'request',
    sourceEntryIds: parseStringArray(row.source_entry_ids_json),
    conversationDeletedAt: normalizeDateTimeValue(row.conversation_deleted_at),
  };
}

function buildSourceChangeSnapshotPayload(args: {
  sessionId: string;
  clientId?: string | null;
  conversationTitle?: string | null;
  chatTypeId?: string | null;
  chatTypeLabel?: string | null;
  requestId: string;
  status: ChatConversationRequestStatus;
  questionText: string;
  answerText: string;
  answeredAt?: string | null;
  updatedAt?: string | null;
  reviewStatus?: 'reviewed' | 'not-reviewed';
  sourceChangeKind?: 'request' | 'verification-group';
  sourceEntryIds?: string[];
}) {
  const changedFiles = extractChangedFiles(args.answerText);
  const diffBlocks = extractDiffBlocks(args.answerText);
  const currentSourceFiles = extractCurrentSourceFiles(args.answerText);
  const sourceChangeTitle = inferSourceChangeScreenTitle(
    [...changedFiles, ...currentSourceFiles],
    args.conversationTitle,
  );
  const featureTags = deriveFeatureTags(changedFiles);
  const hasSourceChanges = hasMeaningfulChatSourceArtifacts({
    changedFiles,
    currentSourceFiles,
    diffBlocks,
  });
  const sourceChangedAt = args.answeredAt?.trim() || args.updatedAt?.trim() || new Date().toISOString();

  return {
    session_id: args.sessionId,
    client_id: normalizeClientId(args.clientId),
    request_id: args.requestId,
    conversation_title: sourceChangeTitle,
    chat_type_id: args.chatTypeId?.trim() || null,
    chat_type_label: args.chatTypeLabel?.trim() || null,
    request_title: createRequestTitle(args.questionText, args.requestId),
    question_text: args.questionText,
    answer_text: args.answerText,
    status: args.status,
    answered_at: args.answeredAt?.trim() || null,
    source_changed_at: sourceChangedAt,
    feature_tags_json: stringifyStringArray(featureTags),
    changed_files_json: stringifyStringArray(changedFiles),
    current_source_files_json: stringifyStringArray(currentSourceFiles),
    diff_blocks_json: stringifyStringArray(diffBlocks),
    has_source_changes: hasSourceChanges,
    review_status: args.reviewStatus === 'reviewed' ? 'reviewed' : 'not-reviewed',
    source_change_kind: args.sourceChangeKind === 'verification-group' ? 'verification-group' : 'request',
    source_entry_ids_json: stringifyStringArray(args.sourceEntryIds ?? []),
    conversation_deleted_at: null,
    updated_at: db.fn.now(),
  };
}

function normalizeClientId(clientId?: string | null) {
  return clientId?.trim() || null;
}

function getTimeValue(value: string | null | undefined) {
  if (!value) {
    return 0;
  }

  const timestamp = new Date(value).getTime();
  return Number.isFinite(timestamp) ? timestamp : 0;
}

function isRuntimeRequestActive(requestId?: string | null) {
  const normalizedRequestId = requestId?.trim() || null;

  if (!normalizedRequestId) {
    return false;
  }

  const detail = chatRuntimeService.getJobDetail(normalizedRequestId);
  return detail.item != null && detail.terminalStatus == null;
}

function isTerminalRequestStatus(status: ChatConversationRequestStatus | null | undefined) {
  return status === 'completed' || status === 'failed' || status === 'cancelled' || status === 'removed';
}

function isPreparingChatReplyText(text?: string | null) {
  const normalized = String(text ?? '').replace(/\s+/g, ' ').trim();
  return normalized.startsWith('응답을 준비하고 있습니다');
}

function hasStoredRequestResponse(request: {
  responseMessageId?: number | null;
  responseText?: string | null;
}) {
  const normalizedResponseText = String(request.responseText ?? '').trim();

  if (normalizedResponseText.length > 0) {
    return !isPreparingChatReplyText(normalizedResponseText);
  }

  return request.responseMessageId != null;
}

function isConversationRequestActive(
  conversation: {
    current_request_id?: unknown;
    current_job_status?: unknown;
  } | null | undefined,
  requestId?: string | null,
) {
  const normalizedRequestId = requestId?.trim() || null;

  if (!normalizedRequestId) {
    return false;
  }

  const currentRequestId = String(conversation?.current_request_id ?? '').trim() || null;
  const currentJobStatus = String(conversation?.current_job_status ?? '').trim();

  if (currentRequestId !== normalizedRequestId) {
    return false;
  }

  return currentJobStatus === 'queued' || currentJobStatus === 'started';
}

function hasConversationMetadata(
  conversation: {
    title?: unknown;
    draft_text?: unknown;
    request_badge_label?: unknown;
    chat_type_id?: unknown;
    last_chat_type_id?: unknown;
    general_section_name?: unknown;
    context_label?: unknown;
    context_description?: unknown;
    current_request_id?: unknown;
    current_job_status?: unknown;
  } | null | undefined,
) {
  return [
    conversation?.title,
    conversation?.draft_text,
    conversation?.request_badge_label,
    conversation?.chat_type_id,
    conversation?.last_chat_type_id,
    conversation?.general_section_name,
    conversation?.context_label,
    conversation?.context_description,
    conversation?.current_request_id,
    conversation?.current_job_status,
  ].some((value) => String(value ?? '').trim().length > 0);
}

export function isManagedChatShareSessionId(sessionId: string | null | undefined) {
  return String(sessionId ?? '').trim().startsWith(MANAGED_CHAT_SHARE_SESSION_PREFIX);
}

export function normalizeStaleRequestItem(
  item: ChatConversationRequestItem,
  conversation: {
    current_request_id?: unknown;
    current_job_status?: unknown;
    current_status_updated_at?: unknown;
  } | null | undefined,
) {
  const runtimeActive = isRuntimeRequestActive(item.requestId);
  const lastUpdatedAt = Math.max(
    getTimeValue(conversation?.current_status_updated_at == null ? null : String(conversation.current_status_updated_at)),
    getTimeValue(item.updatedAt),
  );
  const isDetachedStaleInProgressState =
    !runtimeActive &&
    !isConversationRequestActive(conversation, item.requestId) &&
    (item.status === 'queued' || item.status === 'started') &&
    !hasStoredRequestResponse(item) &&
    !isTerminalRequestStatus(item.status) &&
    lastUpdatedAt > 0 &&
    Date.now() - lastUpdatedAt >= STALE_CHAT_REQUEST_TIMEOUT_MS;

  if (
    shouldClearConversationJobState({
      currentRequestId: String(conversation?.current_request_id ?? ''),
      currentJobStatus:
        conversation?.current_job_status == null
          ? null
          : String(conversation.current_job_status) as ChatConversationItem['currentJobStatus'],
      currentStatusUpdatedAt:
        conversation?.current_status_updated_at == null ? null : String(conversation.current_status_updated_at),
      runtimeActive,
      request: item,
    }) || isDetachedStaleInProgressState
  ) {
    return {
      ...item,
      status: 'failed' as const,
      statusMessage: item.statusMessage ?? '중단된 오래된 요청',
      canDelete: true,
      terminalAt: item.terminalAt ?? item.updatedAt,
    };
  }

  return item;
}

export function shouldClearConversationJobState(params: {
  currentRequestId?: string | null;
  currentJobStatus?: ChatConversationItem['currentJobStatus'];
  currentStatusUpdatedAt?: string | null;
  runtimeActive?: boolean;
  nowMs?: number;
  request:
    | {
        requestId?: string | null;
        status?: ChatConversationRequestStatus | null;
        responseMessageId?: number | null;
        responseText?: string | null;
        terminalAt?: string | null;
        updatedAt?: string | null;
      }
    | null
    | undefined;
}) {
  const currentJobStatus = params.currentJobStatus ?? null;
  const requestStatus = params.request?.status ?? null;
  const hasStoredResponse = hasStoredRequestResponse(params.request ?? {});

  if (!currentJobStatus) {
    return false;
  }

  const currentRequestId = params.currentRequestId?.trim() || null;

  if (!currentRequestId) {
    return true;
  }

  const requestId = params.request?.requestId?.trim() || null;

  if (!requestId || requestId !== currentRequestId) {
    return false;
  }

  const runtimeActive = params.runtimeActive === true;
  const lastUpdatedAt = Math.max(
    getTimeValue(params.currentStatusUpdatedAt),
    getTimeValue(params.request?.updatedAt),
  );
  const nowMs = Number.isFinite(params.nowMs) ? Number(params.nowMs) : Date.now();
  const isStaleInProgressState =
    !runtimeActive &&
    (currentJobStatus === 'queued' || currentJobStatus === 'started') &&
    !hasStoredRequestResponse(params.request ?? {}) &&
    !isTerminalRequestStatus(params.request?.status ?? null) &&
    lastUpdatedAt > 0 &&
    nowMs - lastUpdatedAt >= STALE_CHAT_REQUEST_TIMEOUT_MS;

  return (
    (requestStatus != null && requestStatus !== 'completed' && isTerminalRequestStatus(requestStatus)) ||
    hasStoredResponse ||
    isStaleInProgressState
  );
}

function getRequestStatusRank(status: ChatConversationRequestStatus | null | undefined) {
  switch (status) {
    case 'accepted':
      return 0;
    case 'queued':
      return 1;
    case 'started':
      return 2;
    case 'completed':
    case 'failed':
    case 'cancelled':
    case 'removed':
      return 3;
    default:
      return -1;
  }
}

function getDefaultChatConversationRequestStatusMessage(status: ChatConversationRequestStatus) {
  switch (status) {
    case 'accepted':
      return '요청을 접수했습니다.';
    case 'queued':
      return '대기열 등록';
    case 'started':
      return '요청 처리 중';
    case 'completed':
      return '요청 처리 완료';
    case 'failed':
      return '요청 처리 실패';
    case 'cancelled':
      return '요청 실행 중단';
    case 'removed':
      return '요청 기록이 제거되었습니다.';
    default:
      return null;
  }
}

export function mergeChatConversationRequestStatus(
  currentStatus: ChatConversationRequestStatus | null | undefined,
  incomingStatus: ChatConversationRequestStatus | null | undefined,
): ChatConversationRequestStatus {
  const normalizedCurrent = currentStatus ?? null;
  const normalizedIncoming = incomingStatus ?? null;

  if (!normalizedCurrent && !normalizedIncoming) {
    return 'accepted';
  }

  if (!normalizedCurrent) {
    return normalizedIncoming ?? 'accepted';
  }

  if (!normalizedIncoming) {
    return normalizedCurrent;
  }

  if (isTerminalRequestStatus(normalizedCurrent) && !isTerminalRequestStatus(normalizedIncoming)) {
    return normalizedCurrent;
  }

  if (!isTerminalRequestStatus(normalizedCurrent) && isTerminalRequestStatus(normalizedIncoming)) {
    return normalizedIncoming;
  }

  return getRequestStatusRank(normalizedIncoming) >= getRequestStatusRank(normalizedCurrent)
    ? normalizedIncoming
    : normalizedCurrent;
}

export function buildChatConversationRequestPatchFromMessage(message: {
  id: number;
  author: StoredChatMessage['author'];
  text: string;
  clientRequestId?: string | null;
}): ChatConversationRequestStatusPatch | null {
  const normalizedRequestId = message.clientRequestId?.trim() || null;

  if (!normalizedRequestId) {
    return null;
  }

  if (message.author === 'user') {
    return {
      requestId: normalizedRequestId,
      status: 'accepted',
      userMessageId: message.id,
      userText: message.text,
    };
  }

  if (message.author === 'codex') {
    return {
      requestId: normalizedRequestId,
      status: 'started',
      responseMessageId: message.id,
      responseText: message.text,
    };
  }

  return null;
}

export function selectChatConversationResponseCandidate(
  request: {
    requestId: string;
    createdAt: string;
    responseMessageId?: number | null;
  },
  nextRequest: {
    createdAt: string;
  } | undefined,
  messages: ChatConversationResponseCandidate[],
) {
  const normalizedRequestId = request.requestId.trim();

  if (!normalizedRequestId) {
    return null;
  }

  const directMatches = messages.filter(
    (message) => message.author === 'codex' && message.clientRequestId?.trim() === normalizedRequestId,
  );

  if (directMatches.length > 0) {
    return directMatches.at(-1) ?? null;
  }

  if (request.responseMessageId != null) {
    const responseMessageMatch = messages.find(
      (message) => message.author === 'codex' && message.messageId === request.responseMessageId,
    );

    if (responseMessageMatch) {
      return responseMessageMatch;
    }
  }

  const requestCreatedAt = getTimeValue(request.createdAt);
  const nextRequestCreatedAt = getTimeValue(nextRequest?.createdAt);
  const windowMatches = messages.filter((message) => {
    if (message.author !== 'codex') {
      return false;
    }

    const linkedRequestId = message.clientRequestId?.trim() || null;

    if (linkedRequestId && linkedRequestId !== normalizedRequestId) {
      return false;
    }

    const createdAt = getTimeValue(message.createdAt);

    if (requestCreatedAt > 0 && createdAt > 0 && createdAt < requestCreatedAt) {
      return false;
    }

    if (nextRequestCreatedAt > 0 && createdAt > 0 && createdAt >= nextRequestCreatedAt) {
      return false;
    }

    return Boolean(String(message.text ?? '').trim());
  });

  return windowMatches.at(-1) ?? null;
}

async function getLatestPreviewableMessageMap(sessionIds: string[]) {
  const normalizedSessionIds = sessionIds.map((sessionId) => sessionId.trim()).filter(Boolean);

  if (normalizedSessionIds.length === 0) {
    return new Map<string, { text: string; createdAt: string | null }>();
  }

  const rows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .select('session_id', 'author', 'text', 'created_at')
    .whereIn('session_id', normalizedSessionIds)
    .whereIn('author', ['user', 'codex'])
    .orderBy('session_id', 'asc')
    .orderBy('created_at', 'desc')
    .orderBy('id', 'desc');

  const messageMap = new Map<string, { text: string; createdAt: string | null }>();

  for (const row of rows) {
    const sessionId = String(row.session_id ?? '').trim();

    if (!sessionId || messageMap.has(sessionId) || !isPreviewableConversationMessage(row)) {
      continue;
    }

    messageMap.set(sessionId, {
      text: String(row.text ?? ''),
      createdAt: normalizeDateTimeValue(row.created_at),
    });
  }

  return messageMap;
}

async function getLatestRequestPreviewMap(sessionIds: string[]) {
  const normalizedSessionIds = Array.from(new Set(sessionIds.map((sessionId) => sessionId.trim()).filter(Boolean)));

  if (normalizedSessionIds.length === 0) {
    return new Map<string, { text: string; createdAt: string | null }>();
  }

  const rows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('session_id', 'user_text', 'created_at', 'status', 'request_id')
    .whereIn('session_id', normalizedSessionIds)
    .whereNot('status', 'removed')
    .orderBy('session_id', 'asc')
    .orderBy('created_at', 'desc')
    .orderBy('request_id', 'desc');

  const requestMap = new Map<string, { text: string; createdAt: string | null }>();
  const requestRowsBySession = new Map<string, Array<{ text: string; createdAt: string | null }>>();
  const completedSessionIds = new Set<string>();

  for (const row of rows) {
    const sessionId = String(row.session_id ?? '').trim();
    const userText = String(row.user_text ?? '').trim();

    if (!sessionId || completedSessionIds.has(sessionId) || !userText) {
      continue;
    }

    const requestRows = requestRowsBySession.get(sessionId) ?? [];
    requestRows.push({
      text: userText,
      createdAt: normalizeDateTimeValue(row.created_at),
    });

    if (requestRows.length >= 5) {
      completedSessionIds.add(sessionId);
    }

    requestRowsBySession.set(sessionId, requestRows);

    if (completedSessionIds.size >= normalizedSessionIds.length) {
      break;
    }
  }

  for (const sessionId of normalizedSessionIds) {
    const preview = buildLatestRequestPreview(requestRowsBySession.get(sessionId) ?? []);

    if (!preview) {
      continue;
    }

    requestMap.set(sessionId, preview);
  }

  return requestMap;
}

async function getLatestResponsePreviewMap(sessionIds: string[]) {
  const normalizedSessionIds = Array.from(new Set(sessionIds.map((sessionId) => sessionId.trim()).filter(Boolean)));

  if (normalizedSessionIds.length === 0) {
    return new Map<string, { text: string; createdAt: string | null }>();
  }

  const rows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('session_id', 'response_text', 'answered_at', 'updated_at', 'status', 'request_id')
    .whereIn('session_id', normalizedSessionIds)
    .whereNot('status', 'removed')
    .orderBy('session_id', 'asc')
    .orderByRaw('COALESCE(answered_at, updated_at, created_at) desc')
    .orderBy('request_id', 'desc');

  const responseMap = new Map<string, { text: string; createdAt: string | null }>();

  for (const row of rows) {
    const sessionId = String(row.session_id ?? '').trim();
    const responseText = String(row.response_text ?? '').trim();

    if (!sessionId || responseMap.has(sessionId) || !responseText) {
      continue;
    }

    responseMap.set(sessionId, {
      text: responseText,
      createdAt: normalizeDateTimeValue(row.answered_at ?? row.updated_at),
    });
  }

  return responseMap;
}

function resolveConversationPreviewOverride(
  mapped: ChatConversationItem,
  latestMessage: { text: string; createdAt: string | null } | undefined,
  latestRequest: { text: string; createdAt: string | null } | undefined,
) {
  const latestMessageTime = getTimeValue(latestMessage?.createdAt);
  const latestRequestTime = getTimeValue(latestRequest?.createdAt);

  if (latestRequest && latestRequestTime > latestMessageTime) {
    return {
      ...mapped,
      lastMessagePreview: createPreview(latestRequest.text),
      lastMessageAt: latestRequest.createdAt,
    };
  }

  if (latestMessage) {
    return {
      ...mapped,
      lastMessagePreview: createPreview(latestMessage.text),
      lastMessageAt: latestMessage.createdAt,
    };
  }

  return mapped;
}

async function getLatestResponseMessageIdMap(sessionIds: string[]) {
  const normalizedSessionIds = Array.from(new Set(sessionIds.map((sessionId) => sessionId.trim()).filter(Boolean)));

  if (normalizedSessionIds.length === 0) {
    return new Map<string, number>();
  }

  const rows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('session_id', 'response_message_id')
    .whereIn('session_id', normalizedSessionIds)
    .whereNotNull('response_message_id')
    .orderBy('session_id', 'asc')
    .orderBy('response_message_id', 'desc');

  const responseMap = new Map<string, number>();

  for (const row of rows) {
    const sessionId = String(row.session_id ?? '').trim();
    const responseMessageId =
      row.response_message_id == null ? null : Number(row.response_message_id);

    if (!sessionId || responseMessageId == null || responseMap.has(sessionId)) {
      continue;
    }

    responseMap.set(sessionId, responseMessageId);
  }

  return responseMap;
}

async function getLatestCodexPromptPartsMap(sessionIds: string[]) {
  const normalizedSessionIds = Array.from(new Set(sessionIds.map((sessionId) => sessionId.trim()).filter(Boolean)));

  if (normalizedSessionIds.length === 0) {
    return new Map<string, ChatMessagePart[]>();
  }

  const rows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .select('session_id', 'parts_json', 'created_at', 'message_id')
    .whereIn('session_id', normalizedSessionIds)
    .andWhere('author', 'codex')
    .orderBy('session_id', 'asc')
    .orderBy('created_at', 'desc')
    .orderBy('message_id', 'desc');

  const promptPartMap = new Map<string, ChatMessagePart[]>();

  for (const row of rows) {
    const sessionId = String(row.session_id ?? '').trim();

    if (!sessionId || promptPartMap.has(sessionId)) {
      continue;
    }

    const parts = parseChatMessageParts(row.parts_json);

    if ((parts ?? []).some((part) => part.type === 'prompt')) {
      promptPartMap.set(sessionId, parts ?? []);
    }
  }

  return promptPartMap;
}

async function getLatestResponseMessageId(sessionId: string) {
  const responseMap = await getLatestResponseMessageIdMap([sessionId]);
  return responseMap.get(sessionId.trim()) ?? null;
}

export async function ensureChatConversationTables() {
  const hasConversationTable = await db.schema.hasTable(CHAT_CONVERSATION_TABLE);

  if (!hasConversationTable) {
    await db.schema.createTable(CHAT_CONVERSATION_TABLE, (table) => {
      table.string('session_id', 120).primary();
      table.string('client_id', 120).nullable().index();
      table.string('title', 200).notNullable().defaultTo('새 대화');
      table.text('draft_text').notNullable().defaultTo('');
      table.string('request_badge_label', 120).nullable();
      table.string('codex_model', 120).nullable();
      table.string('chat_type_id', 120).nullable();
      table.string('last_chat_type_id', 120).nullable();
      table.string('general_section_name', 120).nullable();
      table.string('context_label', 200).nullable();
      table.text('context_description').nullable();
      table.boolean('notify_offline').notNullable().defaultTo(false);
      table.string('current_request_id', 120).nullable();
      table.string('current_job_status', 40).nullable();
      table.text('current_job_message').nullable();
      table.integer('current_queue_size').notNullable().defaultTo(0);
      table.timestamp('current_status_updated_at', { useTz: true }).nullable();
      table.text('last_message_preview').notNullable().defaultTo('');
      table.timestamp('last_message_at', { useTz: true }).nullable();
      table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
    });
  }

  const requiredConversationColumns: Array<[string, (table: any) => void]> = [
    ['client_id', (table) => table.string('client_id', 120).nullable().index()],
    ['title', (table) => table.string('title', 200).notNullable().defaultTo('새 대화')],
    ['draft_text', (table) => table.text('draft_text').notNullable().defaultTo('')],
    ['request_badge_label', (table) => table.string('request_badge_label', 120).nullable()],
    ['codex_model', (table) => table.string('codex_model', 120).nullable()],
    ['chat_type_id', (table) => table.string('chat_type_id', 120).nullable()],
    ['last_chat_type_id', (table) => table.string('last_chat_type_id', 120).nullable()],
    ['general_section_name', (table) => table.string('general_section_name', 120).nullable()],
    ['context_label', (table) => table.string('context_label', 200).nullable()],
    ['context_description', (table) => table.text('context_description').nullable()],
    ['notify_offline', (table) => table.boolean('notify_offline').notNullable().defaultTo(false)],
    ['current_request_id', (table) => table.string('current_request_id', 120).nullable()],
    ['current_job_status', (table) => table.string('current_job_status', 40).nullable()],
    ['current_job_message', (table) => table.text('current_job_message').nullable()],
    ['current_queue_size', (table) => table.integer('current_queue_size').notNullable().defaultTo(0)],
    ['current_status_updated_at', (table) => table.timestamp('current_status_updated_at', { useTz: true }).nullable()],
    ['last_message_preview', (table) => table.text('last_message_preview').notNullable().defaultTo('')],
    ['last_message_at', (table) => table.timestamp('last_message_at', { useTz: true }).nullable()],
    ['created_at', (table) => table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
    ['updated_at', (table) => table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredConversationColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_TABLE, (table) => {
        createColumn(table);
      });
    }
  }

  const hasClientTable = await db.schema.hasTable(CHAT_CONVERSATION_CLIENT_TABLE);

  if (!hasClientTable) {
    await db.schema.createTable(CHAT_CONVERSATION_CLIENT_TABLE, (table) => {
      table.increments('id').primary();
      table.string('session_id', 120).notNullable().index();
      table.string('client_id', 120).notNullable().index();
      table.boolean('notify_offline').notNullable().defaultTo(false);
      table.bigInteger('last_read_response_message_id').nullable();
      table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.unique(['session_id', 'client_id']);
    });
  }

  const requiredClientColumns: Array<[string, (table: any) => void]> = [
    ['session_id', (table) => table.string('session_id', 120).notNullable().index()],
    ['client_id', (table) => table.string('client_id', 120).notNullable().index()],
    ['notify_offline', (table) => table.boolean('notify_offline').notNullable().defaultTo(false)],
    ['last_read_response_message_id', (table) => table.bigInteger('last_read_response_message_id').nullable()],
    ['created_at', (table) => table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
    ['updated_at', (table) => table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredClientColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_CLIENT_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_CLIENT_TABLE, (table) => {
        createColumn(table);
      });
    }
  }

  const hasMessageTable = await db.schema.hasTable(CHAT_CONVERSATION_MESSAGE_TABLE);

  if (!hasMessageTable) {
    await db.schema.createTable(CHAT_CONVERSATION_MESSAGE_TABLE, (table) => {
      table.increments('id').primary();
      table.string('session_id', 120).notNullable().index();
      table.bigInteger('message_id').notNullable();
      table.string('author', 20).notNullable();
      table.text('text').notNullable();
      table.text('parts_json').notNullable().defaultTo('[]');
      table.string('display_timestamp', 40).notNullable().defaultTo('');
      table.string('client_request_id', 120).nullable();
      table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.unique(['session_id', 'message_id']);
    });
  }

  const requiredMessageColumns: Array<[string, (table: any) => void]> = [
    ['session_id', (table) => table.string('session_id', 120).notNullable().index()],
    ['message_id', (table) => table.bigInteger('message_id').notNullable()],
    ['author', (table) => table.string('author', 20).notNullable().defaultTo('codex')],
    ['text', (table) => table.text('text').notNullable().defaultTo('')],
    ['parts_json', (table) => table.text('parts_json').notNullable().defaultTo('[]')],
    ['display_timestamp', (table) => table.string('display_timestamp', 40).notNullable().defaultTo('')],
    ['client_request_id', (table) => table.string('client_request_id', 120).nullable()],
    ['created_at', (table) => table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredMessageColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_MESSAGE_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_MESSAGE_TABLE, (table) => {
        createColumn(table);
      });
    }
  }

  const hasRequestTable = await db.schema.hasTable(CHAT_CONVERSATION_REQUEST_TABLE);

  if (!hasRequestTable) {
    await db.schema.createTable(CHAT_CONVERSATION_REQUEST_TABLE, (table) => {
      table.increments('id').primary();
      table.string('session_id', 120).notNullable().index();
      table.string('request_id', 120).notNullable();
      table.string('requester_client_id', 200).nullable();
      table.string('chat_type_id', 120).nullable();
      table.string('chat_type_label', 200).nullable();
      table.string('request_origin', 40).nullable();
      table.string('shared_resource_token_id', 120).nullable().index();
      table.string('parent_request_id', 120).nullable();
      table.string('status', 40).notNullable().defaultTo('accepted');
      table.text('status_message').nullable();
      table.bigInteger('user_message_id').nullable();
      table.text('user_text').notNullable().defaultTo('');
      table.bigInteger('response_message_id').nullable();
      table.text('response_text').notNullable().defaultTo('');
      table.text('usage_snapshot').nullable();
      table.integer('total_tokens').nullable();
      table.timestamp('manual_prompt_completed_at', { useTz: true }).nullable();
      table.timestamp('manual_verification_completed_at', { useTz: true }).nullable();
      table.timestamp('answered_at', { useTz: true }).nullable();
      table.timestamp('terminal_at', { useTz: true }).nullable();
      table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.unique(['session_id', 'request_id']);
    });
  }

  const requiredRequestColumns: Array<[string, (table: any) => void]> = [
    ['session_id', (table) => table.string('session_id', 120).notNullable().index()],
    ['request_id', (table) => table.string('request_id', 120).notNullable()],
    ['requester_client_id', (table) => table.string('requester_client_id', 200).nullable()],
    ['chat_type_id', (table) => table.string('chat_type_id', 120).nullable()],
    ['chat_type_label', (table) => table.string('chat_type_label', 200).nullable()],
    ['request_origin', (table) => table.string('request_origin', 40).nullable()],
    ['shared_resource_token_id', (table) => table.string('shared_resource_token_id', 120).nullable().index()],
    ['parent_request_id', (table) => table.string('parent_request_id', 120).nullable()],
    ['status', (table) => table.string('status', 40).notNullable().defaultTo('accepted')],
    ['status_message', (table) => table.text('status_message').nullable()],
    ['user_message_id', (table) => table.bigInteger('user_message_id').nullable()],
    ['user_text', (table) => table.text('user_text').notNullable().defaultTo('')],
    ['response_message_id', (table) => table.bigInteger('response_message_id').nullable()],
    ['response_text', (table) => table.text('response_text').notNullable().defaultTo('')],
    ['usage_snapshot', (table) => table.text('usage_snapshot').nullable()],
    ['total_tokens', (table) => table.integer('total_tokens').nullable()],
    ['manual_prompt_completed_at', (table) => table.timestamp('manual_prompt_completed_at', { useTz: true }).nullable()],
    ['manual_verification_completed_at', (table) =>
      table.timestamp('manual_verification_completed_at', { useTz: true }).nullable()],
    ['answered_at', (table) => table.timestamp('answered_at', { useTz: true }).nullable()],
    ['terminal_at', (table) => table.timestamp('terminal_at', { useTz: true }).nullable()],
    ['created_at', (table) => table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
    ['updated_at', (table) => table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredRequestColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_REQUEST_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_REQUEST_TABLE, (table) => {
        createColumn(table);
      });
    }
  }

  const hasActivityTable = await db.schema.hasTable(CHAT_CONVERSATION_ACTIVITY_TABLE);

  if (!hasActivityTable) {
    await db.schema.createTable(CHAT_CONVERSATION_ACTIVITY_TABLE, (table) => {
      table.increments('id').primary();
      table.string('session_id', 120).notNullable().index();
      table.string('request_id', 120).notNullable().index();
      table.integer('line_no').notNullable();
      table.text('text').notNullable();
      table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.unique(['session_id', 'request_id', 'line_no']);
    });
  }

  const requiredActivityColumns: Array<[string, (table: any) => void]> = [
    ['session_id', (table) => table.string('session_id', 120).notNullable().index()],
    ['request_id', (table) => table.string('request_id', 120).notNullable().index()],
    ['line_no', (table) => table.integer('line_no').notNullable()],
    ['text', (table) => table.text('text').notNullable().defaultTo('')],
    ['created_at', (table) => table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredActivityColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_ACTIVITY_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_ACTIVITY_TABLE, (table) => {
        createColumn(table);
      });
    }
  }

  const hasSourceChangeTable = await db.schema.hasTable(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE);

  if (!hasSourceChangeTable) {
    await db.schema.createTable(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE, (table) => {
      table.increments('id').primary();
      table.string('session_id', 120).notNullable().index();
      table.string('client_id', 120).nullable().index();
      table.string('request_id', 120).notNullable();
      table.string('conversation_title', 200).notNullable().defaultTo('새 대화');
      table.string('chat_type_id', 120).nullable();
      table.string('chat_type_label', 200).nullable();
      table.string('request_title', 200).notNullable().defaultTo('');
      table.text('question_text').notNullable().defaultTo('');
      table.text('answer_text').notNullable().defaultTo('');
      table.string('status', 40).notNullable().defaultTo('completed');
      table.timestamp('answered_at', { useTz: true }).nullable();
      table.timestamp('source_changed_at', { useTz: true }).nullable();
      table.text('feature_tags_json').notNullable().defaultTo('[]');
      table.text('changed_files_json').notNullable().defaultTo('[]');
      table.text('current_source_files_json').notNullable().defaultTo('[]');
      table.text('diff_blocks_json').notNullable().defaultTo('[]');
      table.boolean('has_source_changes').notNullable().defaultTo(false);
      table.string('review_status', 40).notNullable().defaultTo('not-reviewed');
      table.string('source_change_kind', 40).notNullable().defaultTo('request');
      table.text('source_entry_ids_json').notNullable().defaultTo('[]');
      table.timestamp('conversation_deleted_at', { useTz: true }).nullable();
      table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now());
      table.unique(['session_id', 'request_id']);
    });
  }

  const requiredSourceChangeColumns: Array<[string, (table: any) => void]> = [
    ['session_id', (table) => table.string('session_id', 120).notNullable().index()],
    ['client_id', (table) => table.string('client_id', 120).nullable().index()],
    ['request_id', (table) => table.string('request_id', 120).notNullable()],
    ['conversation_title', (table) => table.string('conversation_title', 200).notNullable().defaultTo('새 대화')],
    ['chat_type_id', (table) => table.string('chat_type_id', 120).nullable()],
    ['chat_type_label', (table) => table.string('chat_type_label', 200).nullable()],
    ['request_title', (table) => table.string('request_title', 200).notNullable().defaultTo('')],
    ['question_text', (table) => table.text('question_text').notNullable().defaultTo('')],
    ['answer_text', (table) => table.text('answer_text').notNullable().defaultTo('')],
    ['status', (table) => table.string('status', 40).notNullable().defaultTo('completed')],
    ['answered_at', (table) => table.timestamp('answered_at', { useTz: true }).nullable()],
    ['source_changed_at', (table) => table.timestamp('source_changed_at', { useTz: true }).nullable()],
    ['feature_tags_json', (table) => table.text('feature_tags_json').notNullable().defaultTo('[]')],
    ['changed_files_json', (table) => table.text('changed_files_json').notNullable().defaultTo('[]')],
    ['current_source_files_json', (table) => table.text('current_source_files_json').notNullable().defaultTo('[]')],
    ['diff_blocks_json', (table) => table.text('diff_blocks_json').notNullable().defaultTo('[]')],
    ['has_source_changes', (table) => table.boolean('has_source_changes').notNullable().defaultTo(false)],
    ['review_status', (table) => table.string('review_status', 40).notNullable().defaultTo('not-reviewed')],
    ['source_change_kind', (table) => table.string('source_change_kind', 40).notNullable().defaultTo('request')],
    ['source_entry_ids_json', (table) => table.text('source_entry_ids_json').notNullable().defaultTo('[]')],
    ['conversation_deleted_at', (table) => table.timestamp('conversation_deleted_at', { useTz: true }).nullable()],
    ['updated_at', (table) => table.timestamp('updated_at', { useTz: true }).notNullable().defaultTo(db.fn.now())],
  ];

  for (const [columnName, createColumn] of requiredSourceChangeColumns) {
    const hasColumn = await db.schema.hasColumn(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE, columnName);

    if (!hasColumn) {
      await db.schema.alterTable(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE, (table) => {
        createColumn(table);
      });
    }
  }
}

export async function getChatConversation(sessionId: string, clientId?: string | null) {
  const normalizedSessionId = sessionId.trim();
  let row = await db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first();

  if (!row) {
    return null;
  }

  const currentRequestId = String(row.current_request_id ?? '').trim() || null;

  if (
    shouldClearConversationJobState({
      currentRequestId,
      currentJobStatus: row.current_job_status == null ? null : String(row.current_job_status) as ChatConversationItem['currentJobStatus'],
      currentStatusUpdatedAt: normalizeDateTimeValue(row.current_status_updated_at),
      runtimeActive: isRuntimeRequestActive(currentRequestId),
      request: currentRequestId
        ? await db(CHAT_CONVERSATION_REQUEST_TABLE)
            .where({
              session_id: normalizedSessionId,
              request_id: currentRequestId,
            })
            .first()
            .then((requestRow) =>
              requestRow
                ? {
                    requestId: String(requestRow.request_id ?? ''),
                    status: String(requestRow.status ?? '') as ChatConversationRequestStatus,
                    responseMessageId: requestRow.response_message_id == null ? null : Number(requestRow.response_message_id),
                    responseText: String(requestRow.response_text ?? ''),
                    terminalAt: normalizeDateTimeValue(requestRow.terminal_at),
                    updatedAt: normalizeDateTimeValue(requestRow.updated_at),
                  }
                : null,
            )
        : null,
    })
  ) {
    const shouldMarkRequestFailed =
      currentRequestId &&
      !isRuntimeRequestActive(currentRequestId) &&
      ['queued', 'started'].includes(String(row.current_job_status ?? '').trim());

    if (shouldMarkRequestFailed) {
      await db(CHAT_CONVERSATION_REQUEST_TABLE)
        .where({
          session_id: normalizedSessionId,
          request_id: currentRequestId,
        })
        .whereIn('status', ['queued', 'started'])
        .update({
          status: 'failed',
          status_message: '중단된 오래된 요청',
          terminal_at: db.fn.now(),
          updated_at: db.fn.now(),
        });
    }

    await db(CHAT_CONVERSATION_TABLE)
      .where({ session_id: normalizedSessionId })
      .update({
        current_request_id: null,
        current_job_status: null,
        current_job_message: null,
        current_queue_size: 0,
        current_status_updated_at: db.fn.now(),
        updated_at: db.fn.now(),
      });
    row = await db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first();

    if (!row) {
      return null;
    }
  }

  const mapped = mapConversationRow(row);
  const latestPreviewMessageMap = await getLatestPreviewableMessageMap([normalizedSessionId]);
  const latestRequestPreviewMap = await getLatestRequestPreviewMap([normalizedSessionId]);
  const previewResolvedConversation = resolveConversationPreviewOverride(
    mapped,
    latestPreviewMessageMap.get(normalizedSessionId),
    latestRequestPreviewMap.get(normalizedSessionId),
  );
  const normalizedClientId = normalizeClientId(clientId);

  if (!normalizedClientId) {
    return previewResolvedConversation;
  }

  const preference = await getChatConversationClientPreference(sessionId, normalizedClientId);
  const latestResponseMessageId = await getLatestResponseMessageId(normalizedSessionId);
  return {
    ...previewResolvedConversation,
    clientId: normalizedClientId,
    notifyOffline: preference?.notifyOffline ?? previewResolvedConversation.notifyOffline,
    hasUnreadResponse:
      latestResponseMessageId != null &&
      latestResponseMessageId > (preference?.lastReadResponseMessageId ?? 0),
  };
}

export async function createChatConversation(payload: z.input<typeof conversationPayloadSchema>) {
  const parsed = conversationPayloadSchema.parse(payload);
  const normalizedClientId = normalizeClientId(parsed.clientId);
  const notifyOffline = parsed.notifyOffline ?? true;
  await db(CHAT_CONVERSATION_TABLE)
    .insert({
      session_id: parsed.sessionId,
      client_id: normalizedClientId,
      title: parsed.title?.trim() || '새 대화',
      draft_text: parsed.draftText ?? '',
      request_badge_label: parsed.requestBadgeLabel?.trim() || null,
      codex_model: parsed.codexModel?.trim() || null,
      chat_type_id: parsed.chatTypeId?.trim() || null,
      last_chat_type_id: parsed.lastChatTypeId?.trim() || parsed.chatTypeId?.trim() || null,
      general_section_name: parsed.generalSectionName?.trim() || null,
      context_label: parsed.contextLabel?.trim() || null,
      context_description: parsed.contextDescription?.trim() || null,
      notify_offline: notifyOffline,
      current_request_id: null,
      current_job_status: null,
      current_job_message: null,
      current_queue_size: 0,
      current_status_updated_at: null,
      last_message_preview: '',
      last_message_at: null,
      created_at: db.fn.now(),
      updated_at: db.fn.now(),
    })
    .onConflict('session_id')
    .ignore();

  if (normalizedClientId) {
    const existingPreference = await getChatConversationClientPreference(parsed.sessionId, normalizedClientId);

    if (!existingPreference) {
      await upsertChatConversationClientPreference(parsed.sessionId, normalizedClientId, notifyOffline);
    }
  }

  const conversation = await getChatConversation(parsed.sessionId, normalizedClientId);

  if (!conversation) {
    throw new Error('채팅방을 저장했지만 다시 불러오지 못했습니다.');
  }

  return conversation;
}

export async function updateChatConversationContext(
  sessionId: string,
  payload: {
    title?: string | null;
    draftText?: string | null;
    requestBadgeLabel?: string | null;
    clientId?: string | null;
    codexModel?: string | null;
    chatTypeId?: string | null;
    lastChatTypeId?: string | null;
    generalSectionName?: string | null;
    contextLabel?: string | null;
    contextDescription?: string | null;
    notifyOffline?: boolean | null;
  },
) {
  const normalizedClientId = normalizeClientId(payload.clientId);
  const current = await db(CHAT_CONVERSATION_TABLE).where({ session_id: sessionId.trim() }).first();

  if (!current) {
    return null;
  }

  const nextUpdatePayload: Record<string, unknown> = {
    ...buildChatConversationContextUpdateFields({
      current,
      payload,
    }),
    updated_at: db.fn.now(),
  };

  await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: sessionId.trim() })
    .update(nextUpdatePayload);

  if (normalizedClientId && payload.notifyOffline != null) {
    await upsertChatConversationClientPreference(sessionId, normalizedClientId, payload.notifyOffline);
  }

  return getChatConversation(sessionId, normalizedClientId);
}

export function resolveNextConversationChatTypeId(currentChatTypeId?: string | null, requestedChatTypeId?: string | null) {
  const normalizedCurrentChatTypeId = String(currentChatTypeId ?? '').trim() || null;
  const normalizedRequestedChatTypeId = String(requestedChatTypeId ?? '').trim() || null;
  return normalizedRequestedChatTypeId ?? normalizedCurrentChatTypeId ?? null;
}

export function buildChatConversationContextUpdateFields(args: {
  current: Record<string, unknown>;
  payload: {
    title?: string | null;
    draftText?: string | null;
    requestBadgeLabel?: string | null;
    clientId?: string | null;
    codexModel?: string | null;
    chatTypeId?: string | null;
    lastChatTypeId?: string | null;
    generalSectionName?: string | null;
    contextLabel?: string | null;
    contextDescription?: string | null;
    notifyOffline?: boolean | null;
  };
}) {
  const hasDefinedPayloadValue = (key: keyof typeof args.payload) =>
    Object.prototype.hasOwnProperty.call(args.payload, key) && args.payload[key] !== undefined;
  const currentTitle = String(args.current.title ?? '').trim() || null;
  const currentDraftText = typeof args.current.draft_text === 'string' ? String(args.current.draft_text) : '';
  const currentRequestBadgeLabel = String(args.current.request_badge_label ?? '').trim() || null;
  const currentCodexModel = String(args.current.codex_model ?? '').trim() || null;
  const currentGeneralSectionName = String(args.current.general_section_name ?? '').trim() || null;
  const currentContextLabel = String(args.current.context_label ?? '').trim() || null;
  const currentContextDescription = String(args.current.context_description ?? '').trim() || null;
  const normalizedClientId = normalizeClientId(args.payload.clientId);
  const currentChatTypeId = String(args.current.chat_type_id ?? '').trim() || null;
  const requestedChatTypeId = args.payload.chatTypeId?.trim() || null;
  const nextChatTypeId = resolveNextConversationChatTypeId(currentChatTypeId, requestedChatTypeId);
  const requestedTitle = args.payload.title?.trim() || null;
  const requestedContextLabel = args.payload.contextLabel?.trim() || null;
  const requestedContextDescription = args.payload.contextDescription?.trim() || null;
  const hasRequestedCodexModel = hasDefinedPayloadValue('codexModel');
  const hasRequestedChatTypeId = hasDefinedPayloadValue('chatTypeId');
  const hasRequestedLastChatTypeId = hasDefinedPayloadValue('lastChatTypeId');
  const hasRequestedTitle = hasDefinedPayloadValue('title');
  const hasRequestedDraftText = hasDefinedPayloadValue('draftText');
  const hasRequestedRequestBadgeLabel = hasDefinedPayloadValue('requestBadgeLabel');
  const hasRequestedGeneralSectionName = hasDefinedPayloadValue('generalSectionName');
  const hasRequestedContextLabel = hasDefinedPayloadValue('contextLabel');
  const hasRequestedContextDescription = hasDefinedPayloadValue('contextDescription');
  const hasRequestedNotifyOffline = hasDefinedPayloadValue('notifyOffline');
  const nextUpdatePayload: Record<string, unknown> = {};

  if (hasRequestedTitle) {
    nextUpdatePayload.title =
      resolveNextConversationContextValue(currentTitle, requestedTitle, hasRequestedTitle) ?? '새 대화';
  }

  if (hasRequestedDraftText) {
    nextUpdatePayload.draft_text = args.payload.draftText ?? currentDraftText;
  }

  if (hasRequestedRequestBadgeLabel) {
    nextUpdatePayload.request_badge_label = resolveNextConversationContextValue(
      currentRequestBadgeLabel,
      args.payload.requestBadgeLabel,
      hasRequestedRequestBadgeLabel,
    );
  }

  if (hasRequestedCodexModel) {
    nextUpdatePayload.codex_model = resolveNextConversationContextValue(
      currentCodexModel,
      args.payload.codexModel,
      hasRequestedCodexModel,
    );
  }

  if (normalizedClientId && normalizedClientId !== String(args.current.client_id ?? '').trim()) {
    nextUpdatePayload.client_id = normalizedClientId;
  }

  if (hasRequestedChatTypeId) {
    nextUpdatePayload.chat_type_id = nextChatTypeId;
  }

  if (hasRequestedChatTypeId || hasRequestedLastChatTypeId) {
    nextUpdatePayload.last_chat_type_id = hasRequestedLastChatTypeId
      ? args.payload.lastChatTypeId?.trim() || nextChatTypeId || args.current.last_chat_type_id || null
      : nextChatTypeId;
  }

  if (hasRequestedGeneralSectionName) {
    nextUpdatePayload.general_section_name = resolveNextConversationContextValue(
      currentGeneralSectionName,
      args.payload.generalSectionName,
      hasRequestedGeneralSectionName,
    );
  }

  if (hasRequestedContextLabel) {
    nextUpdatePayload.context_label = resolveNextConversationContextValue(
      currentContextLabel,
      requestedContextLabel,
      hasRequestedContextLabel,
    );
  }

  if (hasRequestedContextDescription) {
    nextUpdatePayload.context_description = resolveNextConversationContextValue(
      currentContextDescription,
      requestedContextDescription,
      hasRequestedContextDescription,
    );
  }

  if (normalizedClientId == null && hasRequestedNotifyOffline && args.payload.notifyOffline != null) {
    nextUpdatePayload.notify_offline = args.payload.notifyOffline;
  }

  return nextUpdatePayload;
}

export function resolveNextConversationContextValue(
  currentValue: string | null | undefined,
  requestedValue: string | null | undefined,
  hasRequestedValue: boolean,
) {
  if (!hasRequestedValue) {
    return String(currentValue ?? '').trim() || null;
  }

  return String(requestedValue ?? '').trim() || null;
}

export async function listChatConversations(
  clientId?: string | null,
  limit = 50,
  unreadStateClientId?: string | null,
) {
  const normalizedClientId = normalizeClientId(clientId);
  const normalizedUnreadStateClientId = normalizeClientId(unreadStateClientId ?? clientId);
  const normalizedLimit = Math.max(1, Math.min(200, Math.round(limit)));
  let conversationListScopeClientId = normalizedClientId;
  const buildConversationListQuery = (targetClientId?: string | null) => {
    const query = db(CHAT_CONVERSATION_TABLE)
      .select('*')
      .orderByRaw('COALESCE(last_message_at, updated_at, created_at) DESC NULLS LAST')
      .orderByRaw('last_message_at DESC NULLS LAST')
      .orderByRaw('updated_at DESC NULLS LAST')
      .orderByRaw('created_at DESC NULLS LAST')
      .limit(normalizedLimit);

    if (targetClientId) {
      query.where((builder) => {
        builder
          .where({ client_id: targetClientId })
          .orWhereExists(
            db(CHAT_CONVERSATION_CLIENT_TABLE)
              .select(db.raw('1'))
              .whereRaw(`${CHAT_CONVERSATION_CLIENT_TABLE}.session_id = ${CHAT_CONVERSATION_TABLE}.session_id`)
              .andWhere({ client_id: targetClientId }),
          );
      });
    }

    return query;
  };

  let rows = await buildConversationListQuery(normalizedClientId);

  // Browser storage reset can regenerate client_id and hide existing rooms.
  // When that happens, fall back to the recent global list so the user can recover.
  if (normalizedClientId && rows.length === 0) {
    conversationListScopeClientId = null;
    rows = await buildConversationListQuery(null);
  }

  const sessionIds = rows.map((row) => String(row.session_id ?? '')).filter(Boolean);
  const currentRequestIds = Array.from(
    new Set(rows.map((row) => String(row.current_request_id ?? '').trim()).filter(Boolean)),
  );

  if (sessionIds.length > 0 && currentRequestIds.length > 0) {
    const requestRows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
      .select('session_id', 'request_id', 'status', 'response_message_id', 'response_text', 'terminal_at')
      .whereIn('session_id', sessionIds)
      .whereIn('request_id', currentRequestIds);
    const requestMap = new Map(
      requestRows.map((requestRow) => [
        `${String(requestRow.session_id ?? '').trim()}:${String(requestRow.request_id ?? '').trim()}`,
        {
          requestId: String(requestRow.request_id ?? ''),
          status: String(requestRow.status ?? '') as ChatConversationRequestStatus,
          responseMessageId: requestRow.response_message_id == null ? null : Number(requestRow.response_message_id),
          responseText: String(requestRow.response_text ?? ''),
          terminalAt: normalizeDateTimeValue(requestRow.terminal_at),
        },
      ]),
    );
    const staleSessionIds = rows
      .filter((row) =>
        shouldClearConversationJobState({
          currentRequestId: String(row.current_request_id ?? ''),
          currentJobStatus: row.current_job_status == null ? null : String(row.current_job_status) as ChatConversationItem['currentJobStatus'],
          currentStatusUpdatedAt: normalizeDateTimeValue(row.current_status_updated_at),
          runtimeActive: isRuntimeRequestActive(String(row.current_request_id ?? '')),
          request:
            requestMap.get(`${String(row.session_id ?? '').trim()}:${String(row.current_request_id ?? '').trim()}`) ?? null,
        }),
      )
      .map((row) => String(row.session_id ?? '').trim())
      .filter(Boolean);

    if (staleSessionIds.length > 0) {
      const staleRequestIds = rows
        .filter((row) => staleSessionIds.includes(String(row.session_id ?? '').trim()))
        .map((row) => ({
          sessionId: String(row.session_id ?? '').trim(),
          requestId: String(row.current_request_id ?? '').trim(),
          status: String(row.current_job_status ?? '').trim(),
        }))
        .filter((item) => item.requestId && (item.status === 'queued' || item.status === 'started'));

      for (const staleItem of staleRequestIds) {
        await db(CHAT_CONVERSATION_REQUEST_TABLE)
          .where({
            session_id: staleItem.sessionId,
            request_id: staleItem.requestId,
          })
          .whereIn('status', ['queued', 'started'])
          .update({
            status: 'failed',
            status_message: '중단된 오래된 요청',
            terminal_at: db.fn.now(),
            updated_at: db.fn.now(),
          });
      }

      await db(CHAT_CONVERSATION_TABLE)
        .whereIn('session_id', staleSessionIds)
        .update({
          current_request_id: null,
          current_job_status: null,
          current_job_message: null,
          current_queue_size: 0,
          current_status_updated_at: db.fn.now(),
          updated_at: db.fn.now(),
        });
      rows = await buildConversationListQuery(conversationListScopeClientId);
    }
  }

  rows = rows.filter((row) => !isManagedChatShareSessionId(String(row.session_id ?? '')));

  if (rows.length > 0) {
    const candidateSessionIds = rows.map((row) => String(row.session_id ?? '').trim()).filter(Boolean);
    const [messageSessionRows, requestSessionRows] = await Promise.all([
      db(CHAT_CONVERSATION_MESSAGE_TABLE).distinct('session_id').whereIn('session_id', candidateSessionIds),
      db(CHAT_CONVERSATION_REQUEST_TABLE).distinct('session_id').whereIn('session_id', candidateSessionIds),
    ]);
    const visibleSessionIds = new Set(
      [...messageSessionRows, ...requestSessionRows]
        .map((row) => String(row.session_id ?? '').trim())
        .filter(Boolean),
    );

    rows = rows.filter((row) => {
      const sessionId = String(row.session_id ?? '').trim();
      return visibleSessionIds.has(sessionId) || hasConversationMetadata(row);
    });
  }

  const latestPreviewMessageMap = await getLatestPreviewableMessageMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const latestRequestPreviewMap = await getLatestRequestPreviewMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const latestResponsePreviewMap = await getLatestResponsePreviewMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const pendingAttentionBySessionId = await getConversationPendingAttentionMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const latestResponseMessageIdMap = await getLatestResponseMessageIdMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const latestCodexPromptPartsMap = await getLatestCodexPromptPartsMap(
    rows.map((row) => String(row.session_id ?? '')),
  );
  const mapListConversationRow = (row: Record<string, unknown>) => ({
    ...mapConversationRow(row),
    contextDescription: summarizeConversationListContextDescription(row.context_description as string | null | undefined),
  });

  if (!normalizedUnreadStateClientId) {
    return rows
      .map((row) => {
        const mapped = mapListConversationRow(row);
        const pendingWorkState = resolvePendingWorkState({
          requestText: latestRequestPreviewMap.get(mapped.sessionId)?.text ?? '',
          responseText: latestResponsePreviewMap.get(mapped.sessionId)?.text ?? '',
          latestCodexParts: latestCodexPromptPartsMap.get(mapped.sessionId),
        });
        return {
          ...resolveConversationPreviewOverride(
            mapped,
            latestPreviewMessageMap.get(mapped.sessionId),
            latestRequestPreviewMap.get(mapped.sessionId),
          ),
          ...pendingWorkState,
          lastRequestPreview: createPreview(latestRequestPreviewMap.get(mapped.sessionId)?.text ?? ''),
          lastResponsePreview: createPreview(latestResponsePreviewMap.get(mapped.sessionId)?.text ?? ''),
          hasUnreadResponse: false,
          hasPendingAttention: pendingAttentionBySessionId.get(mapped.sessionId) === true,
        };
      })
      .sort((left, right) =>
        (right.lastMessageAt ?? right.updatedAt).localeCompare(left.lastMessageAt ?? left.updatedAt),
      );
  }

  if (rows.length === 0) {
    return [];
  }

  const preferences = await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .select('*')
    .where({ client_id: normalizedUnreadStateClientId })
    .whereIn(
      'session_id',
      rows.map((row) => String(row.session_id ?? '')).filter(Boolean),
    );

  const preferenceMap = new Map(
    preferences.map((row) => {
      const mapped = mapClientPreferenceRow(row);
      return [mapped.sessionId, mapped];
    }),
  );

  return rows
    .map((row) => {
      const mapped = mapListConversationRow(row);
      const preference = preferenceMap.get(mapped.sessionId);
      const latestPreviewMessage = latestPreviewMessageMap.get(mapped.sessionId);
      const pendingWorkState = resolvePendingWorkState({
        requestText: latestRequestPreviewMap.get(mapped.sessionId)?.text ?? '',
        responseText: latestResponsePreviewMap.get(mapped.sessionId)?.text ?? '',
        latestCodexParts: latestCodexPromptPartsMap.get(mapped.sessionId),
      });

      return {
        ...resolveConversationPreviewOverride(
          mapped,
          latestPreviewMessage,
          latestRequestPreviewMap.get(mapped.sessionId),
        ),
        ...pendingWorkState,
        lastRequestPreview: createPreview(latestRequestPreviewMap.get(mapped.sessionId)?.text ?? ''),
        lastResponsePreview: createPreview(latestResponsePreviewMap.get(mapped.sessionId)?.text ?? ''),
        clientId: normalizedUnreadStateClientId,
        notifyOffline: preference?.notifyOffline ?? mapped.notifyOffline,
        hasUnreadResponse:
          (latestResponseMessageIdMap.get(mapped.sessionId) ?? 0) >
          (preference?.lastReadResponseMessageId ?? 0),
        hasPendingAttention: pendingAttentionBySessionId.get(mapped.sessionId) === true,
      };
    })
    .sort((left, right) =>
      (right.lastMessageAt ?? right.updatedAt).localeCompare(left.lastMessageAt ?? left.updatedAt),
    );
}

export async function listChatConversationMessages(
  sessionId: string,
  options: {
    limit?: number;
    beforeMessageId?: number | null;
  } = {},
) {
  const normalizedLimit = Math.max(1, Math.min(1000, Math.round(options.limit ?? 200)));
  const normalizedBeforeMessageId =
    Number.isFinite(options.beforeMessageId) && (options.beforeMessageId ?? 0) > 0
      ? Math.trunc(options.beforeMessageId as number)
      : null;
  const query = db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .select('*')
    .where({ session_id: sessionId.trim() })
    .modify((builder) => {
      if (normalizedBeforeMessageId !== null) {
        builder.where('message_id', '<', normalizedBeforeMessageId);
      }

      builder.andWhere((visibilityBuilder) => {
        applyVisibleConversationMessageCondition(visibilityBuilder);
      });
    })
    .orderBy('message_id', 'desc')
    .orderBy('id', 'desc')
    .limit(normalizedLimit);
  const latestRows = await query;

  return latestRows.reverse().map((row: Parameters<typeof mapMessageRow>[0]) => mapMessageRow(row));
}

export async function listChatConversationActivityLogsByRequestIds(
  sessionId: string,
  requestIds: string[],
): Promise<ChatConversationActivityLogItem[]> {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestIds = Array.from(new Set(requestIds.map((item) => item.trim()).filter(Boolean)));

  if (!normalizedSessionId || normalizedRequestIds.length === 0) {
    return [];
  }

  const rows = await db(CHAT_CONVERSATION_ACTIVITY_TABLE)
    .select('session_id', 'request_id', 'text', 'line_no', 'created_at')
    .where({ session_id: normalizedSessionId })
    .whereIn('request_id', normalizedRequestIds)
    .orderBy('request_id', 'asc')
    .orderBy('line_no', 'asc')
    .orderBy('id', 'asc');

  const activityMap = new Map<string, ChatConversationActivityLogItem>();

  for (const row of rows) {
    const requestId = String(row.request_id ?? '').trim();

    if (!requestId) {
      continue;
    }

    const existing = activityMap.get(requestId);

    if (existing) {
      existing.lines.push(String(row.text ?? ''));
      existing.updatedAt = normalizeDateTimeValue(row.created_at) ?? existing.updatedAt;
      continue;
    }

    activityMap.set(requestId, {
      sessionId: String(row.session_id ?? normalizedSessionId),
      requestId,
      lines: [String(row.text ?? '')],
      updatedAt: normalizeDateTimeValue(row.created_at),
    });
  }

  return normalizedRequestIds
    .map((requestId) => activityMap.get(requestId))
    .filter(Boolean) as ChatConversationActivityLogItem[];
}

async function resolveConversationRequestCursor(sessionId: string, beforeMessageId: number) {
  const normalizedSessionId = sessionId.trim();
  const normalizedBeforeMessageId = Math.trunc(beforeMessageId);

  if (!normalizedSessionId || normalizedBeforeMessageId <= 0) {
    return null;
  }

  const directRequestRow = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('request_id', 'created_at')
    .where({ session_id: normalizedSessionId })
    .andWhere((builder) => {
      builder.where('user_message_id', normalizedBeforeMessageId).orWhere('response_message_id', normalizedBeforeMessageId);
    })
    .first();

  if (directRequestRow) {
    return {
      requestId: String(directRequestRow.request_id ?? '').trim(),
      createdAt: normalizeDateTimeValue(directRequestRow.created_at) ?? '',
    };
  }

  const messageRow = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .select('client_request_id')
    .where({
      session_id: normalizedSessionId,
      message_id: normalizedBeforeMessageId,
    })
    .first();
  const linkedRequestId = String(messageRow?.client_request_id ?? '').trim();

  if (!linkedRequestId) {
    return null;
  }

  const linkedRequestRow = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('request_id', 'created_at')
    .where({
      session_id: normalizedSessionId,
      request_id: linkedRequestId,
    })
    .first();

  if (!linkedRequestRow) {
    return null;
  }

  return {
    requestId: String(linkedRequestRow.request_id ?? '').trim(),
    createdAt: normalizeDateTimeValue(linkedRequestRow.created_at) ?? '',
  };
}

export async function listChatConversationDetailPage(
  sessionId: string,
  options: {
    limit?: number;
    beforeMessageId?: number | null;
  } = {},
): Promise<ChatConversationDetailPage> {
  const normalizedSessionId = sessionId.trim();
  await getChatConversation(normalizedSessionId, null);
  const conversation = await db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first();
  const normalizedLimit = Math.max(1, Math.min(100, Math.round(options.limit ?? 10)));
  const normalizedBeforeMessageId =
    Number.isFinite(options.beforeMessageId) && (options.beforeMessageId ?? 0) > 0
      ? Math.trunc(options.beforeMessageId as number)
      : null;
  const requestCursor =
    normalizedBeforeMessageId == null
      ? null
      : await resolveConversationRequestCursor(normalizedSessionId, normalizedBeforeMessageId);

  const requestRows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({ session_id: normalizedSessionId })
    .whereNot('status', 'removed')
    .modify((builder) => {
      if (!requestCursor) {
        return;
      }

      builder.andWhere((cursorBuilder) => {
        cursorBuilder
          .where('created_at', '<', requestCursor.createdAt)
          .orWhere((sameTimeBuilder) => {
            sameTimeBuilder.where('created_at', '=', requestCursor.createdAt).andWhere('request_id', '<', requestCursor.requestId);
          });
      });
    })
    .orderBy('created_at', 'desc')
    .orderBy('request_id', 'desc')
    .limit(normalizedLimit);

  const orderedRequestRows = [...requestRows].reverse();
  const requests = orderedRequestRows.map((row) => normalizeStaleRequestItem(mapRequestRow(row), conversation));
  const requestIds = requests.map((item) => item.requestId.trim()).filter(Boolean);

  if (requestIds.length === 0) {
    return {
      messages: [],
      requests,
      activityLogs: [],
      oldestLoadedMessageId: null,
      hasOlderMessages: false,
    };
  }

  const messageRows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .select('*')
    .where({ session_id: normalizedSessionId })
    .whereIn('client_request_id', requestIds)
    .andWhere((builder) => {
      applyVisibleConversationMessageCondition(builder);
    })
    .orderBy('message_id', 'asc')
    .orderBy('id', 'asc');
  const messages = messageRows.map((row: Parameters<typeof mapMessageRow>[0]) => mapMessageRow(row));
  const activityLogs = await listChatConversationActivityLogsByRequestIds(normalizedSessionId, requestIds);
  const oldestLoadedMessageId =
    requests.reduce<number | null>((oldestId, request) => {
      const candidateIds = [request.userMessageId, request.responseMessageId].filter(
        (value): value is number => typeof value === 'number' && Number.isInteger(value) && value > 0,
      );

      if (candidateIds.length === 0) {
        return oldestId;
      }

      const nextCandidateId = Math.min(...candidateIds);
      return oldestId == null ? nextCandidateId : Math.min(oldestId, nextCandidateId);
    }, null) ?? messages[0]?.id ?? null;
  const oldestRequest = requests[0] ?? null;
  const hasOlderMessages = oldestRequest
    ? Boolean(
        await db(CHAT_CONVERSATION_REQUEST_TABLE)
          .where({ session_id: normalizedSessionId })
          .whereNot('status', 'removed')
          .andWhere((builder) => {
            builder
              .where('created_at', '<', oldestRequest.createdAt)
              .orWhere((sameTimeBuilder) => {
                sameTimeBuilder.where('created_at', '=', oldestRequest.createdAt).andWhere('request_id', '<', oldestRequest.requestId);
              });
          })
          .first(),
      )
    : false;

  return {
    messages,
    requests,
    activityLogs,
    oldestLoadedMessageId,
    hasOlderMessages,
  };
}

export async function listChatConversationRequests(sessionId: string, limit = 200) {
  const normalizedSessionId = sessionId.trim();
  await getChatConversation(normalizedSessionId, null);
  const conversation = await db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first();

  const rows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({ session_id: normalizedSessionId })
    .orderBy('created_at', 'asc')
    .limit(Math.max(1, Math.min(1000, Math.round(limit))));

  return rows.map((row) => normalizeStaleRequestItem(mapRequestRow(row), conversation));
}

export async function listChatSourceChangeSnapshots(clientId?: string | null, limit = 200) {
  await ensureChatConversationTables();
  await db(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
    .where({ has_source_changes: true })
    .andWhere('changed_files_json', '[]')
    .andWhere('current_source_files_json', '[]')
    .andWhere('diff_blocks_json', '[]')
    .update({
      has_source_changes: false,
      updated_at: db.fn.now(),
    });

  const normalizedClientId = normalizeClientId(clientId);
  const normalizedLimit = Math.max(1, Math.min(500, Math.round(limit)));

  const buildQuery = (targetClientId?: string | null) =>
    db(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
      .select('*')
      .where({ has_source_changes: true })
      .modify((builder) => {
        if (targetClientId) {
          builder.where({ client_id: targetClientId });
        }
      })
      .orderByRaw('COALESCE(source_changed_at, answered_at, updated_at) DESC NULLS LAST')
      .orderBy('updated_at', 'desc')
      .limit(normalizedLimit);

  let rows = await buildQuery(normalizedClientId);

  if (normalizedClientId && rows.length === 0) {
    rows = await buildQuery(null);
  }

  return rows.map((row: Parameters<typeof mapSourceChangeSnapshotRow>[0]) => mapSourceChangeSnapshotRow(row));
}

async function applyVerifiedSourceChangeGrouping(args: {
  sessionId: string;
  clientId?: string | null;
  conversationTitle?: string | null;
  chatTypeId?: string | null;
  chatTypeLabel?: string | null;
  requestId: string;
  questionText: string;
  answerText: string;
  status: ChatConversationRequestStatus;
  answeredAt?: string | null;
  updatedAt?: string | null;
}) {
  const metadata = parseSourceChangeVerificationMetadata(args.questionText);

  if (!metadata) {
    return;
  }

  const selectedFeatureKeys = parseSelectedPromptValues(args.answerText);
  const entryRefs = metadata.features.flatMap((feature) => feature.entryRefs);

  if (entryRefs.length === 0) {
    return;
  }

  const sourceRows = await db(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
    .select('*')
    .where((builder) => {
      entryRefs.forEach((entryRef, index) => {
        const method = index === 0 ? 'where' : 'orWhere';
        builder[method]((nestedBuilder: any) => {
          nestedBuilder.where({
            session_id: entryRef.sessionId,
            request_id: entryRef.requestId,
          });
        });
      });
    });

  const sourceRowMap = new Map<string, Record<string, unknown>>();
  sourceRows.forEach((row) => {
    const sessionId = String(row.session_id ?? '').trim();
    const requestId = String(row.request_id ?? '').trim();

    if (sessionId && requestId) {
      sourceRowMap.set(`${sessionId}:${requestId}`, row);
    }
  });

  const activeSourceIds = Array.from(new Set(entryRefs.map((entryRef) => `${entryRef.sessionId}:${entryRef.requestId}`)));

  await db.transaction(async (trx) => {
    if (activeSourceIds.length > 0) {
      await trx(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
        .where((builder) => {
          activeSourceIds.forEach((entryId, index) => {
            const dividerIndex = entryId.indexOf(':');
            const sessionId = dividerIndex >= 0 ? entryId.slice(0, dividerIndex) : '';
            const requestId = dividerIndex >= 0 ? entryId.slice(dividerIndex + 1) : '';
            const method = index === 0 ? 'where' : 'orWhere';

            builder[method]((nestedBuilder: any) => {
              nestedBuilder.where({
                session_id: sessionId,
                request_id: requestId,
              });
            });
          });
        })
        .update({
          has_source_changes: false,
          updated_at: db.fn.now(),
        });
    }

    await Promise.all(metadata.features.map(async (feature, index) => {
      const featureRows = feature.entryRefs
        .map((entryRef) => sourceRowMap.get(`${entryRef.sessionId}:${entryRef.requestId}`) ?? null)
        .filter((row): row is Record<string, unknown> => row != null);

      if (featureRows.length === 0) {
        return;
      }

      const changedFiles = stringifyStringArray(featureRows.flatMap((row) => parseStringArray(row.changed_files_json)));
      const currentSourceFiles = stringifyStringArray(featureRows.flatMap((row) => parseStringArray(row.current_source_files_json)));
      const diffBlocks = stringifyStringArray(featureRows.flatMap((row) => parseStringArray(row.diff_blocks_json)));
      const payload = buildSourceChangeSnapshotPayload({
        sessionId: args.sessionId,
        clientId: args.clientId ?? null,
        conversationTitle: args.conversationTitle ?? null,
        chatTypeId: args.chatTypeId ?? null,
        chatTypeLabel: args.chatTypeLabel ?? null,
        requestId: buildVerificationGroupRequestId(args.requestId, feature.key, index),
        status: args.status,
        questionText: args.questionText,
        answerText: args.answerText,
        answeredAt: args.answeredAt ?? null,
        updatedAt: args.updatedAt ?? null,
        reviewStatus: selectedFeatureKeys.has(feature.key) ? 'reviewed' : 'not-reviewed',
        sourceChangeKind: 'verification-group',
        sourceEntryIds: feature.entryRefs.map((entryRef) => `${entryRef.sessionId}:${entryRef.requestId}`),
      });

      await trx(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
        .insert({
          ...payload,
          request_title: `${feature.label} 검증`,
          feature_tags_json: stringifyStringArray([feature.label]),
          changed_files_json: changedFiles,
          current_source_files_json: currentSourceFiles,
          diff_blocks_json: diffBlocks,
          has_source_changes: hasMeaningfulChatSourceArtifacts({
            changedFiles: parseStringArray(changedFiles),
            currentSourceFiles: parseStringArray(currentSourceFiles),
            diffBlocks: parseStringArray(diffBlocks),
          }),
        })
        .onConflict(['session_id', 'request_id'])
        .merge();
    }));
  });
}

export async function syncChatSourceChangeSnapshot(sessionId: string, requestId: string) {
  await ensureChatConversationTables();

  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();

  await getChatConversation(normalizedSessionId, null);

  if (!normalizedSessionId || !normalizedRequestId) {
    return null;
  }

  const [conversation, request] = await Promise.all([
    db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first(),
    db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedRequestId,
      })
      .first(),
  ]);

  if (!request) {
    return null;
  }

  const status = String(request.status ?? 'accepted') as ChatConversationRequestStatus;
  const questionText = String(request.user_text ?? '').trim();
  const answerText = String(request.response_text ?? '').trim();

  if (status !== 'completed' || !answerText || isPreparingChatReplyText(answerText)) {
    return null;
  }

  const payload = buildSourceChangeSnapshotPayload({
    sessionId: normalizedSessionId,
    clientId: conversation?.client_id == null ? null : String(conversation.client_id),
    conversationTitle: String(conversation?.title ?? '새 대화'),
    chatTypeId: conversation?.chat_type_id == null ? null : String(conversation.chat_type_id),
    chatTypeLabel: conversation?.context_label == null ? null : String(conversation.context_label),
    requestId: normalizedRequestId,
    status,
    questionText,
    answerText,
    answeredAt: normalizeDateTimeValue(request.answered_at),
    updatedAt: normalizeDateTimeValue(request.updated_at),
  });

  await db(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
    .insert(payload)
    .onConflict(['session_id', 'request_id'])
    .merge(payload);

  await applyVerifiedSourceChangeGrouping({
    sessionId: normalizedSessionId,
    clientId: conversation?.client_id == null ? null : String(conversation.client_id),
    conversationTitle: String(conversation?.title ?? '새 대화'),
    chatTypeId: conversation?.chat_type_id == null ? null : String(conversation.chat_type_id),
    chatTypeLabel: conversation?.context_label == null ? null : String(conversation.context_label),
    requestId: normalizedRequestId,
    questionText,
    answerText,
    status,
    answeredAt: normalizeDateTimeValue(request.answered_at),
    updatedAt: normalizeDateTimeValue(request.updated_at),
  });

  const row = await db(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  return row ? mapSourceChangeSnapshotRow(row) : null;
}

export async function getChatConversationRequest(sessionId: string, requestId: string) {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();

  if (!normalizedSessionId || !normalizedRequestId) {
    return null;
  }

  await getChatConversation(normalizedSessionId, null);

  const conversation = await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: normalizedSessionId })
    .first();
  const row = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  return row ? normalizeStaleRequestItem(mapRequestRow(row), conversation) : null;
}

async function refreshConversationPreview(sessionId: string) {
  const latestMessage = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .where({ session_id: sessionId.trim() })
    .whereIn('author', ['user', 'codex'])
    .orderBy('created_at', 'desc')
    .orderBy('id', 'desc')
    .first();

  await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: sessionId.trim() })
    .update({
      last_message_preview: latestMessage && isPreviewableConversationMessage(latestMessage) ? createPreview(String(latestMessage.text ?? '')) : '',
      last_message_at: latestMessage && isPreviewableConversationMessage(latestMessage) ? latestMessage.created_at : null,
      updated_at: db.fn.now(),
    });
}

export async function appendChatConversationMessage(
  conversationPayload: z.input<typeof conversationPayloadSchema>,
  messagePayload: z.input<typeof conversationMessagePayloadSchema>,
) {
  const conversation = conversationPayloadSchema.parse(conversationPayload);
  const message = conversationMessagePayloadSchema.parse(messagePayload);

  await createChatConversation(conversation);

  const currentConversation = await db(CHAT_CONVERSATION_TABLE).where({ session_id: conversation.sessionId }).first();
  const resolvedClientRequestId =
    message.clientRequestId?.trim() ||
    (message.author === 'codex' ? String(currentConversation?.current_request_id ?? '').trim() || null : null);

  await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .insert({
      session_id: message.sessionId,
      message_id: message.messageId,
      author: message.author,
      text: message.text,
      parts_json: stringifyChatMessageParts(message.parts),
      display_timestamp: message.timestamp,
      client_request_id: resolvedClientRequestId,
      created_at: db.fn.now(),
    })
    .onConflict(['session_id', 'message_id'])
    .merge({
      author: message.author,
      text: message.text,
      parts_json: stringifyChatMessageParts(message.parts),
      display_timestamp: message.timestamp,
      client_request_id: resolvedClientRequestId,
    });

  await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: conversation.sessionId })
    .update({
      client_id: normalizeClientId(conversation.clientId) || currentConversation?.client_id || null,
      draft_text: '',
      chat_type_id: currentConversation?.chat_type_id || conversation.chatTypeId?.trim() || null,
      last_chat_type_id:
        currentConversation?.chat_type_id ||
        currentConversation?.last_chat_type_id ||
        conversation.chatTypeId?.trim() ||
        conversation.lastChatTypeId?.trim() ||
        null,
      context_label:
        currentConversation?.chat_type_id || currentConversation?.context_label
          ? currentConversation?.context_label || null
          : conversation.contextLabel?.trim() || null,
      context_description:
        currentConversation?.chat_type_id || currentConversation?.context_description
          ? currentConversation?.context_description || null
          : conversation.contextDescription?.trim() || null,
      notify_offline:
        conversation.notifyOffline == null ? Boolean(currentConversation?.notify_offline) : conversation.notifyOffline,
      updated_at: db.fn.now(),
    });

  await refreshConversationPreview(conversation.sessionId);

  if (normalizeClientId(conversation.clientId) && conversation.notifyOffline != null) {
    await upsertChatConversationClientPreference(
      conversation.sessionId,
      normalizeClientId(conversation.clientId)!,
      conversation.notifyOffline,
    );
  }

  const requestPatch = buildChatConversationRequestPatchFromMessage({
    id: message.messageId,
    author: message.author,
    text: message.text,
    clientRequestId: resolvedClientRequestId,
  });

  if (requestPatch) {
    await upsertChatConversationRequest(conversation.sessionId, {
      requestId: requestPatch.requestId,
      requesterClientId:
        message.author === 'user'
          ? normalizeClientId(conversation.clientId)
          : undefined,
      status: requestPatch.status,
      userMessageId: requestPatch.userMessageId,
      userText: requestPatch.userText,
      responseMessageId: requestPatch.responseMessageId,
      responseText: requestPatch.responseText,
    });
  }
}

export async function appendChatConversationActivityLine(
  sessionId: string,
  requestId: string,
  line: string,
  lineNo?: number,
) {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();
  const normalizedLine = line.trim();

  if (!normalizedSessionId || !normalizedRequestId || !normalizedLine) {
    return null;
  }

  const normalizedLineNo =
    Number.isInteger(lineNo) && Number(lineNo) > 0 ? Number(lineNo) : undefined;
  let nextLineNo = normalizedLineNo ?? null;

  if (nextLineNo == null) {
    const existingLineCountRow = await db(CHAT_CONVERSATION_ACTIVITY_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedRequestId,
      })
      .count<{ count?: string | number }>('id as count')
      .first();
    nextLineNo = Number(existingLineCountRow?.count ?? 0) + 1;
  }

  await db(CHAT_CONVERSATION_ACTIVITY_TABLE)
    .insert({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
      line_no: nextLineNo,
      text: normalizedLine,
      created_at: db.fn.now(),
    })
    .onConflict(['session_id', 'request_id', 'line_no'])
    .merge({
      text: normalizedLine,
      created_at: db.fn.now(),
    });

  return nextLineNo;
}

export async function listChatConversationActivityLogs(
  sessionId: string,
  limitRequests = 500,
): Promise<ChatConversationActivityLogItem[]> {
  const normalizedSessionId = sessionId.trim();

  if (!normalizedSessionId) {
    return [];
  }

  const requestRows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .select('request_id')
    .where({ session_id: normalizedSessionId })
    .whereNot('status', 'removed')
    .orderBy('created_at', 'desc')
    .orderBy('request_id', 'desc')
    .limit(limitRequests);
  const requestIds = requestRows
    .map((row) => String(row.request_id ?? '').trim())
    .filter(Boolean);

  if (requestIds.length === 0) {
    return [];
  }

  const rows = await db(CHAT_CONVERSATION_ACTIVITY_TABLE)
    .select('session_id', 'request_id', 'text', 'line_no', 'created_at')
    .where({ session_id: normalizedSessionId })
    .whereIn('request_id', requestIds)
    .orderBy('request_id', 'asc')
    .orderBy('line_no', 'asc')
    .orderBy('id', 'asc');

  const activityMap = new Map<string, ChatConversationActivityLogItem>();

  for (const row of rows) {
    const requestId = String(row.request_id ?? '').trim();

    if (!requestId) {
      continue;
    }

    const existing = activityMap.get(requestId);

    if (existing) {
      existing.lines.push(String(row.text ?? ''));
      existing.updatedAt = normalizeDateTimeValue(row.created_at) ?? existing.updatedAt;
      continue;
    }

    activityMap.set(requestId, {
      sessionId: String(row.session_id ?? normalizedSessionId),
      requestId,
      lines: [String(row.text ?? '')],
      updatedAt: normalizeDateTimeValue(row.created_at),
    });
  }

  return requestIds.map((requestId) => activityMap.get(requestId)).filter(Boolean) as ChatConversationActivityLogItem[];
}

export async function listRecoverableChatConversationRequests(): Promise<RecoverableChatConversationRequestItem[]> {
  await ensureChatConversationTables();

  const rows = await db(`${CHAT_CONVERSATION_REQUEST_TABLE} as request`)
    .join(`${CHAT_CONVERSATION_TABLE} as conversation`, 'conversation.session_id', 'request.session_id')
    .select(
      'request.session_id',
      'request.request_id',
      'request.request_origin',
      'request.shared_resource_token_id',
      'request.parent_request_id',
      'request.status',
      'request.user_text',
      'request.created_at',
      'request.updated_at',
      'conversation.client_id',
      'conversation.chat_type_id',
      'conversation.last_chat_type_id',
      'conversation.general_section_name',
      'conversation.context_label',
      'conversation.context_description',
      'conversation.current_request_id',
      'conversation.current_job_status',
      'conversation.current_status_updated_at',
    )
    .whereIn('request.status', ['accepted', 'queued', 'started'])
    .andWhere((builder) => {
      builder.whereNull('request.terminal_at');
    })
    .andWhere((builder) => {
      builder.whereNull('request.response_message_id').orWhere('request.response_message_id', 0);
    })
    .orderByRaw(
      "case when request.request_id = conversation.current_request_id then 0 else 1 end asc",
    )
    .orderBy('request.session_id', 'asc')
    .orderBy('request.created_at', 'asc')
    .orderBy('request.request_id', 'asc');

  return rows
    .map((row) => {
      const sessionId = String(row.session_id ?? '').trim();
      const requestId = String(row.request_id ?? '').trim();
      const userText = String(row.user_text ?? '').trim();
      const createdAt = normalizeDateTimeValue(row.created_at) ?? '';

      if (!sessionId || !requestId || !userText || !createdAt) {
        return null;
      }

      return {
        sessionId,
        clientId: row.client_id == null ? null : String(row.client_id),
        chatTypeId: row.chat_type_id == null ? null : String(row.chat_type_id),
        lastChatTypeId: row.last_chat_type_id == null ? null : String(row.last_chat_type_id),
        generalSectionName: row.general_section_name == null ? null : String(row.general_section_name),
        contextLabel: row.context_label == null ? null : String(row.context_label),
        contextDescription: row.context_description == null ? null : String(row.context_description),
        currentRequestId: row.current_request_id == null ? null : String(row.current_request_id),
        currentJobStatus:
          row.current_job_status == null ? null : (String(row.current_job_status) as ChatConversationItem['currentJobStatus']),
        requestId,
        requestOrigin:
          row.request_origin == null
            ? null
            : String(row.request_origin) === 'prompt' || String(row.request_origin) === 'composer'
              ? (String(row.request_origin) as 'composer' | 'prompt')
              : null,
        sharedResourceTokenId: row.shared_resource_token_id == null ? null : String(row.shared_resource_token_id),
        parentRequestId: row.parent_request_id == null ? null : String(row.parent_request_id),
        status: String(row.status ?? 'accepted') as ChatConversationRequestStatus,
        userText,
        createdAt,
        updatedAt: normalizeDateTimeValue(row.updated_at) ?? createdAt,
        currentStatusUpdatedAt: normalizeDateTimeValue(row.current_status_updated_at),
      } satisfies RecoverableChatConversationRequestItem;
    })
    .filter((item): item is RecoverableChatConversationRequestItem => {
      if (!item) {
        return false;
      }

      return !shouldClearConversationJobState({
        currentRequestId: item.currentRequestId,
        currentJobStatus: item.currentJobStatus,
        currentStatusUpdatedAt: item.currentStatusUpdatedAt,
        runtimeActive: false,
        request: {
          requestId: item.requestId,
          status: item.status,
          responseMessageId: null,
          responseText: '',
          terminalAt: null,
          updatedAt: item.updatedAt,
        },
      });
    });
}

export async function updateChatConversationJobState(
  sessionId: string,
  payload: {
    requestId?: string | null;
    status?: 'queued' | 'started' | 'completed' | 'failed' | null;
    message?: string | null;
    queueSize?: number | null;
    clear?: boolean;
  },
) {
  const current = await db(CHAT_CONVERSATION_TABLE).where({ session_id: sessionId.trim() }).first();

  if (!current) {
    return null;
  }

  const shouldClear = payload.clear === true;

  await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: sessionId.trim() })
    .update({
      current_request_id: shouldClear ? null : payload.requestId?.trim() || current.current_request_id || null,
      current_job_status: shouldClear ? null : payload.status ?? current.current_job_status ?? null,
      current_job_message: shouldClear ? null : payload.message?.trim() || null,
      current_queue_size: shouldClear ? 0 : Math.max(0, Math.round(payload.queueSize ?? current.current_queue_size ?? 0)),
      current_status_updated_at: db.fn.now(),
      updated_at: db.fn.now(),
    });

  const row = await db(CHAT_CONVERSATION_TABLE).where({ session_id: sessionId.trim() }).first();
  return row ? mapConversationRow(row) : null;
}

async function clearConversationJobStateForRequest(sessionId: string, requestId: string) {
  await db(CHAT_CONVERSATION_TABLE)
    .where({
      session_id: sessionId,
      current_request_id: requestId,
    })
    .update({
      current_request_id: null,
      current_job_status: null,
      current_job_message: null,
      current_queue_size: 0,
      current_status_updated_at: db.fn.now(),
      updated_at: db.fn.now(),
    });
}

export async function upsertChatConversationRequest(
  sessionId: string,
  payload: {
    requestId: string;
    requesterClientId?: string | null;
    chatTypeId?: string | null;
    chatTypeLabel?: string | null;
    requestOrigin?: 'composer' | 'prompt' | null;
    sharedResourceTokenId?: string | null;
    parentRequestId?: string | null;
    status?: ChatConversationRequestStatus;
    statusMessage?: string | null;
    userMessageId?: number | null;
    userText?: string | null;
    responseMessageId?: number | null;
    responseText?: string | null;
    usageSnapshot?: ChatConversationRequestUsageSnapshot | null;
    totalTokens?: number | null;
  },
) {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = payload.requestId.trim();
  const normalizedRequesterClientId = payload.requesterClientId?.trim() || null;
  const normalizedChatTypeId = payload.chatTypeId?.trim() || null;
  const normalizedChatTypeLabel = payload.chatTypeLabel?.trim() || null;
  const normalizedRequestOrigin =
    payload.requestOrigin === 'prompt' || payload.requestOrigin === 'composer' ? payload.requestOrigin : null;
  const normalizedSharedResourceTokenId = payload.sharedResourceTokenId?.trim() || null;
  const normalizedParentRequestId = payload.parentRequestId?.trim() || null;

  if (!normalizedSessionId || !normalizedRequestId) {
    return null;
  }

  let nextRow:
    | {
        session_id: string;
        request_id: string;
        requester_client_id: string | null;
        chat_type_id: string | null;
        chat_type_label: string | null;
        request_origin: 'composer' | 'prompt' | null;
        shared_resource_token_id: string | null;
        parent_request_id: string | null;
        status: ChatConversationRequestStatus;
        status_message: string | null;
        user_message_id: number | null;
        user_text: string;
        response_message_id: number | null;
        response_text: string;
        usage_snapshot: string | null;
        total_tokens: number | null;
        manual_prompt_completed_at: unknown;
        manual_verification_completed_at: unknown;
        answered_at: unknown;
        terminal_at: unknown;
        created_at: unknown;
        updated_at: unknown;
      }
    | null = null;
  let nextStatus: ChatConversationRequestStatus = payload.status ?? 'accepted';

  for (let attempt = 0; attempt < 3; attempt += 1) {
    const current = await db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedRequestId,
      })
      .first();

    nextStatus = mergeChatConversationRequestStatus(
      (current?.status as ChatConversationRequestStatus | undefined) ?? null,
      payload.status ?? null,
    );
    const currentStatus = (current?.status as ChatConversationRequestStatus | undefined) ?? null;
    const defaultStatusMessage =
      payload.status && payload.status !== currentStatus
        ? getDefaultChatConversationRequestStatusMessage(nextStatus)
        : null;
    const terminalStatus = ['completed', 'failed', 'cancelled', 'removed'].includes(nextStatus)
      ? db.fn.now()
      : current?.terminal_at ?? null;
    const answeredAt =
      payload.responseMessageId != null || (payload.responseText?.trim() ?? '').length > 0
        ? current?.answered_at ?? db.fn.now()
        : current?.answered_at ?? null;
    const normalizedUsageSnapshot =
      payload.usageSnapshot === undefined
        ? current?.usage_snapshot ?? null
        : payload.usageSnapshot
          ? JSON.stringify(payload.usageSnapshot)
          : null;
    const normalizedTotalTokens =
      payload.totalTokens === undefined
        ? current?.total_tokens == null
          ? null
          : Math.max(0, Math.round(Number(current.total_tokens)))
        : payload.totalTokens == null
          ? null
          : Math.max(0, Math.round(Number(payload.totalTokens)));

    nextRow = {
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
      requester_client_id: normalizedRequesterClientId ?? current?.requester_client_id ?? null,
      chat_type_id: normalizedChatTypeId ?? current?.chat_type_id ?? null,
      chat_type_label: normalizedChatTypeLabel ?? current?.chat_type_label ?? null,
      request_origin: normalizedRequestOrigin ?? current?.request_origin ?? null,
      shared_resource_token_id: normalizedSharedResourceTokenId ?? current?.shared_resource_token_id ?? null,
      parent_request_id: normalizedParentRequestId ?? current?.parent_request_id ?? null,
      status: nextStatus,
      status_message: payload.statusMessage?.trim() || defaultStatusMessage || current?.status_message || null,
      user_message_id: payload.userMessageId ?? current?.user_message_id ?? null,
      user_text: payload.userText ?? current?.user_text ?? '',
      response_message_id: payload.responseMessageId ?? current?.response_message_id ?? null,
      response_text: payload.responseText ?? current?.response_text ?? '',
      usage_snapshot: normalizedUsageSnapshot,
      total_tokens: normalizedTotalTokens,
      manual_prompt_completed_at: current?.manual_prompt_completed_at ?? null,
      manual_verification_completed_at: current?.manual_verification_completed_at ?? null,
      answered_at: answeredAt,
      terminal_at: terminalStatus,
      created_at: current?.created_at ?? db.fn.now(),
      updated_at: db.fn.now(),
    };

    if (current) {
      await db(CHAT_CONVERSATION_REQUEST_TABLE)
        .where({
          session_id: normalizedSessionId,
          request_id: normalizedRequestId,
        })
        .update(nextRow);
      break;
    }

    const insertedRows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
      .insert(nextRow)
      .onConflict(['session_id', 'request_id'])
      .ignore()
      .returning(['session_id']);

    if (insertedRows.length > 0) {
      break;
    }
  }

  if (!nextRow) {
    return null;
  }

  const row = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  if (
    shouldClearConversationJobState({
      currentRequestId: normalizedRequestId,
      currentJobStatus: 'started',
      request: {
        requestId: normalizedRequestId,
        status: nextStatus,
        responseMessageId: nextRow.response_message_id,
        responseText: nextRow.response_text,
        terminalAt: nextRow.terminal_at == null ? null : String(nextRow.terminal_at),
      },
    })
  ) {
    await clearConversationJobStateForRequest(normalizedSessionId, normalizedRequestId);
  }

  if (
    nextStatus === 'completed' &&
    (nextRow.response_message_id != null || String(nextRow.response_text ?? '').trim().length > 0)
  ) {
    await syncChatSourceChangeSnapshot(normalizedSessionId, normalizedRequestId);
  }

  return row ? mapRequestRow(row) : null;
}

export async function markChatConversationRequestManualCompletion(
  sessionId: string,
  requestId: string,
  completionType: 'prompt' | 'verification',
) {
  await ensureChatConversationTables();

  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();

  if (!normalizedSessionId || !normalizedRequestId) {
    return null;
  }

  const targetColumn =
    completionType === 'prompt' ? 'manual_prompt_completed_at' : 'manual_verification_completed_at';

  await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .update({
      [targetColumn]: db.fn.now(),
      updated_at: db.fn.now(),
    });

  const conversation = await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: normalizedSessionId })
    .first();
  const row = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  return row ? normalizeStaleRequestItem(mapRequestRow(row), conversation) : null;
}

export async function persistChatConversationPromptSelection(
  sessionId: string,
  parentRequestId: string,
  selection: ChatPromptSelectionPatch,
) {
  await ensureChatConversationTables();

  const normalizedSessionId = sessionId.trim();
  const normalizedParentRequestId = parentRequestId.trim();

  if (!normalizedSessionId || !normalizedParentRequestId) {
    return null;
  }

  let requestRow = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedParentRequestId,
    })
    .first();

  const resolvedAt = new Date().toISOString();
  if (!requestRow) {
    return null;
  }

  const loadCandidateRequestRows = async () =>
    db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
      })
      .select('request_id', 'parent_request_id', 'response_message_id', 'created_at')
      .orderBy('created_at', 'desc')
      .orderBy('request_id', 'desc');

  let candidateRequestRows = await loadCandidateRequestRows();
  let candidateRequestIds = collectPromptSelectionCandidateRequestIds(candidateRequestRows, normalizedParentRequestId);
  const sourceMessageId = normalizePromptSelectionSourceMessageId(selection);

  if (candidateRequestIds.length === 0) {
    candidateRequestIds = [normalizedParentRequestId];
  }

  const candidateMessageRows: Record<string, unknown>[] = [];
  const seenMessageIds = new Set<string>();
  const appendCandidateMessageRows = (rows: Record<string, unknown>[]) => {
    rows.forEach((row) => {
      const messageId = String(row.message_id ?? row.id ?? '').trim();

      if (!messageId || seenMessageIds.has(messageId)) {
        return;
      }

      seenMessageIds.add(messageId);
      candidateMessageRows.push(row);
    });
  };
  const loadResponseMessageRow = async (targetRequestRow: Record<string, unknown> | undefined | null) => {
    const responseMessageId =
      targetRequestRow?.response_message_id == null ? null : Number(targetRequestRow.response_message_id);

    if (responseMessageId == null) {
      return null;
    }

    return db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({
        session_id: normalizedSessionId,
        message_id: responseMessageId,
      })
      .first();
  };

  if (sourceMessageId != null) {
    const sourceMessageRow = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({
        session_id: normalizedSessionId,
        message_id: sourceMessageId,
      })
      .first();

    if (sourceMessageRow) {
      appendCandidateMessageRows([sourceMessageRow]);
    }
  }

  const appendCandidateResponseMessageRows = async (
    rows: Array<Record<string, unknown>>,
    preferredRequestIds: string[],
  ) => {
    const requestRowById = new Map(
      rows.map((row) => [String(row.request_id ?? '').trim(), row] as const).filter(([requestId]) => requestId),
    );

    for (const requestId of preferredRequestIds) {
      const targetRequestRow = requestRowById.get(requestId);

      if (!targetRequestRow) {
        continue;
      }

      const responseMessageRow = await loadResponseMessageRow(targetRequestRow);

      if (responseMessageRow) {
        appendCandidateMessageRows([responseMessageRow]);
      }
    }
  };

  await appendCandidateResponseMessageRows(candidateRequestRows, candidateRequestIds);

  if (candidateMessageRows.length === 0) {
    await repairChatConversationRequestLinks(normalizedSessionId);
    requestRow = await db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedParentRequestId,
      })
      .first();

    if (!requestRow) {
      return null;
    }

    candidateRequestRows = await loadCandidateRequestRows();
    candidateRequestIds = collectPromptSelectionCandidateRequestIds(candidateRequestRows, normalizedParentRequestId);

    if (candidateRequestIds.length === 0) {
      candidateRequestIds = [normalizedParentRequestId];
    }

    await appendCandidateResponseMessageRows(candidateRequestRows, candidateRequestIds);
  }

  const linkedMessageRows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .where({
      session_id: normalizedSessionId,
    })
    .whereIn('client_request_id', candidateRequestIds)
    .orderBy('created_at', 'desc')
    .orderBy('message_id', 'desc')
    .orderBy('id', 'desc')
    .limit(Math.max(12, candidateRequestIds.length * 4));

  appendCandidateMessageRows(linkedMessageRows);

  if (candidateMessageRows.length === 0) {
    const recentPromptMessageRows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({
        session_id: normalizedSessionId,
      })
      .andWhere('parts_json', 'like', '%"type":"prompt"%')
      .orderBy('created_at', 'desc')
      .orderBy('message_id', 'desc')
      .orderBy('id', 'desc')
      .limit(24);

    appendCandidateMessageRows(recentPromptMessageRows);
  }

  const matchedCandidate = selectChatPromptSelectionMessageCandidate(candidateMessageRows, selection, resolvedAt);

  if (!matchedCandidate) {
    return null;
  }

  const { messageRow, nextParts } = matchedCandidate;
  const resolvedMessageId = Number(messageRow.message_id ?? messageRow.id ?? 0);

  if (!resolvedMessageId) {
    return null;
  }

  await db(CHAT_CONVERSATION_MESSAGE_TABLE)
    .where({
      session_id: normalizedSessionId,
      message_id: resolvedMessageId,
    })
    .update({
      parts_json: stringifyChatMessageParts(nextParts),
    });

  await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedParentRequestId,
    })
    .update({
      response_message_id: requestRow.response_message_id ?? resolvedMessageId,
      response_text: String(requestRow.response_text ?? '').trim() || String(messageRow.text ?? ''),
      manual_prompt_completed_at: requestRow.manual_prompt_completed_at ?? db.fn.now(),
      updated_at: db.fn.now(),
    });

  const [updatedConversation, updatedRequestRow, updatedMessageRow] = await Promise.all([
    db(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).first(),
    db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedParentRequestId,
      })
      .first(),
    db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({
        session_id: normalizedSessionId,
        message_id: resolvedMessageId,
      })
      .first(),
  ]);

  if (!updatedRequestRow || !updatedMessageRow) {
    return null;
  }

  return {
    request: normalizeStaleRequestItem(mapRequestRow(updatedRequestRow), updatedConversation),
    message: mapMessageRow(updatedMessageRow),
  };
}

export async function repairChatConversationRequestLinks(sessionId?: string | null) {
  await ensureChatConversationTables();

  const normalizedSessionId = sessionId?.trim() || null;
  const sessionRows = normalizedSessionId
    ? [{ session_id: normalizedSessionId }]
    : await db(CHAT_CONVERSATION_REQUEST_TABLE).distinct('session_id').orderBy('session_id', 'asc');

  let repairedRequestCount = 0;
  let linkedMessageCount = 0;
  let completedStatusCount = 0;
  const touchedSessions: string[] = [];

  for (const sessionRow of sessionRows) {
    const currentSessionId = String(sessionRow.session_id ?? '').trim();

    if (!currentSessionId) {
      continue;
    }

    const requestRows = await db(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({ session_id: currentSessionId })
      .orderBy('created_at', 'asc')
      .orderBy('request_id', 'asc');
    const messageRows = await db(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({ session_id: currentSessionId })
      .select('id', 'message_id', 'author', 'text', 'parts_json', 'client_request_id', 'created_at')
      .orderBy('created_at', 'asc')
      .orderBy('message_id', 'asc')
      .orderBy('id', 'asc');

    let sessionTouched = false;
    const responseMessages: ChatConversationResponseCandidate[] = messageRows.map((row) => ({
      id: Number(row.id ?? 0),
      messageId: Number(row.message_id ?? 0),
      author: String(row.author ?? 'codex') as StoredChatMessage['author'],
      text: String(row.text ?? ''),
      clientRequestId: row.client_request_id == null ? null : String(row.client_request_id),
      createdAt: normalizeDateTimeValue(row.created_at),
    }));

    for (let index = 0; index < requestRows.length; index += 1) {
      const requestRow = requestRows[index];
      const nextRequestRow = requestRows[index + 1];
      const requestId = String(requestRow.request_id ?? '').trim();

      if (!requestId) {
        continue;
      }

      const candidate = selectChatConversationResponseCandidate(
        {
          requestId,
          createdAt: normalizeDateTimeValue(requestRow.created_at) ?? '',
          responseMessageId: requestRow.response_message_id == null ? null : Number(requestRow.response_message_id),
        },
        nextRequestRow
          ? {
              createdAt: normalizeDateTimeValue(nextRequestRow.created_at) ?? '',
            }
          : undefined,
        responseMessages,
      );

      if (!candidate) {
        continue;
      }

      if ((candidate.clientRequestId?.trim() || null) !== requestId) {
        await db(CHAT_CONVERSATION_MESSAGE_TABLE)
          .where({
            session_id: currentSessionId,
            message_id: candidate.messageId,
          })
          .update({
            client_request_id: requestId,
          });
        candidate.clientRequestId = requestId;
        linkedMessageCount += 1;
        sessionTouched = true;
      }

      const shouldPromoteToCompleted =
        !isTerminalRequestStatus(String(requestRow.status ?? '') as ChatConversationRequestStatus) &&
        requestRow.terminal_at != null;
      const nextStatus = shouldPromoteToCompleted ? 'completed' : undefined;
      const previousStatus = String(requestRow.status ?? '').trim();

      await upsertChatConversationRequest(currentSessionId, {
        requestId,
        status: nextStatus,
        responseMessageId: candidate.messageId,
        responseText: candidate.text,
      });

      if (
        requestRow.response_message_id == null ||
        String(requestRow.response_text ?? '') !== candidate.text ||
        requestRow.answered_at == null
      ) {
        repairedRequestCount += 1;
        sessionTouched = true;
      }

      if (nextStatus === 'completed' && previousStatus !== 'completed') {
        completedStatusCount += 1;
        sessionTouched = true;
      }
    }

    if (sessionTouched) {
      touchedSessions.push(currentSessionId);
    }
  }

  return {
    sessionCount: sessionRows.length,
    touchedSessions,
    repairedRequestCount,
    linkedMessageCount,
    completedStatusCount,
  };
}

export async function deleteUnansweredChatConversationRequest(sessionId: string, requestId: string) {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();
  const current = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  if (!current) {
    return { deleted: false, reason: 'not_found' as const };
  }

  const conversation = await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: normalizedSessionId })
    .first();
  const mapped = normalizeStaleRequestItem(mapRequestRow(current), conversation);

  if (mapped.hasResponse) {
    return { deleted: false, reason: 'answered' as const };
  }

  if (mapped.status === 'queued' || mapped.status === 'started') {
    return { deleted: false, reason: 'active' as const };
  }

  await db.transaction(async (trx) => {
    await trx(CHAT_CONVERSATION_MESSAGE_TABLE)
      .where({
        session_id: normalizedSessionId,
        client_request_id: normalizedRequestId,
      })
      .del();

    await trx(CHAT_CONVERSATION_REQUEST_TABLE)
      .where({
        session_id: normalizedSessionId,
        request_id: normalizedRequestId,
      })
      .del();

    const conversation = await trx(CHAT_CONVERSATION_TABLE)
      .where({ session_id: normalizedSessionId })
      .first();

    if (conversation?.current_request_id === normalizedRequestId) {
      await trx(CHAT_CONVERSATION_TABLE)
        .where({ session_id: normalizedSessionId })
        .update({
          current_request_id: null,
          current_job_status: null,
          current_job_message: null,
          current_queue_size: 0,
          current_status_updated_at: db.fn.now(),
          updated_at: db.fn.now(),
        });
    }
  });

  await refreshConversationPreview(normalizedSessionId);
  return { deleted: true, reason: null as null };
}

export async function cancelUnansweredChatConversationRequest(
  sessionId: string,
  requestId: string,
  statusMessage = '사용자 요청으로 중단된 요청을 취소 처리했습니다.',
) {
  const normalizedSessionId = sessionId.trim();
  const normalizedRequestId = requestId.trim();
  const current = await db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({
      session_id: normalizedSessionId,
      request_id: normalizedRequestId,
    })
    .first();

  if (!current) {
    return { cancelled: false, reason: 'not_found' as const, item: null };
  }

  const conversation = await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: normalizedSessionId })
    .first();
  const mapped = normalizeStaleRequestItem(mapRequestRow(current), conversation);

  if (mapped.hasResponse) {
    return { cancelled: false, reason: 'answered' as const, item: null };
  }

  if (mapped.status === 'queued' || mapped.status === 'started') {
    return { cancelled: false, reason: 'active' as const, item: null };
  }

  if (mapped.status === 'cancelled' || mapped.status === 'removed') {
    return { cancelled: false, reason: 'already_terminal' as const, item: mapped };
  }

  const item = await upsertChatConversationRequest(normalizedSessionId, {
    requestId: normalizedRequestId,
    status: 'cancelled',
    statusMessage,
  });

  await refreshConversationPreview(normalizedSessionId);
  return { cancelled: Boolean(item), reason: item ? null : ('not_found' as const), item };
}

export async function clearAllChatConversationJobStates() {
  await ensureChatConversationTables();

  await db(CHAT_CONVERSATION_TABLE)
    .whereNotNull('current_job_status')
    .update({
      current_request_id: null,
      current_job_status: null,
      current_job_message: null,
      current_queue_size: 0,
      current_status_updated_at: db.fn.now(),
      updated_at: db.fn.now(),
    });
}

export async function deleteChatConversation(sessionId: string) {
  const normalizedSessionId = sessionId.trim();

  return db.transaction(async (trx) => {
    await trx(CHAT_CONVERSATION_SOURCE_CHANGE_TABLE)
      .where({ session_id: normalizedSessionId })
      .update({
        conversation_deleted_at: db.fn.now(),
        updated_at: db.fn.now(),
      });
    await trx(CHAT_CONVERSATION_CLIENT_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_ACTIVITY_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_REQUEST_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_MESSAGE_TABLE).where({ session_id: normalizedSessionId }).del();
    const deletedCount = await trx(CHAT_CONVERSATION_TABLE).where({ session_id: normalizedSessionId }).del();
    return deletedCount > 0;
  });
}

export async function clearChatConversationData(sessionId: string, clientId?: string | null) {
  const normalizedSessionId = sessionId.trim();

  await db.transaction(async (trx) => {
    await trx(CHAT_CONVERSATION_ACTIVITY_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_REQUEST_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_MESSAGE_TABLE).where({ session_id: normalizedSessionId }).del();
    await trx(CHAT_CONVERSATION_CLIENT_TABLE)
      .where({ session_id: normalizedSessionId })
      .update({
        last_read_response_message_id: null,
        updated_at: db.fn.now(),
      });
    await trx(CHAT_CONVERSATION_TABLE)
      .where({ session_id: normalizedSessionId })
      .update({
        current_request_id: null,
        current_job_status: null,
        current_job_message: null,
        current_queue_size: 0,
        current_status_updated_at: null,
        draft_text: '',
        last_message_preview: '',
        last_message_at: null,
        updated_at: db.fn.now(),
      });
  });

  return getChatConversation(normalizedSessionId, clientId);
}

export async function getChatConversationClientPreference(sessionId: string, clientId: string) {
  const row = await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .where({
      session_id: sessionId.trim(),
      client_id: clientId.trim(),
    })
    .first();

  return row ? mapClientPreferenceRow(row) : null;
}

async function listRegisteredNotificationClientIds(clientIds: string[]) {
  const normalizedClientIds = [...new Set(clientIds.map((item) => String(item ?? '').trim()).filter(Boolean))];

  if (!normalizedClientIds.length) {
    return new Set<string>();
  }

  const [webPushRows, tokenRows] = await Promise.all([
    db(WEB_PUSH_SUBSCRIPTION_TABLE)
      .where({ is_enabled: true })
      .andWhere((builder) => {
        builder.whereIn('device_id', normalizedClientIds).orWhereIn('client_id', normalizedClientIds);
      })
      .select('device_id', 'client_id'),
    db(NOTIFICATION_TOKEN_TABLE)
      .where({ is_enabled: true })
      .whereIn('device_id', normalizedClientIds)
      .select('device_id'),
  ]);

  return collectRegisteredNotificationClientIds([...webPushRows, ...tokenRows]);
}

export async function cleanupStaleChatConversationOfflineNotificationClients(
  sessionId: string,
  options?: {
    keepClientIds?: Iterable<string | null | undefined>;
  },
) {
  const normalizedSessionId = sessionId.trim();

  if (!normalizedSessionId) {
    return [] as string[];
  }

  const rows = await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .where({
      session_id: normalizedSessionId,
      notify_offline: true,
    })
    .select('client_id');

  const optedInClientIds = rows
    .map((row) => String(row.client_id ?? '').trim())
    .filter(Boolean);
  const registeredClientIds = await listRegisteredNotificationClientIds(optedInClientIds);
  const staleClientIds = selectStaleOfflineNotificationClientIds(
    optedInClientIds.map((clientId) => ({
      clientId,
      notifyOffline: true,
      hasActivePushRegistration: registeredClientIds.has(clientId),
    })),
    options,
  );

  if (!staleClientIds.length) {
    return [] as string[];
  }

  await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .where({ session_id: normalizedSessionId })
    .whereIn('client_id', staleClientIds)
    .update({
      notify_offline: false,
      updated_at: db.fn.now(),
    });

  await cleanupNotificationMessagesForStaleTargetClients({
    sessionId: normalizedSessionId,
    staleClientIds,
  });

  return staleClientIds;
}

export async function listChatConversationOfflineNotificationClientIds(
  sessionId: string,
  options?: {
    keepClientIds?: Iterable<string | null | undefined>;
  },
) {
  await cleanupStaleChatConversationOfflineNotificationClients(sessionId, options);

  const rows = await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .where({
      session_id: sessionId.trim(),
      notify_offline: true,
    })
    .select('client_id');

  return rows
    .map((row) => String(row.client_id ?? '').trim())
    .filter(Boolean);
}

export async function upsertChatConversationClientPreference(sessionId: string, clientId: string, notifyOffline: boolean) {
  const normalizedSessionId = sessionId.trim();
  const normalizedClientId = clientId.trim();
  await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .insert({
      session_id: normalizedSessionId,
      client_id: normalizedClientId,
      notify_offline: notifyOffline,
      last_read_response_message_id: null,
      created_at: db.fn.now(),
      updated_at: db.fn.now(),
    })
    .onConflict(['session_id', 'client_id'])
    .merge({
      notify_offline: notifyOffline,
      updated_at: db.fn.now(),
    });

  if (notifyOffline) {
    await cleanupStaleChatConversationOfflineNotificationClients(normalizedSessionId, {
      keepClientIds: [normalizedClientId],
    });
  }

  return getChatConversationClientPreference(normalizedSessionId, normalizedClientId);
}

export async function markChatConversationResponsesRead(sessionId: string, clientId: string) {
  const normalizedSessionId = sessionId.trim();
  const normalizedClientId = clientId.trim();

  if (!normalizedSessionId || !normalizedClientId) {
    return null;
  }

  const currentConversation = await db(CHAT_CONVERSATION_TABLE)
    .where({ session_id: normalizedSessionId })
    .first();

  if (!currentConversation) {
    return null;
  }

  const latestResponseMessageId = await getLatestResponseMessageId(normalizedSessionId);
  await db(CHAT_CONVERSATION_CLIENT_TABLE)
    .insert({
      session_id: normalizedSessionId,
      client_id: normalizedClientId,
      notify_offline: Boolean(currentConversation.notify_offline),
      last_read_response_message_id: latestResponseMessageId,
      created_at: db.fn.now(),
      updated_at: db.fn.now(),
    })
    .onConflict(['session_id', 'client_id'])
    .merge({
      last_read_response_message_id: latestResponseMessageId,
      updated_at: db.fn.now(),
    });

  await cleanupStaleChatConversationOfflineNotificationClients(normalizedSessionId, {
    keepClientIds: [normalizedClientId],
  });

  return {
    sessionId: normalizedSessionId,
    lastReadResponseMessageId: latestResponseMessageId,
  };
}

export type SharedResourceTokenRequestUsageSummary = {
  sharedResourceTokenId: string;
  requestCount: number;
  completedRequestCount: number;
  totalTokens: number;
  lastUsedAt: string | null;
};

export function buildChatConversationRequestUsageBySharedResourceTokenIdsQuery(tokenIds: string[]) {
  const normalizedTokenIds = Array.from(new Set(tokenIds.map((value) => String(value ?? '').trim()).filter(Boolean)));

  if (normalizedTokenIds.length === 0) {
    return null;
  }

  return db(CHAT_CONVERSATION_REQUEST_TABLE)
    .whereIn('shared_resource_token_id', normalizedTokenIds)
    .groupBy('shared_resource_token_id')
    .select(
      'shared_resource_token_id',
      db.raw('count(*) as request_count'),
      db.raw('sum(COALESCE(total_tokens, 0)) as total_tokens'),
      db.raw(`sum(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_request_count`),
      db.raw('max(COALESCE(answered_at, terminal_at, updated_at, created_at)) as last_used_at'),
    );
}

export async function listChatConversationRequestUsageBySharedResourceTokenIds(tokenIds: string[]) {
  const usageSummaryQuery = buildChatConversationRequestUsageBySharedResourceTokenIdsQuery(tokenIds);

  if (!usageSummaryQuery) {
    return [] as SharedResourceTokenRequestUsageSummary[];
  }

  await ensureChatConversationTables();

  const rows = await usageSummaryQuery as Array<{
    shared_resource_token_id: string | null;
    request_count: string | number | null;
    completed_request_count: string | number | null;
    total_tokens: string | number | null;
    last_used_at: string | Date | null;
  }>;

  return rows.map((row) => ({
    sharedResourceTokenId: String(row.shared_resource_token_id ?? '').trim(),
    requestCount: Math.max(0, Number(row.request_count ?? 0) || 0),
    completedRequestCount: Math.max(
      0,
      Number(row.completed_request_count ?? 0) || 0,
    ),
    totalTokens: Math.max(0, Number(row.total_tokens ?? 0) || 0),
    lastUsedAt: normalizeDateTimeValue(row.last_used_at),
  }));
}

export async function assignSharedResourceTokenToRequests(sessionId: string, requestIds: string[], sharedResourceTokenId: string) {
  const normalizedSessionId = sessionId.trim();
  const normalizedTokenId = sharedResourceTokenId.trim();
  const normalizedRequestIds = Array.from(new Set(requestIds.map((value) => String(value ?? '').trim()).filter(Boolean)));

  if (!normalizedSessionId || !normalizedTokenId || normalizedRequestIds.length === 0) {
    return 0;
  }

  await ensureChatConversationTables();

  return db(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({ session_id: normalizedSessionId })
    .whereIn('request_id', normalizedRequestIds)
    .update({
      shared_resource_token_id: normalizedTokenId,
      updated_at: db.fn.now(),
    });
}

export async function clearSharedResourceTokenFromRequests(sharedResourceTokenId: string, trx: typeof db = db) {
  const normalizedTokenId = sharedResourceTokenId.trim();

  if (!normalizedTokenId) {
    return 0;
  }

  await ensureChatConversationTables();

  return trx(CHAT_CONVERSATION_REQUEST_TABLE)
    .where({ shared_resource_token_id: normalizedTokenId })
    .update({
      shared_resource_token_id: null,
      updated_at: db.fn.now(),
    });
}