import { eq } from 'drizzle-orm';
import { asCaseId } from '@/server/platform-seams/ids.js';
import {
  deals,
  supportTickets,
  transactionCases,
  vendors,
  orderLine,
  dealSkus,
} from '@/server/db/schema';
import type { AdapterContext } from '@/server/support/types';

export interface ResolvedSupportContext {
  /** orderLine.id — null when no related order line can be resolved */
  purchaseId: string | null;
  dealId: string | null;
  vendorId: string | null;
}

export async function resolveSupportContext(ctx: AdapterContext): Promise<ResolvedSupportContext> {
  if (ctx.parentType === 'ticket') {
    const [ticket] = await ctx.db
      .select({ relatedOrderLineId: supportTickets.relatedOrderLineId })
      .from(supportTickets)
      .where(eq(supportTickets.id, ctx.parentId))
      .limit(1);

    if (!ticket?.relatedOrderLineId) {
      return { purchaseId: null, dealId: null, vendorId: null };
    }

    // Resolve orderLine and its deal/vendor
    const [lineRow] = await ctx.db
      .select({
        id: orderLine.id,
        dealId: dealSkus.dealId,
        vendorId: orderLine.vendorId,
      })
      .from(orderLine)
      .innerJoin(dealSkus, eq(orderLine.variantId, dealSkus.id))
      .where(eq(orderLine.id, ticket.relatedOrderLineId))
      .limit(1);

    return {
      purchaseId: lineRow?.id ?? null,
      dealId: lineRow?.dealId ?? null,
      vendorId: lineRow?.vendorId ?? null,
    };
  }

  const [caseRow] = await ctx.db
    .select({
      orderLineId: transactionCases.orderLineId,
      vendorId: transactionCases.vendorId,
    })
    .from(transactionCases)
    .where(eq(transactionCases.id, asCaseId(ctx.parentId)))
    .limit(1);

  if (!caseRow) {
    return { purchaseId: null, dealId: null, vendorId: null };
  }

  if (!caseRow.orderLineId) {
    return { purchaseId: null, dealId: null, vendorId: caseRow.vendorId };
  }

  const [skuRow] = await ctx.db
    .select({ dealId: dealSkus.dealId })
    .from(orderLine)
    .innerJoin(dealSkus, eq(orderLine.variantId, dealSkus.id))
    .where(eq(orderLine.id, caseRow.orderLineId))
    .limit(1);

  return {
    purchaseId: caseRow.orderLineId,
    dealId: skuRow?.dealId ?? null,
    vendorId: caseRow.vendorId,
  };
}

export async function resolveVendorId(ctx: AdapterContext): Promise<string | null> {
  const resolved = await resolveSupportContext(ctx);
  return resolved.vendorId;
}

export async function resolvePurchaseId(ctx: AdapterContext): Promise<string | null> {
  const resolved = await resolveSupportContext(ctx);
  return resolved.purchaseId;
}

export async function loadDealSummary(
  ctx: AdapterContext,
  dealId: string,
): Promise<{
  title: string;
  vendorName: string;
  dealState: string;
  returnWindowDays: number;
} | null> {
  const [row] = await ctx.db
    .select({
      title: deals.title,
      dealState: deals.dealState,
      returnWindowDays: deals.returnWindowDays,
      vendorName: vendors.displayName,
    })
    .from(deals)
    .innerJoin(vendors, eq(deals.vendorId, vendors.id))
    .where(eq(deals.id, dealId))
    .limit(1);

  return row ?? null;
}