// services/email-classifier.ts
import { ChatOpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
import { RunnableSequence } from "@langchain/core/runnables";
import { z } from "zod";
 
const ClassificationResult = z.object({
  category: z.enum([
    "support",
    "sales",
    "billing",
    "partnership",
    "spam",
    "other",
  ]),
  priority: z.enum(["urgent", "high", "normal", "low"]),
  sentiment: z.enum(["positive", "neutral", "negative"]),
  summary: z.string().max(200),
  extractedEntities: z.object({
    customerName: z.string().optional(),
    accountId: z.string().optional(),
    productMentioned: z.string().optional(),
    requestedAction: z.string().optional(),
  }),
  suggestedResponse: z.string(),
});
 
const classificationPrompt = PromptTemplate.fromTemplate(`
Classify the following email and extract key information.
 
From: {from}
Subject: {subject}
Body:
{body}
 
Respond in JSON format with these fields:
- category: support | sales | billing | partnership | spam | other
- priority: urgent | high | normal | low
- sentiment: positive | neutral | negative
- summary: brief summary under 200 characters
- extractedEntities: customerName, accountId, productMentioned, requestedAction
- suggestedResponse: a draft response to the email
 
JSON response:`);
 
const model = new ChatOpenAI({
  model: "gpt-4o-mini", // Cost-effective for classification
  temperature: 0,
});
 
export const classifyEmail = RunnableSequence.from([
  classificationPrompt,
  model,
  (response) => {
    const parsed = JSON.parse(response.content as string);
    return ClassificationResult.parse(parsed);
  },
]);
 
// Express endpoint for n8n to call
import express from "express";
const app = express();
app.use(express.json());
 
app.post("/classify", async (req, res) => {
  try {
    const { from, subject, body } = req.body;
    const result = await classifyEmail.invoke({
      from,
      subject,
      body,
    });
    res.json(result);
  } catch (error) {
    res.status(500).json({
      error: (error as Error).message,
    });
  }
});
 
app.listen(3001, () => {
  console.log("Email classifier service running on :3001");
});

// n8n workflow structure (simplified)
{
  "nodes": [
    {
      "name": "Gmail Trigger",
      "type": "n8n-nodes-base.gmailTrigger",
      "parameters": {
        "pollTimes": { "item": [{ "mode": "everyMinute" }] },
        "filters": { "labelIds": ["INBOX"] }
      }
    },
    {
      "name": "Classify Email",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "POST",
        "url": "http://localhost:3001/classify",
        "body": {
          "from": "={{ $json.from }}",
          "subject": "={{ $json.subject }}",
          "body": "={{ $json.snippet }}"
        }
      }
    },
    {
      "name": "Route by Category",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "rules": [
          { "value": "support", "output": 0 },
          { "value": "sales", "output": 1 },
          { "value": "billing", "output": 2 },
          { "value": "spam", "output": 3 }
        ]
      }
    },
    {
      "name": "Notify Support Slack",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#support-queue",
        "text": "New {{ $json.priority }} support email from {{ $json.extractedEntities.customerName }}: {{ $json.summary }}"
      }
    }
  ]
}

// services/content-pipeline.ts
import { ChatOpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
import { RunnableSequence } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";
 
const model = new ChatOpenAI({ model: "gpt-4o" });
const fastModel = new ChatOpenAI({ model: "gpt-4o-mini" });
 
// Step 1: Generate research outline
const researchChain = RunnableSequence.from([
  PromptTemplate.fromTemplate(`
Create a detailed research outline for a blog post about: {topic}
Target audience: {audience}
Desired length: {wordCount} words
 
Include:
- 5-7 key points to cover
- Questions to answer
- Potential data points or examples to include
- Suggested structure
 
Research outline:`),
  model,
  new StringOutputParser(),
]);
 
// Step 2: Generate draft from outline
const draftChain = RunnableSequence.from([
  PromptTemplate.fromTemplate(`
Write a blog post based on this outline.
 
Topic: {topic}
Target audience: {audience}
Word count target: {wordCount}
 
Research Outline:
{outline}
 
Write in a professional but approachable tone.
Include practical examples.
Use markdown formatting with headers.
 
Blog post:`),
  model,
  new StringOutputParser(),
]);
 
// Step 3: Generate SEO metadata
const seoChain = RunnableSequence.from([
  PromptTemplate.fromTemplate(`
Generate SEO metadata for this blog post.
 
Title topic: {topic}
Post content (first 500 chars): {contentPreview}
 
Return JSON with:
- metaTitle (under 60 chars)
- metaDescription (under 155 chars)
- slug (url-friendly)
- tags (array of 5 relevant tags)
 
JSON:`),
  fastModel,
  new StringOutputParser(),
]);
 
// Combined pipeline endpoint
import express from "express";
const app = express();
app.use(express.json());
 
app.post("/generate-content", async (req, res) => {
  const { topic, audience, wordCount = 1500 } = req.body;
 
  // Step 1: Research
  const outline = await researchChain.invoke({
    topic,
    audience,
    wordCount: String(wordCount),
  });
 
  // Step 2: Draft
  const draft = await draftChain.invoke({
    topic,
    audience,
    wordCount: String(wordCount),
    outline,
  });
 
  // Step 3: SEO metadata
  const seoRaw = await seoChain.invoke({
    topic,
    contentPreview: draft.slice(0, 500),
  });
 
  const seo = JSON.parse(seoRaw);
 
  res.json({
    outline,
    draft,
    seo,
    metadata: {
      generatedAt: new Date().toISOString(),
      estimatedWordCount: draft.split(/\s+/).length,
    },
  });
});
 
app.listen(3002, () => {
  console.log("Content pipeline running on :3002");
});

// services/data-enrichment.ts
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";
import express from "express";
 
const model = new ChatOpenAI({
  model: "gpt-4o-mini",
  temperature: 0,
});
 
const EnrichmentResult = z.object({
  companySize: z
    .enum(["startup", "smb", "mid-market", "enterprise"])
    .optional(),
  industry: z.string().optional(),
  painPoints: z.array(z.string()),
  buyingStage: z
    .enum(["awareness", "consideration", "decision"])
    .optional(),
  techStack: z.array(z.string()),
  keyDecisionFactors: z.array(z.string()),
});
 
const app = express();
app.use(express.json());
 
app.post("/enrich", async (req, res) => {
  const { interactions } = req.body;
  // interactions is an array of { type, content, date }
 
  const combinedContext = interactions
    .map(
      (i: any) =>
        `[${i.type} - ${i.date}]: ${i.content}`
    )
    .join("\n\n");
 
  const response = await model.invoke([
    {
      role: "system",
      content: `Analyze customer interactions and extract
        structured insights. Only include fields where you
        have reasonable confidence. Return valid JSON.`,
    },
    {
      role: "user",
      content: `Extract insights from these interactions:\n\n${combinedContext}`,
    },
  ]);
 
  const enrichment = EnrichmentResult.parse(
    JSON.parse(response.content as string)
  );
 
  res.json(enrichment);
});
 
app.listen(3003, () => {
  console.log("Data enrichment service running on :3003");
});

// services/webhook-handler.ts
import express from "express";
import crypto from "crypto";
import { classifyAndProcess } from "./processors";
 
const app = express();
app.use(express.json());
 
// Verify webhook signatures for security
function verifyWebhookSignature(
  payload: string,
  signature: string,
  secret: string
): boolean {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(payload)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}
 
app.post("/webhook/process", async (req, res) => {
  const signature = req.headers["x-webhook-signature"];
  if (
    !signature ||
    !verifyWebhookSignature(
      JSON.stringify(req.body),
      signature as string,
      process.env.WEBHOOK_SECRET!
    )
  ) {
    return res.status(401).json({ error: "Invalid signature" });
  }
 
  // Acknowledge immediately, process async
  res.status(202).json({ status: "accepted" });
 
  // Process in background
  try {
    await classifyAndProcess(req.body);
  } catch (error) {
    console.error("Background processing failed:", error);
    // Alert monitoring system
  }
});
 
app.listen(3004);