/**
 * Activity feed query helpers — activity-timeline (wave-12).
 *
 * Re-exports the same-transaction writer helpers from the activities package
 * and adds soft-delete helpers for note activities.
 * Route files import from '@zync/db/queries'.
 */
export {
  appendInvoiceActivity,
  appendProjectActivity,
  appendCustomerActivity,
  appendVendorActivity,
} from '../activities/writers'

import { and, eq } from 'drizzle-orm'
import type { Db } from '../client'
import { customerActivities, invoiceActivities, projectActivities, vendorActivities } from '../schema'

// ── Customer activity soft-delete ─────────────────────────────────────────────

export interface ActivityNoteRow {
  id: string
  actorId: string | null
  eventType: string
  createdAt: Date
  deletedAt: Date | null
}

/**
 * Load a single customer activity row for delete-eligibility checks.
 */
export async function getCustomerActivityNote(
  db: Db,
  tenantId: string,
  customerId: string,
  activityId: string,
): Promise<ActivityNoteRow | null> {
  const [row] = await db
    .select({
      id: customerActivities.id,
      actorId: customerActivities.actorId,
      eventType: customerActivities.eventType,
      createdAt: customerActivities.createdAt,
      deletedAt: customerActivities.deletedAt,
    })
    .from(customerActivities)
    .where(
      and(
        eq(customerActivities.tenantId, tenantId),
        eq(customerActivities.customerId, customerId),
        eq(customerActivities.id, activityId),
      ),
    )
    .limit(1)
  return row ?? null
}

/**
 * Soft-delete a customer activity by setting deletedAt.
 */
export async function softDeleteCustomerActivity(
  db: Db,
  tenantId: string,
  activityId: string,
): Promise<void> {
  await db
    .update(customerActivities)
    .set({ deletedAt: new Date() })
    .where(and(eq(customerActivities.tenantId, tenantId), eq(customerActivities.id, activityId)))
}

// ── Invoice activity soft-delete ──────────────────────────────────────────────

/**
 * Load a single invoice activity row for delete-eligibility checks.
 */
export async function getInvoiceActivityNote(
  db: Db,
  tenantId: string,
  invoiceId: string,
  activityId: string,
): Promise<ActivityNoteRow | null> {
  const [row] = await db
    .select({
      id: invoiceActivities.id,
      actorId: invoiceActivities.actorId,
      eventType: invoiceActivities.eventType,
      createdAt: invoiceActivities.createdAt,
      deletedAt: invoiceActivities.deletedAt,
    })
    .from(invoiceActivities)
    .where(
      and(
        eq(invoiceActivities.tenantId, tenantId),
        eq(invoiceActivities.invoiceId, invoiceId),
        eq(invoiceActivities.id, activityId),
      ),
    )
    .limit(1)
  return row ?? null
}

/**
 * Soft-delete an invoice activity by setting deletedAt.
 */
export async function softDeleteInvoiceActivity(
  db: Db,
  tenantId: string,
  activityId: string,
): Promise<void> {
  await db
    .update(invoiceActivities)
    .set({ deletedAt: new Date() })
    .where(and(eq(invoiceActivities.tenantId, tenantId), eq(invoiceActivities.id, activityId)))
}

// ── Project activity soft-delete ──────────────────────────────────────────────

/**
 * Load a single project activity row for delete-eligibility checks.
 */
export async function getProjectActivityNote(
  db: Db,
  tenantId: string,
  projectId: string,
  activityId: string,
): Promise<ActivityNoteRow | null> {
  const [row] = await db
    .select({
      id: projectActivities.id,
      actorId: projectActivities.actorId,
      eventType: projectActivities.eventType,
      createdAt: projectActivities.createdAt,
      deletedAt: projectActivities.deletedAt,
    })
    .from(projectActivities)
    .where(
      and(
        eq(projectActivities.tenantId, tenantId),
        eq(projectActivities.projectId, projectId),
        eq(projectActivities.id, activityId),
      ),
    )
    .limit(1)
  return row ?? null
}

/**
 * Soft-delete a project activity by setting deletedAt.
 */
export async function softDeleteProjectActivity(
  db: Db,
  tenantId: string,
  activityId: string,
): Promise<void> {
  await db
    .update(projectActivities)
    .set({ deletedAt: new Date() })
    .where(and(eq(projectActivities.tenantId, tenantId), eq(projectActivities.id, activityId)))
}

// ── Vendor activity soft-delete ───────────────────────────────────────────────

/**
 * Load a single vendor activity row for delete-eligibility checks.
 */
export async function getVendorActivityNote(
  db: Db,
  tenantId: string,
  vendorId: string,
  activityId: string,
): Promise<ActivityNoteRow | null> {
  const [row] = await db
    .select({
      id: vendorActivities.id,
      actorId: vendorActivities.actorId,
      eventType: vendorActivities.eventType,
      createdAt: vendorActivities.createdAt,
      deletedAt: vendorActivities.deletedAt,
    })
    .from(vendorActivities)
    .where(
      and(
        eq(vendorActivities.tenantId, tenantId),
        eq(vendorActivities.vendorId, vendorId),
        eq(vendorActivities.id, activityId),
      ),
    )
    .limit(1)
  return row ?? null
}

/**
 * Soft-delete a vendor activity by setting deletedAt.
 */
export async function softDeleteVendorActivity(
  db: Db,
  tenantId: string,
  activityId: string,
): Promise<void> {
  await db
    .update(vendorActivities)
    .set({ deletedAt: new Date() })
    .where(and(eq(vendorActivities.tenantId, tenantId), eq(vendorActivities.id, activityId)))
}