import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Step 1: Create the plan
const planPrompt = ChatPromptTemplate.fromTemplate(
  `Create a step-by-step plan for: {task}

Break down the task into numbered steps. Each step should be specific and actionable.`,
);

// Step 2: Execute each step
const executePrompt = ChatPromptTemplate.fromTemplate(
  `You are executing step {stepNumber} of a plan.

Plan:
{plan}

Current step: {currentStep}

Execute this step and provide the result:`,
);

// Create plan chain
const planChain = planPrompt.pipe(llm).pipe(new StringOutputParser());
const executeChain = executePrompt.pipe(llm).pipe(new StringOutputParser());

// Static planning function
async function staticPlanning(task) {
  console.log('Creating plan...');
  const plan = await planChain.invoke({ task });

  // Parse plan into steps (simple splitting by newlines/numbers)
  const steps = plan.split('\n').filter((s) => s.trim().length > 0);

  console.log(`Executing ${steps.length} steps...`);
  const results = [];

  for (let i = 0; i < steps.length; i++) {
    console.log(`Executing step ${i + 1}...`);
    const result = await executeChain.invoke({
      stepNumber: i + 1,
      plan: plan,
      currentStep: steps[i],
    });
    results.push({ step: steps[i], result });
  }

  return { plan, results };
}

// Usage
const task = 'Plan a birthday party for 10 people';
const result = await staticPlanning(task);
console.log('Plan:', result.plan);
console.log('Results:', result.results);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Initial plan creation
const initialPlanPrompt = ChatPromptTemplate.fromTemplate(
  `Create an initial plan for: {task}

Break down into 3-5 main steps.`,
);

// Re-planning based on previous results
const replanPrompt = ChatPromptTemplate.fromTemplate(
  `You are dynamically adjusting a plan based on execution results.

Original task: {task}
Current plan progress:
{history}

Latest result: {latestResult}

Should the plan change? If yes, explain what to modify and provide the updated next steps. If no, simply state the next step to execute.`,
);

// Execute step
const executePrompt = ChatPromptTemplate.fromTemplate(
  `Execute this step: {step}

Provide your result:`,
);

const initialPlanChain = initialPlanPrompt.pipe(llm).pipe(new StringOutputParser());
const replanChain = replanPrompt.pipe(llm).pipe(new StringOutputParser());
const executeChain = executePrompt.pipe(llm).pipe(new StringOutputParser());

// Dynamic planning function
async function dynamicPlanning(task, maxIterations = 5) {
  console.log('Creating initial plan...');

  let currentPlan = await initialPlanChain.invoke({ task });
  let history = [];
  let shouldContinue = true;
  let iteration = 0;

  while (shouldContinue && iteration < maxIterations) {
    iteration++;
    console.log(`\n--- Iteration ${iteration} ---`);

    // Decide next step (simplified - just take first line)
    const nextStep = currentPlan.split('\n')[0];
    console.log('Executing:', nextStep);

    const result = await executeChain.invoke({ step: nextStep });
    history.push({ step: nextStep, result });

    // Check if we need to replan
    const feedback = await replanChain.invoke({
      task,
      history: history.map((h) => `${h.step}: ${h.result}`).join('\n'),
      latestResult: result,
    });

    // Simple check - if feedback contains "no" or "continue", proceed
    if (
      feedback.toLowerCase().includes('complete') ||
      feedback.toLowerCase().includes('finished')
    ) {
      shouldContinue = false;
    } else {
      // Update plan based on feedback
      currentPlan = feedback;
    }
  }

  return history;
}

// Usage
const task = 'Research and write a report on AI trends';
await dynamicPlanning(task);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Level 1: High-level planning (goals)
const highLevelPrompt = ChatPromptTemplate.fromTemplate(
  `For the task: {task}

Provide 2-4 high-level goals (abstract objectives).`,
);

// Level 2: Mid-level planning (phases)
const midLevelPrompt = ChatPromptTemplate.fromTemplate(
  `Break down this goal into phases:

Goal: {goal}

Task: {task}

Provide 2-3 phases for achieving this goal.`,
);

// Level 3: Low-level planning (specific actions)
const lowLevelPrompt = ChatPromptTemplate.fromTemplate(
  `For this phase, provide specific actionable steps:

Phase: {phase}

Task: {task}

Provide 3-5 concrete steps to complete this phase.`,
);

// Execution
const executePrompt = ChatPromptTemplate.fromTemplate(`Execute this step: {step}`);

const highLevelChain = highLevelPrompt.pipe(llm).pipe(new StringOutputParser());
const midLevelChain = midLevelPrompt.pipe(llm).pipe(new StringOutputParser());
const lowLevelChain = lowLevelPrompt.pipe(llm).pipe(new StringOutputParser());
const executeChain = executePrompt.pipe(llm).pipe(new StringOutputParser());

// Hierarchical planning function
async function hierarchicalPlanning(task) {
  console.log('=== Level 1: High-Level Goals ===');
  const goals = await highLevelChain.invoke({ task });
  console.log(goals);

  // For each goal, create mid-level phases
  const goalList = goals.split('\n').filter((g) => g.trim());
  const plan = [];

  for (const goal of goalList) {
    console.log(`\n=== Level 2: Phases for "${goal}" ===`);
    const phases = await midLevelChain.invoke({ goal, task });
    console.log(phases);

    const phaseList = phases.split('\n').filter((p) => p.trim());
    const goalPlan = { goal, phases: [] };

    // For each phase, create low-level steps
    for (const phase of phaseList) {
      console.log(`\n=== Level 3: Steps for "${phase}" ===`);
      const steps = await lowLevelChain.invoke({ phase, task });
      console.log(steps);

      goalPlan.phases.push({ phase, steps: steps.split('\n').filter((s) => s.trim()) });
    }

    plan.push(goalPlan);
  }

  return plan;
}

// Execute the plan
async function executeHierarchicalPlan(plan) {
  console.log('\n=== Executing Plan ===');

  for (const goalPlan of plan) {
    console.log(`\n--- Goal: ${goalPlan.goal} ---`);

    for (const phasePlan of goalPlan.phases) {
      console.log(`\nPhase: ${phasePlan.phase}`);

      for (const step of phasePlan.steps) {
        console.log(`Executing: ${step}`);
        const result = await executeChain.invoke({ step });
        console.log(`Result: ${result.substring(0, 100)}...`);
      }
    }
  }
}

// Usage
const task = 'Build a web application';
const plan = await hierarchicalPlanning(task);
await executeHierarchicalPlan(plan);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ model: 'gpt-4o', temperature: 0.1 });

// --- Step 1: Extract financial metrics from PDF ---
const extractPrompt = ChatPromptTemplate.fromTemplate(
  `You are a financial data extractor. Extract the following key metrics from this earnings report:

Target Metrics:
- Revenue (营收)
- Net Income (净利润)
- EPS (每股收益)
- Operating Margin (营业利润率)

Report Text:
{reportText}

Return ONLY the extracted numbers in this format:
{"revenue": "X", "netIncome": "X", "eps": "X", "operatingMargin": "X"}`,
);

// --- Step 2: Format to strict JSON ---
const formatPrompt = ChatPromptTemplate.fromTemplate(
  `Convert the following financial data into strict JSON format:

Raw Data:
{rawData}

Return ONLY valid JSON with these exact keys:
{"revenue": number, "netIncome": number, "eps": number, "operatingMargin": number}`,
);

// --- Step 3: Validate with calculator ---
const validatePrompt = ChatPromptTemplate.fromTemplate(
  `Verify if these financial metrics are consistent:

Extracted Data:
{jsonData}

Calculations to verify:
1. Operating Margin = (Operating Income / Revenue) * 100
2. Net Income should be positive for profitable companies

Return validation result:
{"valid": boolean, "issues": []}`,
);

// --- Create Chains ---
const extractChain = extractPrompt.pipe(llm).pipe(new StringOutputParser());
const formatChain = formatPrompt.pipe(llm).pipe(new StringOutputParser());
const validateChain = validatePrompt.pipe(llm).pipe(new StringOutputParser());

// --- Prompt Chaining Execution ---
async function extractFinancialData(reportText) {
  console.log('\n=== Step 1: Extract ===');
  const rawData = await extractChain.invoke({ reportText });
  console.log('Extracted:', rawData);

  console.log('\n=== Step 2: Format ===');
  const jsonData = await formatChain.invoke({ rawData });
  console.log('Formatted:', jsonData);

  console.log('\n=== Step 3: Validate ===');
  const validation = await validateChain.invoke({ jsonData });
  console.log('Validation:', validation);

  return { rawData, jsonData, validation };
}

// --- Usage ---
const sampleReport = `
Apple Inc. reported Q4 2024 earnings:
Total Revenue: $94.9 billion
Operating Income: $27.0 billion
Net Income: $23.6 billion
EPS: $1.40
`;

extractFinancialData(sampleReport);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ model: 'gpt-4o', temperature: 0.5 });

// --- Simulated Market Data ---
const marketData = {
  indices: [
    { name: 'S&P 500', value: 4780.24, change: '+0.8%' },
    { name: 'NASDAQ', value: 15055.65, change: '+1.2%' },
    { name: 'DOW', value: 37545.33, change: '+0.5%' },
  ],
  sectors: [
    { name: 'Tech', change: '+1.5%', topGainers: ['NVDA', 'AAPL'] },
    { name: 'Energy', change: '-1.2%', topLosers: ['XOM', 'CVX'] },
    { name: 'Healthcare', change: '+0.3%', topGainers: ['UNH', 'JNJ'] },
  ],
};

// --- Step 1: Summarize index performance ---
const summarizeIndicesPrompt = ChatPromptTemplate.fromTemplate(
  `Summarize the performance of these stock indices:

Indices Data:
{indicesData}

Provide a brief 2-3 sentence summary of market direction.`,
);

// --- Step 2: Identify sector trends ---
const sectorTrendsPrompt = ChatPromptTemplate.fromTemplate(
  `Based on the index summary and sector data, identify key sector trends:

Index Summary:
{indexSummary}

Sector Data:
{sectorData}

Identify:
- Top performing sectors
- Worst performing sectors
- Key market themes`,
);

// --- Step 3: Generate final email ---
const emailPrompt = ChatPromptTemplate.fromTemplate(
  `You are a senior analyst. Draft a professional market summary email.

Market Overview:
{indexSummary}

Sector Trends:
{sectorTrends}

Requirements:
- Professional tone
- Include actionable insights
- Add chart placeholders where relevant
- Keep it concise (3-5 paragraphs)`,
);

// --- Create Chains ---
const summarizeChain = summarizeIndicesPrompt.pipe(llm).pipe(new StringOutputParser());
const sectorChain = sectorTrendsPrompt.pipe(llm).pipe(new StringOutputParser());
const emailChain = emailPrompt.pipe(llm).pipe(new StringOutputParser());

// --- Prompt Chaining Execution ---
async function generateDailyBrief() {
  console.log('\n=== Generating Daily Market Brief ===\n');

  // Step 1: Summarize indices
  console.log('Step 1: Summarizing indices...');
  const indexSummary = await summarizeChain.invoke({
    indicesData: JSON.stringify(marketData.indices),
  });
  console.log('Index Summary:', indexSummary.substring(0, 100), '...');

  // Step 2: Analyze sectors
  console.log('\nStep 2: Analyzing sector trends...');
  const sectorTrends = await sectorChain.invoke({
    indexSummary,
    sectorData: JSON.stringify(marketData.sectors),
  });
  console.log('Sector Trends:', sectorTrends.substring(0, 100), '...');

  // Step 3: Generate email
  console.log('\nStep 3: Drafting final email...');
  const email = await emailChain.invoke({
    indexSummary,
    sectorTrends,
  });

  console.log('\n=== Final Market Brief ===');
  console.log(email);

  return email;
}

generateDailyBrief();

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ model: 'gpt-4o', temperature: 0.7 });

// --- Planning Phase ---
const planningPrompt = ChatPromptTemplate.fromTemplate(
  `You are an investment research planner. The user asks:

"{query}"

Break down this complex research task into a plan with 4-6 research steps.
Each step should address a specific aspect of the question.

Output the plan as a numbered list.`,
);

// --- Chain of Thought Execution ---
const cotPrompt = ChatPromptTemplate.fromTemplate(
  `You are executing step {stepNum}: {stepName}

Previous research results:
{history}

Current task: {stepTask}

Think step-by-step about:
1. What information do I need?
2. What is the logical chain of reasoning?
3. What are the knowledge gaps?

Provide your research findings and reasoning:`,
);

// --- Research Execution ---
const researchPrompt = ChatPromptTemplate.fromTemplate(
  `Execute this research step:

Step: {stepName}
Task: {stepTask}

Provide concise research findings:`,
);

// --- Synthesis ---
const synthesisPrompt = ChatPromptTemplate.fromTemplate(
  `You are the Chief Investment Strategist. Synthesize all research findings into a coherent investment recommendation.

Research History:
{history}

User Question: {query}

Provide:
1. Executive Summary
2. Key Findings from each research area
3. Investment Recommendation
4. Risk Factors
5. Recommended Actions`,
);

// --- Chains ---
const planningChain = planningPrompt.pipe(llm).pipe(new StringOutputParser());
const cotChain = cotPrompt.pipe(llm).pipe(new StringOutputParser());
const researchChain = researchPrompt.pipe(llm).pipe(new StringOutputParser());
const synthesisChain = synthesisPrompt.pipe(llm).pipe(new StringOutputParser());

// --- Planning + CoT Execution ---
async function deepResearch(query) {
  console.log(`\n=== Deep Research: ${query} ===`);

  // Phase 1: Create Plan
  console.log('\n[Planning Phase] Creating research plan...');
  const plan = await planningChain.invoke({ query });
  const steps = plan.split('\n').filter((s) => s.trim());
  console.log('Plan:', steps);

  // Phase 2: Execute with CoT
  let history = [];
  for (let i = 0; i < steps.length; i++) {
    const stepName = steps[i].replace(/^\d+\.\s*/, '').trim();
    console.log(`\n[Research Phase ${i + 1}] ${stepName}`);

    // Chain of Thought
    const cot = await cotChain.invoke({
      stepNum: i + 1,
      stepName,
      stepTask: stepName,
      history: history.join('\n\n'),
    });
    console.log('CoT Reasoning:', cot.substring(0, 200), '...');

    // Execute research
    const result = await researchChain.invoke({
      stepName,
      stepTask: stepName,
    });
    console.log('Research Result:', result.substring(0, 150), '...');

    history.push(`Step ${i + 1} - ${stepName}: ${result}`);
  }

  // Phase 3: Synthesis
  console.log('\n[Synthesis Phase] Generating final recommendation...');
  const finalReport = await synthesisChain.invoke({
    history: history.join('\n\n---\n\n'),
    query,
  });

  console.log('\n=== Final Investment Report ===');
  console.log(finalReport);

  return finalReport;
}

// --- Usage ---
const complexQuery =
  '考虑到最近中东局势升级和美联储可能推迟降息，我应该如何调整我的新能源汽车股票仓位？';

deepResearch(complexQuery);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ model: 'gpt-4o', temperature: 0.5 });

// --- Portfolio Data ---
const userPortfolio = [
  { symbol: 'AAPL', shares: 100, value: 17850, sector: 'Technology' },
  { symbol: 'MSFT', shares: 50, value: 18945, sector: 'Technology' },
  { symbol: 'NVDA', shares: 30, value: 14760, sector: 'Technology' },
  { symbol: 'GOOGL', shares: 40, value: 5672, sector: 'Technology' },
  { symbol: 'TSLA', shares: 20, value: 4960, sector: 'Consumer/Ev' },
];

// --- Phase 1: Analyze Portfolio ---
const analyzePortfolioPrompt = ChatPromptTemplate.fromTemplate(
  `Analyze this investment portfolio for risks:

Portfolio:
{portfolio}

Identify:
1. Sector concentration risk
2. Individual position size risks
3. Correlation risks
4. Any obvious imbalances`,
);

// --- Phase 2: Generate Hedging Strategy ---
const hedgingStrategyPrompt = ChatPromptTemplate.fromTemplate(
  `Based on the portfolio analysis:

Analysis:
{analysis}

Generate a hedging strategy that includes:
1. Low-correlation assets to add
2. Defensive sector recommendations
3. Specific hedging instruments (ETFs, options)

Note: If recommending ETFs, verify they are currently trading.`,
);

// --- Phase 3: Adaptability Check ---
const adaptabilityCheckPrompt = ChatPromptTemplate.fromTemplate(
  `You encountered an issue while executing the hedging strategy.

Original Recommendation:
{originalRec}

Issue:
{issue}

Adapt and provide an alternative strategy that works around this constraint.
Explain your reasoning.`,
);

// --- Phase 4: Final Recommendations ---
const finalRecPrompt = ChatPromptTemplate.fromTemplate(
  `Compile the final investment strategy:

Portfolio Analysis:
{analysis}

Hedging Strategy:
{strategy}

Final adaptations:
{adaptations}

Provide a complete strategy document with specific actionable recommendations.`,
);

// --- Chains ---
const analyzeChain = analyzePortfolioPrompt.pipe(llm).pipe(new StringOutputParser());
const hedgingChain = hedgingStrategyPrompt.pipe(llm).pipe(new StringOutputParser());
const adaptChain = adaptabilityCheckPrompt.pipe(llm).pipe(new StringOutputParser());
const finalChain = finalRecPrompt.pipe(llm).pipe(new StringOutputParser());

// --- Portfolio Diagnosis with Planning ---
async function diagnosePortfolio() {
  console.log('\n=== Portfolio Diagnosis & Strategy ===\n');

  // Step 1: Analyze portfolio
  console.log('[Step 1] Analyzing portfolio...');
  const analysis = await analyzeChain.invoke({
    portfolio: JSON.stringify(userPortfolio, null, 2),
  });
  console.log('Analysis:', analysis.substring(0, 200), '...');

  // Step 2: Generate hedging strategy
  console.log('\n[Step 2] Generating hedging strategy...');
  let strategy = await hedgingChain.invoke({ analysis });
  console.log('Strategy:', strategy.substring(0, 200), '...');

  // Step 3: Simulate constraint/adaptability
  // Simulate finding that recommended ETF is delisted
  const simulatedIssue = "Recommended ETF 'ARKK' has been delisted and is no longer tradable";
  const simulatedOriginalRec = 'Add ARKK for innovation sector exposure';

  if (strategy.includes('ARKK') || strategy.toLowerCase().includes('arkk')) {
    console.log('\n[Adaptability Check] Detected issue with recommendation...');
    const adaptations = await adaptChain.invoke({
      originalRec: simulatedOriginalRec,
      issue: simulatedIssue,
    });
    console.log('Adapted Strategy:', adaptations);

    // Update strategy with adaptation
    strategy = adaptations;
  }

  // Step 4: Final recommendations
  console.log('\n[Step 4] Compiling final strategy...');
  const finalRec = await finalChain.invoke({
    analysis,
    strategy,
    adaptations: strategy.includes('Adapt')
      ? 'Replaced delisted ETF with QQQ'
      : 'No adaptations needed',
  });

  console.log('\n=== Final Investment Strategy ===');
  console.log(finalRec);

  return finalRec;
}

diagnosePortfolio();