HyperGrow

// Type-safe API procedures with comprehensive validation
const protectedProcedure = publicProcedure.use(async ({ ctx, next }) => {
  if (!ctx.session?.user) {
    throw new TRPCError({ code: 'UNAUTHORIZED' });
  }
  return next({ ctx: { ...ctx, user: ctx.session.user } });
});

// Comprehensive lead management with Zod validation
export const leadRouter = createTRPCRouter({
  getAll: protectedProcedure
    .input(z.object({
      organizationId: z.string(),
      status: z.enum(['new', 'contacted', 'interested', 'converted']).optional(),
      limit: z.number().min(1).max(100).default(50),
      cursor: z.string().optional(),
    }))
    .query(async ({ input, ctx }) => {
      const { organizationId, status, limit, cursor } = input;
      
      return await ctx.prisma.lead.findMany({
        where: {
          organizationId,
          ...(status && { status }),
          ...(cursor && { id: { gt: cursor } }),
        },
        take: limit + 1,
        orderBy: { createdAt: 'desc' },
        include: {
          communications: {
            orderBy: { createdAt: 'desc' },
            take: 5,
          },
        },
      });
    }),

  create: protectedProcedure
    .input(z.object({
      organizationId: z.string(),
      firstName: z.string().min(1),
      lastName: z.string().min(1),
      email: z.string().email(),
      phone: z.string().optional(),
      website: z.string().url().optional(),
      companyName: z.string().optional(),
    }))
    .mutation(async ({ input, ctx }) => {
      // AI enrichment and lead creation logic
      const enrichedData = await enrichLeadWithAI(input);
      
      return await ctx.prisma.lead.create({
        data: {
          ...input,
          ...enrichedData,
          status: 'new',
          createdBy: ctx.user.id,
        },
      });
    }),
});

// Automatic client-side type generation
const trpc = createTRPCNext<AppRouter>({
  config({ ctx }) {
    return {
      transformer: superjson,
      links: [
        httpBatchLink({
          url: '/api/trpc',
          headers() {
            return {
              authorization: `Bearer ${getAuthToken()}`,
            };
          },
        }),
      ],
    };
  },
});

// Type-safe client usage
const { data: leads, isLoading } = trpc.lead.getAll.useQuery({
  organizationId: user.organizationId,
  status: 'new',
  limit: 25,
});

// AI-powered business analysis and lead enrichment
interface InsightResult {
  businessInsights: string[];
  painPoints: string[];
  opportunities: string[];
  suggestedApproach: string;
  emailSuggestions: {
    subject: string;
    content: string;
    variables: string[];
  };
  leadScore: number; // 0-100 confidence score
}

async function analyzeWebsite(
  data: ScrapedData, 
  businessName: string,
  templateContext?: TemplateContext
): Promise<InsightResult> {
  const prompt = `
Analyze this business website data and provide comprehensive insights:

Company: ${businessName}
Website Content: ${data.content}
Technologies: ${data.technologies?.join(', ')}
Social Presence: ${data.socialLinks?.length || 0} platforms

Provide detailed analysis in the following format:
1. Business Insights (3-5 key observations)
2. Pain Points (potential challenges they face)
3. Opportunities (ways we can help)
4. Suggested Approach (personalized outreach strategy)
5. Email Suggestions (subject + content template)
6. Lead Score (0-100 based on fit and opportunity)

Focus on actionable insights for sales outreach.
`;

  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 2000,
    messages: [{ role: 'user', content: prompt }]
  });

  return parseAIResponse(response.content[0].text);
}

// Advanced web scraping with Puppeteer
async function scrapeBusinessData(website: string): Promise<ScrapedData> {
  const browser = await puppeteer.launch({
    headless: true,
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  
  try {
    const page = await browser.newPage();
    await page.setUserAgent('Mozilla/5.0 (compatible; HyperGrow Bot)');
    
    await page.goto(website, { 
      waitUntil: 'networkidle2', 
      timeout: 30000 
    });
    
    // Extract comprehensive business data
    const scrapedData = await page.evaluate(() => {
      // Technology detection
      const technologies = Array.from(document.querySelectorAll('script[src]'))
        .map(script => script.getAttribute('src'))
        .filter(src => src?.includes('analytics') || src?.includes('tracking'))
        .map(src => identifyTechnology(src));
        
      // Content analysis
      const content = {
        title: document.title,
        description: document.querySelector('meta[name="description"]')?.getAttribute('content'),
        headings: Array.from(document.querySelectorAll('h1, h2, h3')).map(h => h.textContent),
        services: extractServices(document.body.textContent),
        contactInfo: extractContactInfo(document.body.textContent)
      };
      
      // Social media presence
      const socialLinks = Array.from(document.querySelectorAll('a[href*="facebook"], a[href*="twitter"], a[href*="linkedin"]'))
        .map(link => ({ platform: identifyPlatform(link.href), url: link.href }));
        
      return { technologies, content, socialLinks };
    });
    
    return scrapedData;
  } finally {
    await browser.close();
  }
}

// Automated email personalization
async function generatePersonalizedEmail(
  lead: Lead, 
  insights: InsightResult,
  template: EmailTemplate
): Promise<PersonalizedEmail> {
  const variables = {
    firstName: lead.firstName,
    companyName: lead.companyName,
    businessInsights: insights.businessInsights[0],
    suggestedValue: insights.opportunities[0],
    callToAction: insights.suggestedApproach
  };
  
  const personalizedContent = await replaceTemplateVariables(
    template.content, 
    variables
  );
  
  return {
    subject: `${insights.emailSuggestions.subject} - ${lead.companyName}`,
    content: personalizedContent,
    variables,
    leadScore: insights.leadScore
  };
}