/**
 * Drizzle ORM schema - Multideal (מולטידיל) database
 *
 * All 13 FDS data models + supporting tables.
 * snake_case column names (enforced by drizzle.config.ts casing: 'snake_case').
 * Every timestamp uses { withTimezone: true }.
 * Every enum uses pgEnum.
 *
 * PII columns (phone, email, address, token) are stored as encrypted text via pgcrypto.
 * Blind-index columns provide deterministic lookup without decryption.
 */

import {
  pgTable,
  uuid,
  text,
  boolean,
  integer,
  numeric,
  jsonb,
  timestamp,
  index,
  uniqueIndex,
  customType,
} from 'drizzle-orm/pg-core';
import { sql } from 'drizzle-orm';
import type { CaseId } from '@/server/platform-seams/ids.js';

import {
  llmProviderTypeEnum,
  supportParentTypeEnum,
  supportOpenerRoleEnum,
  returnStatusEnum,
  returnReasonEnum,
  returnLiabilityEnum,
  supportTicketCategoryEnum,
  supportTicketStatusEnum,
  supportPriorityEnum,
  supportCaseCategoryEnum,
  supportCaseStatusEnum,
  caseOfferOutcomeEnum,
  caseOfferByEnum,
  caseOfferStatusEnum,
  caseResolutionExecutorEnum,
  supportMessageAuthorTypeEnum,
  supportMessageVisibilityEnum,
  supportAttachmentAbuseStatusEnum,
  aiInterventionDecisionEnum,
  supportKbCategoryEnum,
  supportKbVisibilityEnum,
} from './enums.js';
import { users, vendors } from './core.js';
import { languages } from './languages.js';
import { deals } from './deal-variants.js';
import { orderLine } from '../../../../node_modules/@platform-modules/commerce-orders/dist/index.js';

// ─── Support System Tables ────────────────────────────────────────────────────

export const supportTickets = pgTable(
  'support_tickets',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    openerId: uuid('opener_id')
      .notNull()
      .references(() => users.id),
    openerRole: supportOpenerRoleEnum('opener_role').notNull(),
    category: supportTicketCategoryEnum('category').notNull(),
    status: supportTicketStatusEnum('status').notNull().default('open'),
    priority: supportPriorityEnum('priority').notNull().default('normal'),
    aiConfidence: numeric('ai_confidence', { precision: 4, scale: 3 }),
    assignedAgentId: uuid('assigned_agent_id').references(() => users.id),
    relatedOrderLineId: uuid('related_order_line_id').references(() => orderLine.id),
    relatedOrderId: uuid('related_order_id'),
    agentDefinitionId: uuid('agent_definition_id').references(() => agentDefinitions.id),
    reopenCount: integer('reopen_count').notNull().default(0),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
    resolvedAt: timestamp('resolved_at', { withTimezone: true }),
    closedAt: timestamp('closed_at', { withTimezone: true }),
    metadata: jsonb('metadata').$type<Record<string, unknown>>().notNull().default({}),
  },
  (t) => [
    index('support_tickets_opener_status_idx').on(t.openerId, t.status),
    index('support_tickets_status_updated_idx').on(t.status, t.updatedAt),
  ],
);

export const transactionCases = pgTable(
  'transaction_cases',
  {
    id: uuid('id').$type<CaseId>().defaultRandom().primaryKey(),
    orderLineId: uuid('order_line_id')
      .notNull()
      .references(() => orderLine.id),
    customerId: uuid('customer_id')
      .notNull()
      .references(() => users.id),
    vendorId: uuid('vendor_id')
      .notNull()
      .references(() => vendors.id),
    category: supportCaseCategoryEnum('category').notNull(),
    status: supportCaseStatusEnum('status').notNull().default('opened'),
    escapeUsed: boolean('escape_used').notNull().default(false),
    vendorWindowHours: integer('vendor_window_hours').notNull(),
    vendorWindowExpiresAt: timestamp('vendor_window_expires_at', { withTimezone: true }),
    slaAiDueAt: timestamp('sla_ai_due_at', { withTimezone: true }),
    slaHumanDueAt: timestamp('sla_human_due_at', { withTimezone: true }),
    autocloseAt: timestamp('autoclose_at', { withTimezone: true }),
    aiConfidence: numeric('ai_confidence', { precision: 4, scale: 3 }),
    assignedAgentId: uuid('assigned_agent_id').references(() => users.id),
    agentDefinitionId: uuid('agent_definition_id').references(() => agentDefinitions.id),
    reopenCount: integer('reopen_count').notNull().default(0),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
    resolvedAt: timestamp('resolved_at', { withTimezone: true }),
    closedAt: timestamp('closed_at', { withTimezone: true }),
    metadata: jsonb('metadata').$type<Record<string, unknown>>().notNull().default({}),
  },
  (t) => [
    index('tx_cases_status_vendor_window_idx').on(t.status, t.vendorWindowExpiresAt),
    index('tx_cases_status_sla_ai_idx').on(t.status, t.slaAiDueAt),
    index('tx_cases_status_sla_human_idx').on(t.status, t.slaHumanDueAt),
    index('tx_cases_status_autoclose_idx').on(t.status, t.autocloseAt),
    uniqueIndex('tx_cases_purchase_open_uniq')
      .on(t.orderLineId)
      .where(sql`status NOT IN ('resolved','closed')`),
  ],
);

export const caseOffers = pgTable(
  'case_offers',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    caseId: uuid('case_id')
      .$type<CaseId>()
      .notNull()
      .references(() => transactionCases.id),
    offeredBy: caseOfferByEnum('offered_by').notNull(),
    outcome: caseOfferOutcomeEnum('outcome').notNull(),
    amountCents: integer('amount_cents'),
    reason: text('reason'),
    status: caseOfferStatusEnum('status').notNull().default('pending'),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    decidedAt: timestamp('decided_at', { withTimezone: true }),
  },
  (t) => [index('case_offers_case_status_idx').on(t.caseId, t.status)],
);

export const caseResolutions = pgTable('case_resolutions', {
  id: uuid('id').defaultRandom().primaryKey(),
  caseId: uuid('case_id')
    .$type<CaseId>()
    .notNull()
    .unique()
    .references(() => transactionCases.id),
  outcome: caseOfferOutcomeEnum('outcome').notNull(),
  amountCents: integer('amount_cents'),
  executedBy: caseResolutionExecutorEnum('executed_by').notNull(),
  providerRefundId: text('provider_refund_id'),
  executedAt: timestamp('executed_at', { withTimezone: true }).notNull().defaultNow(),
});

// ─── Returns / RMA ────────────────────────────────────────────────────────────

export const returns = pgTable(
  'returns',
  {
    id: uuid('id').primaryKey().defaultRandom(),
    orderLineId: uuid('order_line_id')
      .notNull()
      .references(() => orderLine.id),
    buyerId: uuid('buyer_id')
      .notNull()
      .references(() => users.id),
    vendorId: uuid('vendor_id')
      .notNull()
      .references(() => vendors.id),
    dealId: uuid('deal_id')
      .notNull()
      .references(() => deals.id),
    status: returnStatusEnum('status').notNull().default('requested'),
    reason: returnReasonEnum('reason').notNull(),
    reasonNote: text('reason_note'),
    liability: returnLiabilityEnum('liability').notNull(),
    refundAmountAgorot: integer('refund_amount_agorot').notNull(),
    restockingFeeAgorot: integer('restocking_fee_agorot').notNull().default(0),
    shippingReimbursementAgorot: integer('shipping_reimbursement_agorot').notNull().default(0),
    cashRefundAgorot: integer('cash_refund_agorot'),
    creditOverflowAgorot: integer('credit_overflow_agorot').notNull().default(0),
    carrier: text('carrier'),
    trackingNumber: text('tracking_number'),
    trackingEnteredAt: timestamp('tracking_entered_at', { withTimezone: true }),
    receivedAt: timestamp('received_at', { withTimezone: true }),
    vendorRespondBy: timestamp('vendor_respond_by', { withTimezone: true }),
    buyerShipBy: timestamp('buyer_ship_by', { withTimezone: true }),
    vendorInspectBy: timestamp('vendor_inspect_by', { withTimezone: true }),
    providerRefundId: text('provider_refund_id'),
    caseId: uuid('case_id')
      .$type<CaseId | null>()
      .references(() => transactionCases.id),
    metadata: jsonb('metadata').$type<Record<string, unknown>>().notNull().default({}),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
    closedAt: timestamp('closed_at', { withTimezone: true }),
  },
  (t) => [
    index('returns_status_vendor_respond_idx').on(t.status, t.vendorRespondBy),
    index('returns_status_buyer_ship_idx').on(t.status, t.buyerShipBy),
    index('returns_status_vendor_inspect_idx').on(t.status, t.vendorInspectBy),
    index('returns_buyer_idx').on(t.buyerId, t.createdAt),
    index('returns_vendor_idx').on(t.vendorId, t.createdAt),
    uniqueIndex('returns_purchase_open_uniq')
      .on(t.orderLineId)
      .where(sql`status NOT IN ('refunded','denied','cancelled','expired')`),
  ],
);

export const returnEvents = pgTable(
  'return_events',
  {
    id: uuid('id').primaryKey().defaultRandom(),
    returnId: uuid('return_id')
      .notNull()
      .references(() => returns.id, { onDelete: 'cascade' }),
    fromStatus: returnStatusEnum('from_status'),
    toStatus: returnStatusEnum('to_status').notNull(),
    actorType: text('actor_type').notNull(),
    actorId: uuid('actor_id'),
    reason: text('reason'),
    metadata: jsonb('metadata').notNull().default({}),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [index('return_events_return_idx').on(t.returnId, t.createdAt)],
);

// ─── Vendor AI Recommendations ───────────────────────────────────────────────

/** Nightly-generated AI recommendations per vendor (top 3 cached). */
export const vendorRecommendations = pgTable(
  'vendor_recommendations',
  {
    id: uuid('id').primaryKey().defaultRandom(),
    vendorId: uuid('vendor_id')
      .notNull()
      .references(() => vendors.id, { onDelete: 'cascade' }),
    kind: text('kind').notNull(), // 'stock_nudge' | 'pricing_suggestion' | 'schedule_opportunity'
    payload: jsonb('payload').notNull(),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    dismissedAt: timestamp('dismissed_at', { withTimezone: true }),
  },
  (t) => [index('vendor_recommendations_vendor_created_idx').on(t.vendorId, t.createdAt)],
);

export const supportMessages = pgTable(
  'support_messages',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    parentType: supportParentTypeEnum('parent_type').notNull(),
    parentId: uuid('parent_id').notNull(),
    authorType: supportMessageAuthorTypeEnum('author_type').notNull(),
    authorId: uuid('author_id'),
    visibility: supportMessageVisibilityEnum('visibility').notNull().default('public'),
    bodyEncrypted: text('body_encrypted').notNull(),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    editedAt: timestamp('edited_at', { withTimezone: true }),
    deletedAt: timestamp('deleted_at', { withTimezone: true }),
  },
  (t) => [index('support_messages_parent_idx').on(t.parentType, t.parentId, t.createdAt)],
);

export const supportAttachments = pgTable(
  'support_attachments',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    parentType: supportParentTypeEnum('parent_type').notNull(),
    parentId: uuid('parent_id').notNull(),
    messageId: uuid('message_id').references(() => supportMessages.id),
    cfImageId: text('cf_image_id').notNull(),
    variants: jsonb('variants').$type<{ thumb: string; card: string; full: string }>().notNull(),
    mime: text('mime').notNull(),
    sizeBytes: integer('size_bytes').notNull(),
    uploaderId: uuid('uploader_id')
      .notNull()
      .references(() => users.id),
    uploaderRole: supportOpenerRoleEnum('uploader_role').notNull(),
    abuseStatus: supportAttachmentAbuseStatusEnum('abuse_status').notNull().default('pending'),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [index('support_attachments_parent_idx').on(t.parentType, t.parentId)],
);

export const aiInterventions = pgTable(
  'ai_interventions',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    parentType: supportParentTypeEnum('parent_type').notNull(),
    parentId: uuid('parent_id').notNull(),
    agentName: text('agent_name').notNull(),
    agentDefVersion: integer('agent_def_version'),
    toolName: text('tool_name').notNull(),
    inputEncrypted: text('input_encrypted'),
    outputEncrypted: text('output_encrypted'),
    confidence: numeric('confidence', { precision: 4, scale: 3 }),
    decision: aiInterventionDecisionEnum('decision').notNull(),
    tokensIn: integer('tokens_in'),
    tokensOut: integer('tokens_out'),
    latencyMs: integer('latency_ms'),
    costUsd: numeric('cost_usd', { precision: 10, scale: 6 }),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [index('ai_interventions_parent_idx').on(t.parentType, t.parentId, t.createdAt)],
);

const byteaColumn = customType<{ data: Buffer; driverData: Buffer }>({
  dataType() {
    return 'bytea';
  },
});

export const llmProviders = pgTable('llm_providers', {
  id: uuid('id').primaryKey().defaultRandom(),
  slug: text('slug').unique().notNull(),
  name: text('name').notNull(),
  type: llmProviderTypeEnum('type').notNull(),
  baseUrl: text('base_url'),
  apiKeyEnc: byteaColumn('api_key_enc'),
  isActive: boolean('is_active').notNull().default(true),
  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
});
export type LlmProviderRecord = typeof llmProviders.$inferSelect;
export type NewLlmProviderRecord = typeof llmProviders.$inferInsert;

export const llmModelCache = pgTable('llm_model_cache', {
  providerId: uuid('provider_id')
    .primaryKey()
    .references(() => llmProviders.id, { onDelete: 'cascade' }),
  models: jsonb('models')
    .notNull()
    .$type<Array<{ id: string; label: string }>>()
    .default(sql`'[]'::jsonb`),
  fetchedAt: timestamp('fetched_at', { withTimezone: true }).notNull().defaultNow(),
  error: text('error'),
});
export type LlmModelCacheRecord = typeof llmModelCache.$inferSelect;

export const llmQueues = pgTable('llm_queues', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),
  chain: jsonb('chain')
    .notNull()
    .$type<Array<{ llmProviderId: string; model: string }>>()
    .$defaultFn(() => []),
  prompt: text('prompt').notNull().default(''),
  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
  updatedBy: uuid('updated_by').references(() => users.id),
});
export type LlmQueue = typeof llmQueues.$inferSelect;
export type LlmQueueId = 'moderation' | 'translation' | 'support';
export type LlmQueueChainEntry = { llmProviderId: string; model: string };

export const agentDefinitions = pgTable('agent_definitions', {
  id: uuid('id').defaultRandom().primaryKey(),
  slug: text('slug').notNull().unique(),
  name: text('name').notNull(),
  description: text('description').notNull().default(''),
  systemPromptTemplate: text('system_prompt_template').notNull(),
  knowledgeAdapterIds: text('knowledge_adapter_ids').array().notNull().default([]),
  escalationRuleIds: text('escalation_rule_ids').array().notNull().default([]),
  availableDecisions: text('available_decisions').array().notNull().default([]),
  llmChain: jsonb('llm_chain')
    .notNull()
    .$type<{ chain: Array<{ llmProviderId: string; model: string }> }>(),
  slaAiHours: integer('sla_ai_hours').notNull().default(4),
  slaHumanHours: integer('sla_human_hours').notNull().default(24),
  maxCostCents: integer('max_cost_cents').notNull().default(10),
  maxToolCalls: integer('max_tool_calls').notNull().default(12),
  aiConfidenceThreshold: numeric('ai_confidence_threshold', { precision: 4, scale: 3 })
    .notNull()
    .default('0.700'),
  autoRefundCapCents: integer('auto_refund_cap_cents').notNull().default(0),
  isActive: boolean('is_active').notNull().default(true),
  version: integer('version').notNull().default(1),
  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
});
export type AgentDefinition = typeof agentDefinitions.$inferSelect;
export type NewAgentDefinition = typeof agentDefinitions.$inferInsert;

export const agentDefinitionVersions = pgTable(
  'agent_definition_versions',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    definitionId: uuid('definition_id')
      .notNull()
      .references(() => agentDefinitions.id),
    version: integer('version').notNull(),
    snapshot: jsonb('snapshot').notNull(),
    changedBy: uuid('changed_by').references(() => users.id),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [uniqueIndex('agent_def_versions_def_ver_idx').on(t.definitionId, t.version)],
);
export type AgentDefinitionVersion = typeof agentDefinitionVersions.$inferSelect;

const vectorColumn = customType<{ data: number[]; driverData: string }>({
  dataType() {
    return 'vector(1024)';
  },
  toDriver(val) {
    return `[${val.join(',')}]`;
  },
  fromDriver(val) {
    const s = val as string;
    return s.slice(1, -1).split(',').map(Number);
  },
});

// kb-embedding cron is a planned follow-up; kb-search adapter uses FTS.
export const supportKbEmbeddings = pgTable(
  'support_kb_embeddings',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    articleId: uuid('article_id')
      .notNull()
      .references(() => supportKbArticles.id, { onDelete: 'cascade' }),
    chunkIndex: integer('chunk_index').notNull().default(0),
    chunkText: text('chunk_text').notNull(),
    embedding: vectorColumn('embedding').notNull(),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [uniqueIndex('support_kb_embeddings_article_chunk_idx').on(t.articleId, t.chunkIndex)],
);
export type SupportKbEmbedding = typeof supportKbEmbeddings.$inferSelect;
export type NewSupportKbEmbedding = typeof supportKbEmbeddings.$inferInsert;

export const supportKbArticles = pgTable(
  'support_kb_articles',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    // Canonical slug = first-authored locale's slug (first-locale-wins, locked at creation).
    // Locale-specific slugs live in support_kb_article_translations.
    slug: text('slug').notNull(),
    category: supportKbCategoryEnum('category').notNull(),
    tags: text('tags').array().notNull().default([]),
    visibility: supportKbVisibilityEnum('visibility').notNull().default('public'),
    isActive: boolean('is_active').notNull().default(true),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
    updatedBy: uuid('updated_by').references(() => users.id),
  },
  (t) => [
    uniqueIndex('support_kb_articles_slug_idx').on(t.slug),
    index('support_kb_articles_category_idx').on(t.category),
    index('support_kb_articles_active_idx').on(t.isActive),
  ],
);
export type SupportKbArticle = typeof supportKbArticles.$inferSelect;
export type NewSupportKbArticle = typeof supportKbArticles.$inferInsert;

// ─── KB Article Translations (sidecar — localized content) ────────────────────

export const supportKbArticleTranslations = pgTable(
  'support_kb_article_translations',
  {
    id: uuid('id').primaryKey().defaultRandom(),
    articleId: uuid('article_id')
      .notNull()
      .references(() => supportKbArticles.id, { onDelete: 'cascade' }),
    locale: text('locale')
      .notNull()
      .references(() => languages.code),
    slug: text('slug').notNull(),
    title: text('title').notNull(),
    bodyMd: text('body_md').notNull(),
    slugManualOverride: boolean('slug_manual_override').notNull().default(true),
    titleManualOverride: boolean('title_manual_override').notNull().default(true),
    bodyMdManualOverride: boolean('body_md_manual_override').notNull().default(true),
    modelId: text('model_id'),
    status: text('status').notNull().default('OK'),
    translatedAt: timestamp('translated_at', { withTimezone: true }),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [
    uniqueIndex('support_kb_article_translations_article_locale_idx').on(t.articleId, t.locale),
    uniqueIndex('support_kb_article_translations_locale_slug_idx').on(t.locale, t.slug),
    index('support_kb_article_translations_locale_status_idx').on(t.locale, t.status),
  ],
);
export type SupportKbArticleTranslation = typeof supportKbArticleTranslations.$inferSelect;
export type NewSupportKbArticleTranslation = typeof supportKbArticleTranslations.$inferInsert;

export const supportStateTransitions = pgTable(
  'support_state_transitions',
  {
    id: uuid('id').defaultRandom().primaryKey(),
    parentType: supportParentTypeEnum('parent_type').notNull(),
    parentId: uuid('parent_id').notNull(),
    fromState: text('from_state').notNull(),
    toState: text('to_state').notNull(),
    actorType: text('actor_type').notNull(),
    actorId: uuid('actor_id'),
    reason: text('reason'),
    metadata: jsonb('metadata').$type<Record<string, unknown>>().notNull().default({}),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [index('support_state_transitions_parent_idx').on(t.parentType, t.parentId, t.createdAt)],
);

// ─── Support System Relations ─────────────────────────────────────────────────

import { relations } from 'drizzle-orm';

export const supportTicketsRelations = relations(supportTickets, ({ one }) => ({
  opener: one(users, {
    fields: [supportTickets.openerId],
    references: [users.id],
    relationName: 'ticket_opener',
  }),
  assignedAgent: one(users, {
    fields: [supportTickets.assignedAgentId],
    references: [users.id],
    relationName: 'ticket_agent',
  }),
  relatedOrderLine: one(orderLine, {
    fields: [supportTickets.relatedOrderLineId],
    references: [orderLine.id],
  }),
}));

export const transactionCasesRelations = relations(transactionCases, ({ one, many }) => ({
  orderLine: one(orderLine, { fields: [transactionCases.orderLineId], references: [orderLine.id] }),
  customer: one(users, {
    fields: [transactionCases.customerId],
    references: [users.id],
    relationName: 'case_customer',
  }),
  vendor: one(vendors, { fields: [transactionCases.vendorId], references: [vendors.id] }),
  offers: many(caseOffers),
  resolution: one(caseResolutions, {
    fields: [transactionCases.id],
    references: [caseResolutions.caseId],
    relationName: 'case_resolution',
  }),
}));

export const caseOffersRelations = relations(caseOffers, ({ one }) => ({
  case: one(transactionCases, { fields: [caseOffers.caseId], references: [transactionCases.id] }),
}));

export const caseResolutionsRelations = relations(caseResolutions, ({ one }) => ({
  case: one(transactionCases, {
    fields: [caseResolutions.caseId],
    references: [transactionCases.id],
    relationName: 'case_resolution',
  }),
}));

export const supportMessagesRelations = relations(supportMessages, ({ many }) => ({
  attachments: many(supportAttachments),
}));

export const supportAttachmentsRelations = relations(supportAttachments, ({ one }) => ({
  message: one(supportMessages, {
    fields: [supportAttachments.messageId],
    references: [supportMessages.id],
  }),
  uploader: one(users, { fields: [supportAttachments.uploaderId], references: [users.id] }),
}));