import type { AdminRequestRow, SubmissionStatus } from "@/types/admin-submission";
import connectDB from "@/lib/mongodb";
import SummitRequest, { type ISummitRequest } from "@/models/SummitRequest";

function docToRow(doc: ISummitRequest): AdminRequestRow {
  return {
    id: doc.publicId,
    submittedAt: doc.submittedAt,
    displayDate: doc.displayDate,
    fullName: doc.fullName,
    jobTitle: doc.jobTitle,
    company: doc.company,
    segment: doc.segment,
    email: doc.email,
    phone: doc.phone,
    status: doc.status,
    notes: doc.notes,
    source: doc.source,
    // Payment fields
    paymentStatus: doc.paymentStatus,
    paypalOrderId: doc.paypalOrderId,
    paypalCaptureId: doc.paypalCaptureId,
    paymentAmount: doc.paymentAmount,
    paymentCurrency: doc.paymentCurrency,
    paymentCompletedAt: doc.paymentCompletedAt?.toISOString(),
  };
}

export async function listRequestsSorted(): Promise<AdminRequestRow[]> {
  await connectDB();
  const docs = await SummitRequest.find()
    .sort({ submittedAt: -1, updatedAt: -1 })
    .lean<ISummitRequest[]>();
  return docs.map(docToRow);
}

export async function createSummitRequest(row: AdminRequestRow): Promise<void> {
  await connectDB();
  await SummitRequest.create({
    publicId: row.id,
    submittedAt: row.submittedAt,
    displayDate: row.displayDate,
    fullName: row.fullName,
    jobTitle: row.jobTitle,
    company: row.company,
    segment: row.segment,
    email: row.email,
    phone: row.phone,
    status: row.status,
    notes: row.notes,
    source: row.source,
  });
}

export async function updateSummitRequestStatus(publicId: string, status: SubmissionStatus): Promise<void> {
  await connectDB();
  const updated = await SummitRequest.findOneAndUpdate({ publicId }, { $set: { status } }, { new: true });
  if (!updated) {
    throw new Error(`Request not found: ${publicId}`);
  }
}

export async function createRegistrationWithPayment(
  row: AdminRequestRow,
  paypalOrderId: string
): Promise<void> {
  await connectDB();
  await SummitRequest.create({
    publicId: row.id,
    submittedAt: row.submittedAt,
    displayDate: row.displayDate,
    fullName: row.fullName,
    jobTitle: row.jobTitle,
    company: row.company,
    segment: row.segment,
    email: row.email,
    phone: row.phone,
    status: row.status,
    notes: row.notes,
    source: row.source,
    paymentStatus: "payment_pending",
    paypalOrderId,
    paymentAmount: 120,
    paymentCurrency: "USD",
  });
}

export async function markPaymentPaid(
  paypalOrderId: string,
  captureId: string
): Promise<void> {
  await connectDB();
  const updated = await SummitRequest.findOneAndUpdate(
    { paypalOrderId, paymentStatus: { $ne: "paid" } },
    {
      $set: {
        paymentStatus: "paid",
        paypalCaptureId: captureId,
        paymentCompletedAt: new Date(),
      },
    },
    { new: true }
  );
  if (!updated) {
    // Either not found or already paid — both are acceptable (idempotent)
    console.log(`markPaymentPaid: no update for orderId=${paypalOrderId} (not found or already paid)`);
  }
}

export async function markPaymentCancelled(paypalOrderId: string): Promise<void> {
  await connectDB();
  await SummitRequest.findOneAndUpdate(
    { paypalOrderId },
    { $set: { paymentStatus: "payment_cancelled" } },
    { new: true }
  );
}

export async function findByPaypalOrderId(
  paypalOrderId: string
): Promise<ISummitRequest | null> {
  await connectDB();
  return SummitRequest.findOne({ paypalOrderId }).lean<ISummitRequest>();
}