const { SharpApiRelatedJobPositionsService } = require('@sharpapi/sharpapi-node-related-job-positions');

const apiKey = process.env.SHARP_API_KEY; // Store your API key in environment variables
const service = new SharpApiRelatedJobPositionsService(apiKey);

const jobPosition = 'Frontend Developer';

async function generateRelatedPositions() {
  try {
    // Submit related job positions generation job
    const statusUrl = await service.generateRelatedJobPositions(jobPosition, 'English', 10);
    console.log('Job submitted. Status URL:', statusUrl);

    // Fetch results (polls automatically until complete)
    const result = await service.fetchResults(statusUrl);
    console.log('Related positions:', result.getResultJson());
  } catch (error) {
    console.error('Error:', error.message);
  }
}

generateRelatedPositions();

const statusUrl = await service.generateRelatedJobPositions(
  'Data Scientist',
  'English',
  8,
  'Professional',
  'Focus on senior-level positions in tech companies'
);
const result = await service.fetchResults(statusUrl);

const { SharpApiRelatedJobPositionsService } = require('@sharpapi/sharpapi-node-related-job-positions');

const service = new SharpApiRelatedJobPositionsService(process.env.SHARP_API_KEY);

service.generateRelatedJobPositions('DevOps Engineer', 'English', 6)
  .then(statusUrl => service.fetchResults(statusUrl))
  .then(result => {
    const data = result.getResultJson();
    console.log(`Related positions for ${data.result.job_position}:`);

    data.result.related_job_positions
      .sort((a, b) => b.weight - a.weight)
      .forEach((position, index) => {
        console.log(`${index + 1}. ${position.name} (relevance: ${position.weight}/10)`);
      });
  })
  .catch(error => console.error('Generation failed:', error));

const service = new SharpApiRelatedJobPositionsService(process.env.SHARP_API_KEY);

async function recommendCareerPaths(currentPosition) {
  const statusUrl = await service.generateRelatedJobPositions(
    currentPosition,
    'English',
    15
  );

  const result = await service.fetchResults(statusUrl);
  const data = result.getResultJson();

  // Categorize by relevance
  const exactMatch = data.result.related_job_positions.filter(p => p.weight === 10);
  const highlyRelated = data.result.related_job_positions.filter(p => p.weight >= 8 && p.weight < 10);
  const related = data.result.related_job_positions.filter(p => p.weight >= 6 && p.weight < 8);

  return {
    current: currentPosition,
    exactMatches: exactMatch.map(p => p.name),
    lateralMoves: highlyRelated.map(p => p.name),
    careerPivots: related.map(p => p.name)
  };
}

const recommendations = await recommendCareerPaths('Product Manager');

console.log('Career Path Recommendations:');
console.log('\nLateral Moves (Similar Roles):');
recommendations.lateralMoves.forEach(job => console.log(`  - ${job}`));

console.log('\nCareer Pivot Options:');
recommendations.careerPivots.forEach(job => console.log(`  - ${job}`));

const service = new SharpApiRelatedJobPositionsService(process.env.SHARP_API_KEY);

async function expandJobSearch(userSearchTerm) {
  const statusUrl = await service.generateRelatedJobPositions(
    userSearchTerm,
    'English',
    20
  );

  const result = await service.fetchResults(statusUrl);
  const data = result.getResultJson();

  // Filter high-relevance positions for expanded search
  const expandedSearchTerms = data.result.related_job_positions
    .filter(position => position.weight >= 7)
    .map(position => position.name);

  return {
    original: userSearchTerm,
    expanded: [userSearchTerm, ...expandedSearchTerms],
    message: `Searching for ${expandedSearchTerms.length + 1} related positions`
  };
}

const expandedSearch = await expandJobSearch('Full Stack Developer');

console.log(expandedSearch.message);
console.log('Search terms:', expandedSearch.expanded.join(', '));

const service = new SharpApiRelatedJobPositionsService(process.env.SHARP_API_KEY);

async function mapTalentPool(targetPosition) {
  const statusUrl = await service.generateRelatedJobPositions(
    targetPosition,
    'English',
    12
  );

  const result = await service.fetchResults(statusUrl);
  const data = result.getResultJson();

  // Identify candidates with transferable experience
  const transferablePositions = data.result.related_job_positions
    .filter(position => position.weight >= 6)
    .map(position => ({
      title: position.name,
      relevance: position.weight,
      trainingRequired: position.weight < 8 ? 'Moderate' : 'Minimal'
    }));

  return {
    targetRole: targetPosition,
    candidates: transferablePositions,
    totalPool: transferablePositions.length
  };
}

const talentMap = await mapTalentPool('Machine Learning Engineer');

console.log(`Talent Pool for ${talentMap.targetRole}:`);
console.log(`Total candidate sources: ${talentMap.totalPool}`);

talentMap.candidates.forEach(candidate => {
  console.log(`\n${candidate.title}`);
  console.log(`  Relevance: ${candidate.relevance}/10`);
  console.log(`  Training: ${candidate.trainingRequired}`);
});