const webhookSecret = process.env.NYLAS_WEBHOOK_SECRET;
const signature = request.headers.get("x-nylas-signature");
const body = await request.text();

if (!webhookSecret) {
  console.error("NYLAS_WEBHOOK_SECRET is not set");
  return NextResponse.json(
    { error: "Server misconfiguration" },
    { status: 500 }
  );
}

// Verify signature
const expectedSignature = crypto
  .createHmac("sha256", webhookSecret)
  .update(body)
  .digest("hex");

if (signature !== expectedSignature) {
  console.warn("Invalid Nylas webhook signature");
  return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
}

// Parse and handle the event
let event: NylasWebhookPayload;
try {
  event = JSON.parse(body);
} catch (e) {
  return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}

// Handle message.created events
if (
  event.type === "message.created" &&
  event.data?.object?.grant_id &&
  event.data?.object?.id
) {
  const nylasMessage = event.data.object;
  const grantId = nylasMessage.grant_id;
  const messageId = nylasMessage.id;

  try {
    // 1. Extract email content for analysis
    const plainText =
      nylasMessage.body_text ||
      (nylasMessage.body ? stripHtml(nylasMessage.body) : "");

export async function shouldProcessEmail(emailText: string): Promise<{
  shouldProcess: boolean;
  reason?: string;
  classification?: any;
}> {
  try {
    if (!emailText || emailText.trim().length === 0) {
      return {
        shouldProcess: false,
        reason: "Empty email content",
      };
    }

    // Classify the email content using AI
    const classification = await classifyAndExtract(emailText);

    // Filter out non-real estate emails
    if (classification.intent === "not_interested") {
      return {
        shouldProcess: false,
        reason: "Email classified as 'not_interested'",
        classification,
      };
    }

    if (classification.intent === "other") {
      return {
        shouldProcess: false,
        reason: "Email classified as 'other' (non-real estate)",
        classification,
      };
    }

    // Only process real estate related intents
    const validIntents = [
      "initial_inquiry",
      "price_question",
      "showing_request",
      "follow_up",
    ];
    if (!validIntents.includes(classification.intent)) {
      return {
        shouldProcess: false,
        reason: `Email intent '${classification.intent}' not in valid intents`,
        classification,
      };
    }

    return {
      shouldProcess: true,
      classification,
    };
  } catch (error) {
    console.error("🔴 Error in initial email filtering:", error);
    // Default to not processing if there's an error
    return {
      shouldProcess: false,
      reason: "Error during email analysis",
    };
  }
}

export async function classifyAndExtract(
  text: string
): Promise<ClassificationResult> {
  try {
    // Validate input
    if (!text || typeof text !== "string") {
      throw new Error(
        `Invalid input: text must be a non-empty string, got ${typeof text}`
      );
    }

    // Validate API key
    if (!process.env.GOOGLE_AI_API_KEY) {
      throw new Error("GOOGLE_AI_API_KEY environment variable is not set");
    }

    const classificationToolDeclaration: FunctionDeclaration = {
      name: "classify_email_intent_and_entities",
      parameters: {
        type: Type.OBJECT,
        description:
          "Classifies the intent of an email and extracts key entities.",
        properties: {
          intent: {
            type: Type.STRING,
            enum: [...INTENTS],
            description: "The primary intent of the email.",
          },
          entities: {
            type: Type.ARRAY,
            items: {
              type: Type.OBJECT,
              properties: {
                type: {
                  type: Type.STRING,
                  enum: [...ENTITIES],
                  description:
                    "The type of the extracted entity (e.g., 'date', 'location').",
                },
                value: {
                  type: Type.STRING,
                  description: "The extracted value of the entity.",
                },
              },
              required: ["type", "value"],
            },
            description: "A list of all entities found in the email.",
          },
          confidence: {
            type: Type.NUMBER,
            description:
              "A confidence score from 0.0 to 1.0 about the classification.",
          },
        },
        required: ["intent", "entities", "confidence"],
      },
    };

    const response = await ai.models.generateContent({
      model: "gemini-2.5-flash",
      contents: [
        {
          role: "user",
          parts: [
            {
              text: `You are an expert AI assistant for a real estate business. Analyze this email and classify the user's intent and extract key entities.

IMPORTANT: Only classify as real estate related intents if the email is clearly about real estate services (buying, selling, renting, investing in property). 

- "other" = Non-real estate emails (newsletters, spam, personal emails, business unrelated to real estate)
- "not_interested" = People explicitly saying they don't want to be contacted or are unsubscribing
- "initial_inquiry" = First contact about real estate services
- "price_question" = Questions about property prices, values, or costs
- "showing_request" = Requests to view properties or schedule appointments
- "follow_up" = Follow-up questions about previous real estate discussions

Email to analyze:
${text.slice(0, 4000)}`,
            },
          ],
        },
      ],
      config: {
        toolConfig: {
          functionCallingConfig: {
            mode: FunctionCallingConfigMode.ANY,
            allowedFunctionNames: ["classify_email_intent_and_entities"],
          },
        },
        tools: [{ functionDeclarations: [classificationToolDeclaration] }],
      },
    });

    const functionCalls = response.functionCalls;
    if (!functionCalls || !functionCalls[0]?.args) {
      console.error("🔴 AI analysis failed to return a valid function call.");
      console.error("Response:", JSON.stringify(response, null, 2));
      return { intent: "other", entities: [], confidence: 0.3 };
    }

    const args = functionCalls[0].args as {
      intent: Intent;
      entities: ExtractedEntity[];
      confidence: number;
    };

    // Validate the response
    if (!args.intent || !INTENTS.includes(args.intent)) {
      console.error("🔴 AI returned invalid intent:", args.intent);
      return { intent: "other", entities: [], confidence: 0.3 };
    }

    return {
      intent: args.intent || "other",
      entities: args.entities || [],
      confidence: args.confidence || 0.5,
    };
  } catch (error) {
    console.error("🔴 Error in classifyAndExtract:", error);

    // Provide more context about the error
    if (error instanceof Error) {
      if (error.message.includes("Could not load the default credentials")) {
        console.error(
          "🔴 Google AI authentication error: Please check GOOGLE_AI_API_KEY environment variable"
        );
      } else if (error.message.includes("API key")) {
        console.error(
          "🔴 Google AI API key error: Please verify your API key is valid"
        );
      } else if (
        error.message.includes("quota") ||
        error.message.includes("rate limit")
      ) {
        console.error(
          "🔴 Google AI quota/rate limit error: Please check your usage limits"
        );
      }
    }

    // Return a default error state
    return { intent: "other", entities: [], confidence: 0.0 };
  }
}

const fromEmail = nylasMessage.from?.[0]?.email;
const toEmail = nylasMessage.to?.[0]?.email;

if (!fromEmail || !toEmail) {
  console.error("🔴 Missing email addresses in message");
  return NextResponse.json(
    { error: "Invalid message format" },
    { status: 400 }
  );
}

const { data: channel, error: channelError } = await supabaseAdmin
  .from("channels")
  .select("*")
  .eq("identifier", toEmail)
  .single();

if (channelError || !channel) {
  console.error(`🔴 No channel found for Nylas account ${grantId}`);
  return NextResponse.json(
    { error: "Channel not found" },
    { status: 404 }
  );
}

const { data: channelConfig } = await supabaseAdmin
  .from("channel_configurations")
  .select("test_mode_enabled, test_mode_allowed_emails")
  .eq("channel_id", channel.id)
  .single();

// Check test mode configuration
if (channelConfig?.test_mode_enabled) {
  const allowedEmails =
    channelConfig.test_mode_allowed_emails
      ?.split("\n")
      .map((email: string) => email.trim())
      .filter((email: string) => email.length > 0) || [];

  if (!allowedEmails.includes(fromEmail)) {
    console.log(
      `🔵 Skipping email from ${fromEmail} - test mode active, not in allowed list: ${allowedEmails.join(", ")}`
    );
    return NextResponse.json(
      {
        received: true,
        skipped: true,
        reason: `Test mode - only processing emails from: ${allowedEmails.join(", ")}`,
      },
      { status: 200 }
    );
  }
}

let contactId: string;
const { data: existingContact } = await supabaseAdmin
  .from("contacts")
  .select("id")
  .eq("org_id", channel.org_id)
  .eq("email", fromEmail)
  .single();

if (existingContact) {
  contactId = existingContact.id;
} else {
  const { data: newContact, error: contactError } = await supabaseAdmin
    .from("contacts")
    .insert({
      org_id: channel.org_id,
      email: fromEmail,
      name: nylasMessage.from?.[0]?.name || null,
    })
    .select("id")
    .single();

  if (contactError || !newContact) {
    console.error("🔴 Failed to create contact:", contactError);
    return NextResponse.json(
      { error: "Failed to create contact" },
      { status: 500 }
    );
  }
  contactId = newContact.id;
}

let leadId: string;
const { data: existingLead } = await supabaseAdmin
  .from("leads")
  .select("id")
  .eq("channel_id", channel.id)
  .eq("contact_id", contactId)
  .single();

if (existingLead) {
  leadId = existingLead.id;
} else {
  const { data: newLead, error: leadError } = await supabaseAdmin
    .from("leads")
    .insert({
      org_id: channel.org_id,
      channel_id: channel.id,
      contact_id: contactId,
      source: "email",
      status: "new",
    })
    .select("id")
    .single();

  if (leadError || !newLead) {
    console.error("🔴 Failed to create lead:", leadError);
    return NextResponse.json(
      { error: "Failed to create lead" },
      { status: 500 }
    );
  }
  leadId = newLead.id;
}

let conversationId: string;
const { data: existingConversation } = await supabaseAdmin
  .from("conversations")
  .select("id")
  .eq("lead_id", leadId)
  .single();

if (existingConversation) {
  conversationId = existingConversation.id;
} else {
  const { data: newConversation, error: conversationError } =
    await supabaseAdmin
      .from("conversations")
      .insert({
        lead_id: leadId,
        org_id: channel.org_id,
        channel_id: channel.id,
        current_state: "new",
      })
      .select("id")
      .single();

  if (conversationError || !newConversation) {
    console.error("🔴 Failed to create conversation:", conversationError);
    return NextResponse.json(
      { error: "Failed to create conversation" },
      { status: 500 }
    );
  }
  conversationId = newConversation.id;
}

const { data: savedMessage, error: messageError } = await supabaseAdmin
  .from("messages")
  .insert({
    conversation_id: conversationId,
    direction: "inbound",
    subject: nylasMessage.subject || "",
    body_text: plainText,
    body_html: nylasMessage.body || "",
    message_id: nylasMessage.id,
    in_reply_to: nylasMessage.in_reply_to || null,
    raw_payload: nylasMessage,
  })
  .select("id")
  .single();

if (messageError || !savedMessage) {
  console.error("🔴 Failed to save message:", messageError);
  return NextResponse.json(
    { error: "Failed to save message" },
    { status: 500 }
  );
}

try {
  await processConversationWithChannelConfiguration({ conversationId });
}

export async function processConversationWithChannelConfiguration({
  conversationId,
}: ChannelConfigurationProcessorOptions) {
  try {
    // 1. Load conversation context
    const { data: conversation, error: convError } = await supabaseAdmin
      .from("conversations")
      .select(
        `
        *,
        lead:leads (
          *,
          contact:contacts (*)
        ),
        channel:channels (*),
        messages:messages (
          *
        )
      `
      )
      .eq("id", conversationId)
      .single();

    if (convError || !conversation) {
      console.error(
        `🔴 Channel Configuration Processor Error: Could not load conversation [${conversationId}]`,
        convError
      );
      return;
    }

    // Additional debugging for channel
    if (!conversation.channel) {
      console.error(
        `🔴 Conversation ${conversationId} has no channel relationship!`
      );
      console.error(`   Expected channel_id: ${conversation.channel_id}`);

      // Try to find the channel directly
      const { data: directChannel, error: directChannelError } =
        await supabaseAdmin
          .from("channels")
          .select("*")
          .eq("id", conversation.channel_id)
          .single();

      if (directChannelError) {
        console.error(`🔴 Direct channel lookup failed:`, directChannelError);
      } else {
        console.error(
          `🔴 Channel ${conversation.channel_id} does not exist in database`
        );
      }
      return;
    }

    // Check if the channel is paused
    if (conversation.channel?.is_paused) {
      return;
    }

    const allMessages = (conversation.messages as any[]) || [];

    // Always process the most recent inbound message
    const lastMessage = allMessages
      .filter((m) => m.direction === "inbound")
      .sort(
        (a, b) =>
          new Date(b.created_at || 0).getTime() -
          new Date(a.created_at || 0).getTime()
      )[0];

    if (!lastMessage) {
      return;
    }

// Check if this message has already been replied to
if (lastMessage.replied_to) {
  console.log(
    `✅ Channel Config: Message [${lastMessage.id}] has already been replied to. Skipping processing for conversation [${conversationId}].`
  );
  return;
}

const { data: channelConfig, error: configError } = await supabaseAdmin
  .from("channel_configurations")
  .select("*")
  .eq("channel_id", conversation.channel_id)
  .single();

if (configError || !channelConfig) {
  return;
}

export async function classifyAndExtract(
  text: string
): Promise<ClassificationResult> {
  try {
    // Validate input
    if (!text || typeof text !== "string") {
      throw new Error(
        `Invalid input: text must be a non-empty string, got ${typeof text}`
      );
    }

    // Validate API key
    if (!process.env.GOOGLE_AI_API_KEY) {
      throw new Error("GOOGLE_AI_API_KEY environment variable is not set");
    }

    const classificationToolDeclaration: FunctionDeclaration = {
      name: "classify_email_intent_and_entities",
      parameters: {
        type: Type.OBJECT,
        description:
          "Classifies the intent of an email and extracts key entities.",
        properties: {
          intent: {
            type: Type.STRING,
            enum: [...INTENTS],
            description: "The primary intent of the email.",
          },
          entities: {
            type: Type.ARRAY,
            items: {
              type: Type.OBJECT,
              properties: {
                type: {
                  type: Type.STRING,
                  enum: [...ENTITIES],
                  description:
                    "The type of the extracted entity (e.g., 'date', 'location').",
                },
                value: {
                  type: Type.STRING,
                  description: "The extracted value of the entity.",
                },
              },
              required: ["type", "value"],
            },
            description: "A list of all entities found in the email.",
          },
          confidence: {
            type: Type.NUMBER,
            description:
              "A confidence score from 0.0 to 1.0 about the classification.",
          },
        },
        required: ["intent", "entities", "confidence"],
      },
    };

    const response = await ai.models.generateContent({
      model: "gemini-2.5-flash",
      contents: [
        {
          role: "user",
          parts: [
            {
              text: `You are an expert AI assistant for a real estate business. Analyze this email and classify the user's intent and extract key entities.

IMPORTANT: Only classify as real estate related intents if the email is clearly about real estate services (buying, selling, renting, investing in property). 

- "other" = Non-real estate emails (newsletters, spam, personal emails, business unrelated to real estate)
- "not_interested" = People explicitly saying they don't want to be contacted or are unsubscribing
- "initial_inquiry" = First contact about real estate services
- "price_question" = Questions about property prices, values, or costs
- "showing_request" = Requests to view properties or schedule appointments
- "follow_up" = Follow-up questions about previous real estate discussions

Email to analyze:
${text.slice(0, 4000)}`,
            },
          ],
        },
      ],
      config: {
        toolConfig: {
          functionCallingConfig: {
            mode: FunctionCallingConfigMode.ANY,
            allowedFunctionNames: ["classify_email_intent_and_entities"],
          },
        },
        tools: [{ functionDeclarations: [classificationToolDeclaration] }],
      },
    });

    const functionCalls = response.functionCalls;
    if (!functionCalls || !functionCalls[0]?.args) {
      console.error("🔴 AI analysis failed to return a valid function call.");
      console.error("Response:", JSON.stringify(response, null, 2));
      return { intent: "other", entities: [], confidence: 0.3 };
    }

    const args = functionCalls[0].args as {
      intent: Intent;
      entities: ExtractedEntity[];
      confidence: number;
    };

    // Validate the response
    if (!args.intent || !INTENTS.includes(args.intent)) {
      console.error("🔴 AI returned invalid intent:", args.intent);
      return { intent: "other", entities: [], confidence: 0.3 };
    }

    return {
      intent: args.intent || "other",
      entities: args.entities || [],
      confidence: args.confidence || 0.5,
    };
  } catch (error) {
    console.error("🔴 Error in classifyAndExtract:", error);

    // Provide more context about the error
    if (error instanceof Error) {
      if (error.message.includes("Could not load the default credentials")) {
        console.error(
          "🔴 Google AI authentication error: Please check GOOGLE_AI_API_KEY environment variable"
        );
      } else if (error.message.includes("API key")) {
        console.error(
          "🔴 Google AI API key error: Please verify your API key is valid"
        );
      } else if (
        error.message.includes("quota") ||
        error.message.includes("rate limit")
      ) {
        console.error(
          "🔴 Google AI quota/rate limit error: Please check your usage limits"
        );
      }
    }

    // Return a default error state
    return { intent: "other", entities: [], confidence: 0.0 };
  }
}

export async function determineLeadType(
  classification: any,
  emailText: string,
  config: ChannelConfiguration
): Promise<"buyer" | "seller" | "investor" | "renter" | "unclear" | null> {
  // Check which lead types are enabled
  const enabledTypes = Object.entries(config.lead_types_enabled)
    .filter(([_, enabled]) => enabled)
    .map(([type, _]) => type);

  if (enabledTypes.length === 0) {
    return null;
  }

  // Use AI to determine lead type based on email content and classification
  try {
    const leadTypeClassification = await classifyLeadType(
      emailText,
      classification,
      enabledTypes
    );
    return leadTypeClassification;
  } catch (error) {
    console.error("Error classifying lead type with AI:", error);
    // Return unclear instead of falling back to first enabled type
    return "unclear";
  }
}

/**
 * Use AI to classify the lead type based on email content
 */
async function classifyLeadType(
  emailText: string,
  classification: any,
  enabledTypes: string[]
): Promise<"buyer" | "seller" | "investor" | "renter" | "unclear"> {
  try {
    const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_AI_API_KEY! });

    const leadTypeToolDeclaration: FunctionDeclaration = {
      name: "classify_lead_type",
      parameters: {
        type: Type.OBJECT,
        description: "Classifies the lead type based on email content.",
        properties: {
          lead_type: {
            type: Type.STRING,
            enum: [...enabledTypes, "unclear"],
            description:
              "The determined lead type from the available options, or 'unclear' if cannot be determined with confidence.",
          },
          confidence: {
            type: Type.NUMBER,
            description:
              "Confidence score from 0.0 to 1.0 about the classification.",
          },
        },
        required: ["lead_type", "confidence"],
      },
    };

    const response = await ai.models.generateContent({
      model: "gemini-2.5-flash",
      contents: [
        {
          role: "user",
          parts: [
            {
              text: `Analyze this email and determine the lead type. The available lead types are: ${enabledTypes.join(
                ", "
              )}.

Email content:
${emailText}

Previous AI classification:
- Intent: ${classification.intent}
- Confidence: ${classification.confidence}
- Entities: ${JSON.stringify(classification.entities)}

Based on the email content and context, classify this as one of the following lead types:
${enabledTypes
  .map((type) => {
    switch (type) {
      case "buyer":
        return "- buyer: Someone looking to purchase a property (keywords: buy, purchase, looking to buy, want to buy, interested in buying)";
      case "seller":
        return "- seller: Someone looking to sell their property (keywords: sell, selling, want to sell, need to sell, listing)";
      case "investor":
        return "- investor: Someone looking for investment opportunities (keywords: invest, investment, ROI, rental income, cash flow)";
      case "renter":
        return "- renter: Someone looking to rent a property (keywords: rent, renting, looking to rent, want to rent, lease, apartment, rental)";
      default:
        return `- ${type}: Someone looking for ${type} services`;
    }
  })
  .join("\n")}
- unclear: If the email doesn't clearly indicate the lead type or is ambiguous

IMPORTANT: Look for specific keywords in the email. If someone mentions "rent", "renting", "apartment", "lease", etc., they are likely a renter. If they mention "buy", "purchase", "house", etc., they are likely a buyer. If they mention "sell", "selling", "listing", etc., they are likely a seller.

Choose the most appropriate lead type from the available options. If the email is unclear or doesn't provide enough information to determine the lead type with confidence, return "unclear".`,
            },
          ],
        },
      ],
      config: {
        toolConfig: {
          functionCallingConfig: {
            mode: FunctionCallingConfigMode.ANY,
            allowedFunctionNames: ["classify_lead_type"],
          },
        },
        tools: [{ functionDeclarations: [leadTypeToolDeclaration] }],
      },
    });

    const functionCalls = response.functionCalls;
    if (!functionCalls || !functionCalls[0]?.args) {
      console.error(
        "🔴 AI lead type classification failed to return a valid function call."
      );
      return "unclear";
    }

    const args = functionCalls[0].args as {
      lead_type: string;
      confidence: number;
    };

    // Validate the response
    if (
      !args.lead_type ||
      (!enabledTypes.includes(args.lead_type) && args.lead_type !== "unclear")
    ) {
      console.error("🔴 AI returned invalid lead type:", args.lead_type);
      return "unclear";
    }

    // If confidence is low, return unclear
    if (args.confidence < 0.6) {
      return "unclear";
    }

    return args.lead_type as any;
  } catch (error) {
    console.error("Error in AI lead type classification:", error);
    // Return unclear instead of falling back to first enabled type
    return "unclear";
  }
}

if (leadType === "unclear") {
  const clarificationResponse = await generateClarificationResponse(
    lastMessage,
    conversation,
    channelConfig
  );

  if (clarificationResponse) {
    const messageId = await sendEmail({
      to: conversation.lead.contact.email,
      subject: clarificationResponse.subject,
      body: clarificationResponse.body,
      from: conversation.channel.identifier,
      channelId: conversation.channel_id,
      inReplyTo: lastMessage.message_id,
    });

    // Save the outbound message with encryption
    const { error: saveError } = await createEncryptedInsert(
      conversation.lead.org_id, // Use org_id as user_id for encryption
      "messages",
      {
        conversation_id: conversationId,
        direction: "outbound",
        subject: clarificationResponse.subject,
        body_text: clarificationResponse.body,
        message_id: messageId,
        in_reply_to: lastMessage.message_id,
      }
    );

    if (saveError) {
      console.error(
        `🔴 Channel Config: Could not save clarification message for [${conversationId}]:`,
        saveError
      );
    } else {
      // Mark the inbound message as replied to
      const { error: updateError } = await createEncryptedUpdate(
        conversation.lead.org_id, // Use org_id as user_id for encryption
        "messages",
        { replied_to: true },
        { id: lastMessage.id }
      );

      if (updateError) {
        console.error(
          `🔴 Channel Config: Could not mark message [${lastMessage.id}] as replied to:`,
          updateError
        );
      } else {
        console.log(
          `✅ Channel Config: Marked message [${lastMessage.id}] as replied to for conversation [${conversationId}]`
        );
      }
    }
  }
  return;
}

export async function generateClarificationResponse(
  message: any,
  conversation: any,
  config: ChannelConfiguration,
  detectedLeadType?: string // Add optional parameter for detected but disabled lead type
): Promise<{ subject: string; body: string } | null> {
  try {
    const contactName = conversation.lead?.contact?.name || "there";
    const enabledTypes = Object.entries(config.lead_types_enabled)
      .filter(([_, enabled]) => enabled)
      .map(([type, _]) => type);

    // Use user's qualification template if available
    if (config.communication_settings?.qualificationEmails?.length) {
      const templates = config.communication_settings.qualificationEmails;
      const selectedTemplate =
        templates[Math.floor(Math.random() * templates.length)];

      const emailBody = selectedTemplate
        .replace(/\[Lead Name\]/g, contactName)
        .replace(
          /\[Your Name\]/g,
          config.communication_settings?.emailSignature || "[Your Name]"
        );

      return {
        subject: `${message.subject || "Your inquiry"} - Quick question`,
        body: emailBody,
      };
    }

    // Fallback to AI generation if no templates available
    const context = {
      enabledLeadTypes: enabledTypes,
      enabledLeadTypesList: enabledTypes.join(", "),
      contactName,
      originalMessage: message.body_text,
      communicationSettings: config.communication_settings,
      detectedLeadType,
      instructions: detectedLeadType
        ? `The customer's email appears to be about ${detectedLeadType} services, but we only handle ${enabledTypes.join(
            ", "
          )}. Politely explain that we specialize in ${enabledTypes.join(
            ", "
          )} and ask if they might be interested in those services instead.`
        : `The customer's email is unclear about which real estate service they need. Ask them to specify which of these enabled services they're interested in: ${enabledTypes.join(
            ", "
          )}. Be specific and mention each enabled service type.`,
    };

    const response = await composeReply({
      conversationHistory: message.body_text,
      plan: {
        action: detectedLeadType
          ? `Politely explain we specialize in ${enabledTypes.join(
              ", "
            )} and ask if they're interested in those services instead`
          : `Ask for clarification about which of the enabled lead types they're interested in: ${enabledTypes.join(
              ", "
            )}`,
        reasoning: detectedLeadType
          ? `The customer appears to be looking for ${detectedLeadType} services, but we only handle ${enabledTypes.join(
              ", "
            )}. We should politely redirect them to our available services.`
          : "The email doesn't clearly indicate what type of real estate service they're looking for. We need to ask them to specify which of our enabled services they're interested in to provide the best assistance.",
      },
      agentPersona:
        config.communication_settings?.responseStyle ||
        `You are a helpful and professional real estate agent. ${
          detectedLeadType
            ? `Politely explain that you specialize in ${enabledTypes.join(
                ", "
              )} and ask if they might be interested in those services instead.`
            : `Ask the customer to clarify which of these specific services they're interested in: ${enabledTypes.join(
                ", "
              )}.`
        } Be concise and straightforward in your communication. Keep emails brief and to the point.`,
      knowledge: JSON.stringify(context),
    });

    if (!response) {
      return null;
    }

    // Add email signature if available
    let emailBody = response.body;
    if (config.communication_settings?.emailSignature) {
      emailBody = `${response.body}\n\n${config.communication_settings.emailSignature}`;
    }

    return {
      subject: `${message.subject || "Your inquiry"} - Quick question`,
      body: emailBody,
    };
  } catch (error) {
    console.error("Error generating clarification response:", error);
    return null;
  }
}