Scheduling System

export async function proposeInitialTimeSlot(params: {
  today: Date;
}): Promise<string> {
  const { today } = params;
  const minDate = addDays(today, 2);
  const minDateStr = formatDateFriendly(minDate);
  const fallback = formatDateFriendly(addDays(today, 3)) + " at 7pm";

  const { text } = await generateText({
    model: "mistral/mistral-medium",
    prompt: `You are scheduling a first date for a dating app.

Today is ${todayStr}.
The earliest allowed date is ${minDateStr} (must be at least 2 full days from today).

Suggest ONE specific date and time for a first date. Pick a weekend evening or weekday evening after work — something that naturally fits a casual first date.

Rules:
- The date must be on or after ${minDateStr}.
- Return ONLY the date/time string. No explanation, no quotes.
- Format example: "Saturday, March 8th at 7pm"`,
    maxOutputTokens: 30,
  });

  const cleaned = text.trim().replace(/^["']|["']$/g, "");
  if (cleaned.length > 5 && cleaned.length < 80) {
    return cleaned;
  }
  return fallback;
}

export interface SchedulingAnalysis {
  accepted: boolean;               // User confirmed the proposed time
  proposedAlternative: string | null;  // User suggested different time
  tooSoon: boolean;                // Proposed date is less than 2 days away
  needsClarification: boolean;     // Intent is ambiguous
  clarificationQuestion: string | null;  // Follow-up to ask user
}

const analysis = await analyzeSchedulingResponse({
  conversation: [
    { role: "assistant", content: "does Saturday at 7pm work?" },
    { role: "user", content: "can we do Friday instead?" },
  ],
  proposedSlot: "Saturday, March 8th at 7pm",
  today: new Date(),
});

// Returns:
// {
//   accepted: false,
//   proposedAlternative: "Friday, March 7th at 7pm",
//   tooSoon: false,
//   needsClarification: false,
//   clarificationQuestion: null
// }

let tooSoon = false;
if (proposedDateYMD) {
  const minDate = addDays(today, 2);
  const minYMD = minDate.toISOString().slice(0, 10); // "YYYY-MM-DD"
  tooSoon = proposedDateYMD < minYMD;
}

// If too soon, reject and ask for later date:
if (analysis.tooSoon && analysis.proposedAlternative) {
  await sendSms(
    senderPhone,
    `that's a bit soon — can you pick something after ${minDateStr}?`
  );
  return; // Don't advance phase
}

// Load all prior messages for this date
const pastMessages = await db.tpoMessage.findMany({
  where: {
    dateId: activeDate.id,
    OR: [{ fromPhone: senderPhone }, { toPhone: senderPhone }],
  },
  orderBy: { createdAt: "asc" },
});

// Build conversation: past + current message
const conversation = [
  ...pastMessages.map((msg) => ({
    role: msg.fromPhone === "system" ? "assistant" : "user",
    content: msg.body,
  })),
  { role: "user", content: messageBody },
];

const isUserA = activeDate.userA.phoneNumber === senderPhone;
const phase = activeDate.schedulingPhase;

const isExpectedActor =
  (isUserA &&
    (phase === "WAITING_FOR_A_REPLY" || phase === "WAITING_FOR_A_ALTERNATIVE")) ||
  (!isUserA &&
    (phase === "WAITING_FOR_B_REPLY" || phase === "WAITING_FOR_B_ALTERNATIVE"));

if (!isExpectedActor) {
  // Log message but don't advance state
  await sendSms(senderPhone, "just checking with your match — hang tight!");
  return;
}

export async function suggestDateSpot(params: {
  userAProfile: object | null;
  userBProfile: object | null;
  city: string;
  agreedTime: string;
}): Promise<string> {
  const { text } = await generateText({
    model: "mistral/mistral-medium",
    prompt: `You are suggesting a first date venue for two people on a dating app.

City: ${city}
Date/time: ${agreedTime}

Person A's vibe: ${profileSummary(userAProfile)}
Person B's vibe: ${profileSummary(userBProfile)}

Suggest ONE real, specific establishment in ${city} that exists in real life and matches both people's energy.

Rules:
- Under 180 characters total
- Must include the real venue name and a neighborhood/area
- Do NOT suggest a generic vibe-only place (e.g., "a cozy bistro")
- If uncertain about niche spots, pick a widely known real place in ${city}
- End with a short reason it fits them both
- Format: "[real venue name] in [neighborhood/area], [city] — [why it fits you both]"`,
    maxOutputTokens: 80,
  });

  return text.trim();
}

function profileSummary(profile: object | null): string {
  const relevant = {
    hobbies: about?.hobbies,
    activityLevel: about?.activityLevel,
    fridayNight: about?.fridayNight,
    drinking: about?.drinking,
    planningStyle: about?.planningStyle,
    lookingForNow: about?.lookingForNow,
    mustHaves: prefs?.mustHaves,
    datePlanningPreference: prefs?.datePlanningPreference,
  };
  return JSON.stringify(relevant);
}

function isSpecificVenueSuggestion(value: string): boolean {
  // Must include "—" separator and "in" for location
  if (!trimmed.includes("—") || !/\sin\s/i.test(venue)) return false;

  // Reject generic phrases
  const genericPhrases = [
    "a cozy", "a casual", "a lively", "a rooftop",
    "a coffee shop", "a wine bar", "a cocktail spot"
  ];
  if (genericPhrases.some((phrase) => lowerVenue.includes(phrase))) return false;

  // Require at least one capitalized token (proper noun)
  return /\b[A-Z][a-zA-Z0-9&'.-]*\b/.test(venue);
}

if (analysis.accepted) {
  const venue = await suggestDateSpot({
    userAProfile: activeDate.userA.structuredProfile,
    userBProfile: activeDate.userB.structuredProfile,
    city: activeDate.userA.city ?? activeDate.userB.city ?? "your city",
    agreedTime,
  });

  const confirmation = `you're both confirmed for ${agreedTime}!

date spot: ${venue}

any messages to this number now go straight to your match. have fun!`;

  await db.tpoDate.update({
    where: { id: activeDate.id },
    data: {
      schedulingPhase: "AGREED",
      agreedTime,
      suggestedPlace: venue,
      portalEnabled: true,  // Enable message relay
    },
  });

  // Send to both users
  await sendSms(activeDate.userA.phoneNumber, confirmation);
  await sendSms(activeDate.userB.phoneNumber, confirmation);
}