const express = require('express');
const multer = require('multer');
const { parseResume } = require('lovable-resume-parser'); // Hypothetical library
const app = express();
const upload = multer();

app.post('/api/parse-resume', upload.single('resume'), async (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: 'No file uploaded' });
  }
  try {
    const resumeBuffer = req.file.buffer;
    const parsedData = await parseResume(resumeBuffer);
    
    const structuredResume = {
      personal\_info: {
        name: parsedData.name || '',
        email: parsedData.email || '',
        phone: parsedData.phone || ''
      },
      work\_experience: parsedData.experiences ? parsedData.experiences.map(exp => ({
        company: exp.company,
        role: exp.title,
        start\_date: exp.start,
        end\_date: exp.end,
        description: exp.summary
      })) : [],
      education: parsedData.education ? parsedData.education.map(edu => ({
        institution: edu.institution,
        degree: edu.degree,
        start\_date: edu.start,
        end\_date: edu.end
      })) : []
    };

    return res.json(structuredResume);
  } catch (error) {
    console.error(error);
    return res.status(500).json({ error: 'Failed to parse resume' });
  }
});

app.listen(3000, () => {
  console.log('Resume parser API running on port 3000');
});

const express = require('express');
const multer = require('multer');
const axios = require('axios');
const { parseResume } = require('lovable-resume-parser-ex'); // Hypothetical Lovable extendable parser library
const app = express();
const upload = multer();

app.post('/api/enrich-resume', upload.single('resume'), async (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: 'Resume file is required.' });
  }
  try {
    const resumeBuffer = req.file.buffer;
    const parsedResume = await parseResume(resumeBuffer);

    // Send parsed resume data to an external enrichment API for personality and skills insights
    const enrichmentResponse = await axios.post('https://api.external-enrichment.com/insights', {
      email: parsedResume.email,
      skills: parsedResume.skills
    });

    const enrichedInsights = enrichmentResponse.data;

    const structuredResume = {
      personal\_info: {
        name: parsedResume.name || '',
        email: parsedResume.email || '',
        phone: parsedResume.phone || ''
      },
      work\_experience: parsedResume.experiences || [],
      education: parsedResume.education || [],
      enriched\_insights: enrichedInsights
    };

    return res.json(structuredResume);
  } catch (error) {
    console.error('Error processing resume:', error);
    return res.status(500).json({ error: 'Failed to process the resume.' });
  }
});

app.listen(3001, () => {
  console.log('Resume enrichment API running on port 3001');
});

const express = require('express');
const multer = require('multer');
const jwt = require('jsonwebtoken');
const AWS = require('aws-sdk');
const { streamParseResume } = require('lovable-resume-parser'); // Hypothetical stream-based parser

const app = express();
const upload = multer({ storage: multer.memoryStorage() });

const s3 = new AWS.S3({
  accessKeyId: process.env.AWS_ACCESS_KEY,
  secretAccessKey: process.env.AWS_SECRET_KEY,
  region: process.env.AWS\_REGION
});

function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'Missing token' });
  jwt.verify(token, process.env.JWT\_SECRET, (err, user) => {
    if (err) return res.status(403).json({ error: 'Invalid token' });
    req.user = user;
    next();
  });
}

app.post('/api/secure/parse-s3-resume', authenticateToken, upload.single('resume'), async (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: 'No resume provided' });
  }

  const s3Params = {
    Bucket: process.env.AWS_S3_BUCKET,
    Key: `resumes/${Date.now()}_${req.file.originalname}`,
    Body: req.file.buffer,
    ContentType: req.file.mimetype
  };

  try {
    const s3Upload = await s3.upload(s3Params).promise();
    const s3Stream = s3.getObject({ Bucket: process.env.AWS_S3_BUCKET, Key: s3Params.Key }).createReadStream();

    streamParseResume(s3Stream, (err, parsedData) => {
      if (err) {
        return res.status(500).json({ error: 'Error parsing resume' });
      }
      res.json({
        s3Location: s3Upload.Location,
        parsedResume: {
          personal: parsedData.personal || {},
          experience: parsedData.experience || [],
          education: parsedData.education || []
        }
      });
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Server error processing resume' });
  }
});

app.listen(4000, () => {
  console.log('Secure resume parser running on port 4000');
});