agent.js

const OpenAI = require('openai');
const fs = require('fs');

// 检查必需的环境变量
const isTestMode = process.env.OPENAI_API_KEY === 'test_key_for_local_development';
if (!process.env.OPENAI_API_KEY && !isTestMode) {
  console.error('Error: OPENAI_API_KEY environment variable is required');
  process.exit(1);
}

// 初始化OpenAI客户端
const openai = isTestMode 
  ? null 
  : new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });

// 加载产品数据
let productsData, categoriesData;
try {
  productsData = JSON.parse(fs.readFileSync('./products.json', 'utf8'));
  categoriesData = JSON.parse(fs.readFileSync('./categories.json', 'utf8'));
  console.log(`Loaded ${productsData.length} product categories`);
} catch (error) {
  console.error('Error loading product data:', error.message);
  console.error('Please ensure products.json and categories.json exist');
  process.exit(1);
}

// 意图识别函数
async function classifyIntent(userInput) {
  // 在测试模式下使用简单的关键词匹配
  if (isTestMode) {
    const input = userInput.toLowerCase();
    if (input.includes('compare') || input.includes('vs') || input.includes('versus')) {
      return 'product_comparison';
    } else if (input.includes('spec') || input.includes('speed') || input.includes('port')) {
      return 'spec_query';
    } else if (input.includes('feature') || input.includes('function')) {
      return 'feature_query';
    } else if (input.includes('recommend') || input.includes('need') || input.includes('looking')) {
      return 'product_recommendation';
    }
    return 'unknown';
  }

  const prompt = `You are a professional AI assistant for TP-Link's official website, specialized in recommending, comparing, and explaining TP-Link networking products.

Classify the user's intent into one of the following categories:
- product_recommendation: User wants product recommendations based on their needs
- product_comparison: User wants to compare products
- spec_query: User wants to know product specifications
- feature_query: User wants to know about product features
- service_query: User asks about services like HomeShield, Tapo Care
- topic_redirect: User wants to be redirected to specific topics
- unknown: Cannot determine intent

User input: "${userInput}"

Respond with only the intent category.`;

  try {
    const response = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [{ role: 'user', content: prompt }],
      max_tokens: 50,
      temperature: 0.1
    });
    return response.choices[0].message.content.trim();
  } catch (error) {
    console.error('Intent classification error:', error);
    return 'unknown';
  }
}

// 产品推荐工具
function productRecommendation(query) {
  const recommendations = [];
  
  // 简单的关键词匹配逻辑
  const keywords = query.toLowerCase().split(' ');
  
  for (const category of productsData) {
    for (const product of category.products) {
      let score = 0;
      
      // 检查产品名称和描述中的关键词匹配
      const productText = `${product.name} ${product.description || ''}`.toLowerCase();
      
      for (const keyword of keywords) {
        if (productText.includes(keyword)) {
          score += 1;
        }
      }
      
      if (score > 0) {
        recommendations.push({
          name: product.name,
          category: category.category,
          description: product.description,
          url: product.url,
          score: score
        });
      }
    }
  }
  
  // 按匹配度排序，返回前3个推荐
  return recommendations
    .sort((a, b) => b.score - a.score)
    .slice(0, 3);
}

// 产品对比工具
function compareProducts(productNames) {
  const products = [];
  
  for (const name of productNames) {
    for (const category of productsData) {
      const product = category.products.find(p => {
        const productName = p.name.toLowerCase();
        const searchName = name.toLowerCase();
        return productName.includes(searchName) || 
               productName.includes('be' + searchName.replace('be', '')) ||
               (searchName.includes('be65') && productName.includes('be11000')) ||
               (searchName.includes('be95') && productName.includes('be33000'));
      });
      if (product) {
        products.push(product);
        break;
      }
    }
  }
  
  if (products.length < 2) {
    return { error: 'Need at least 2 products to compare' };
  }
  
  // 创建对比表
  const comparison = {
    products: products.map(p => ({
      name: p.name,
      category: p.category,
      url: p.url,
      specs: p.specs || {}
    })),
    comparison: {}
  };
  
  // 对比关键规格
  const keySpecs = ['WiFi Speeds', 'WiFi Range', 'Ethernet Ports', 'Working Modes'];
  for (const spec of keySpecs) {
    comparison.comparison[spec] = {};
    for (const product of products) {
      comparison.comparison[spec][product.name] = product.specs[spec] || 'N/A';
    }
  }
  
  return comparison;
}

// 规格查询工具
function querySpec(model, spec) {
  for (const category of productsData) {
    for (const product of category.products) {
      const productName = product.name.toLowerCase();
      const searchModel = model.toLowerCase();
      if (productName.includes(searchModel) || 
          (searchModel.includes('be65') && productName.includes('be11000')) ||
          (searchModel.includes('be95') && productName.includes('be33000'))) {
        if (spec) {
          return {
            product: product.name,
            spec: spec,
            value: product.specs[spec] || 'Not found'
          };
        } else {
          return {
            product: product.name,
            specs: product.specs
          };
        }
      }
    }
  }
  return { error: 'Product not found' };
}

// 功能查询工具
function queryFeatures(model, feature) {
  for (const category of productsData) {
    for (const product of category.products) {
      const productName = product.name.toLowerCase();
      const searchModel = model.toLowerCase();
      if (productName.includes(searchModel) || 
          (searchModel.includes('be65') && productName.includes('be11000')) ||
          (searchModel.includes('be95') && productName.includes('be33000'))) {
        if (feature) {
          // 检查功能是否在features数组中
          const hasFeature = product.features.some(f => 
            f.toLowerCase().includes(feature.toLowerCase())
          );
          return {
            product: product.name,
            feature: feature,
            hasFeature: hasFeature,
            features: product.features
          };
        } else {
          return {
            product: product.name,
            features: product.features
          };
        }
      }
    }
  }
  return { error: 'Product not found' };
}

// 主Agent函数
async function processUserQuery(userInput) {
  try {
    // 1. 意图识别
    const intent = await classifyIntent(userInput);
    console.log('Detected intent:', intent);
    
    // 2. 根据意图调用相应工具
    let result;
    switch (intent) {
      case 'product_recommendation':
        result = productRecommendation(userInput);
        break;
      case 'product_comparison':
        // 提取产品名称进行对比
        const productNames = userInput.match(/BE[0-9]+/g) || 
                           userInput.match(/Deco\s+[A-Z0-9]+/g) || 
                           userInput.match(/[A-Z][A-Za-z0-9\s-]+/g) || [];
        result = compareProducts(productNames);
        break;
      case 'spec_query':
        // 提取型号和规格
        const specMatch = userInput.match(/(BE[0-9]+)/i);
        if (specMatch) {
          result = querySpec(specMatch[1], 'WiFi Speeds');
        } else {
          result = { error: 'Please specify product model and specification' };
        }
        break;
      case 'feature_query':
        // 简单提取型号和功能
        const featureMatch = userInput.match(/([A-Z][A-Za-z0-9\s-]+).*?(feature|function|capability)/i);
        if (featureMatch) {
          result = queryFeatures(featureMatch[1], featureMatch[2]);
        } else {
          result = { error: 'Please specify product model and feature' };
        }
        break;
      default:
        result = { error: 'I cannot understand your request. Please try rephrasing.' };
    }
    
    return {
      intent: intent,
      result: result
    };
    
  } catch (error) {
    console.error('Agent processing error:', error);
    return {
      intent: 'error',
      result: { error: 'An error occurred while processing your request.' }
    };
  }
}

module.exports = {
  processUserQuery,
  productRecommendation,
  compareProducts,
  querySpec,
  queryFeatures
};