// Cost tracking and analysis for agent operations
// 智能体运营的成本跟踪与分析
import { ChatOpenAI } from "@langchain/openai";

// Cost categories
// 成本类别
enum CostCategory {
  API_CALLS = "api_calls",
  COMPUTE = "compute",
  STORAGE = "storage",
  HUMAN_OVERSIGHT = "human_oversight",
  INTEGRATION = "integration",
  MAINTENANCE = "maintenance"
}

// Cost entry
// 成本条目
interface CostEntry {
  id: string;
  category: CostCategory;
  amount: number;
  currency: string;
  timestamp: number;
  description: string;
  metadata?: Record<string, any>;
}

// Cost analytics
// 成本分析
class CostTracker {
  private costs: CostEntry[] = [];
  private budgets: Map<string, { limit: number; period: string }> = new Map();

  // Track a cost
  trackCost(category: CostCategory, amount: number, description: string, metadata?: Record<string, any>): void {
    const entry: CostEntry = {
      id: `cost-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
      category,
      amount,
      currency: "USD",
      timestamp: Date.now(),
      description,
      metadata
    };

    this.costs.push(entry);
    console.log(`[Cost] ${category}: $${amount.toFixed(2)} - ${description}`);
  }

  // Get costs by category
  getCostsByCategory(category?: CostCategory): CostEntry[] {
    if (category) {
      return this.costs.filter(c => c.category === category);
    }
    return [...this.costs];
  }

  // Calculate total cost
  getTotalCost(startDate?: Date, endDate?: Date): number {
    let filtered = this.costs;

    if (startDate) {
      filtered = filtered.filter(c => c.timestamp >= startDate.getTime());
    }
    if (endDate) {
      filtered = filtered.filter(c => c.timestamp <= endDate.getTime());
    }

    return filtered.reduce((sum, c) => sum + c.amount, 0);
  }

  // Get cost breakdown by category
  getCostBreakdown(): Record<string, number> {
    const breakdown: Record<string, number> = {};

    for (const cost of this.costs) {
      breakdown[cost.category] = (breakdown[cost.category] || 0) + cost.amount;
    }

    return breakdown;
  }

  // Calculate cost per task
  getCostPerTask(): number {
    const taskCount = this.costs.filter(c => c.metadata?.taskId).length;
    return taskCount > 0 ? this.getTotalCost() / taskCount : 0;
  }

  // Budget management
  setBudget(category: string, limit: number, period: string): void {
    this.budgets.set(category, { limit, period });
    console.log(`[Budget] Set ${category} budget: $${limit}/${period}`);
  }

  // Check budget status
  checkBudget(category: string): { remaining: number; percentUsed: number; isOverBudget: boolean } {
    const budget = this.budgets.get(category);
    if (!budget) {
      return { remaining: 0, percentUsed: 0, isOverBudget: false };
    }

    const spent = this.getCostsByCategory(category as CostCategory)
      .reduce((sum, c) => sum + c.amount, 0);

    const remaining = budget.limit - spent;
    const percentUsed = (spent / budget.limit) * 100;

    return {
      remaining: Math.max(0, remaining),
      percentUsed,
      isOverBudget: spent > budget.limit
    };
  }

  // Generate cost report
  generateReport(period: { start: Date; end: Date }): any {
    const costs = this.costs.filter(c =>
      c.timestamp >= period.start.getTime() && c.timestamp <= period.end.getTime()
    );

    return {
      period,
      totalCost: costs.reduce((sum, c) => sum + c.amount, 0),
      byCategory: this.getCostBreakdown(),
      transactionCount: costs.length,
      avgCostPerTransaction: costs.length > 0
        ? costs.reduce((sum, c) => sum + c.amount, 0) / costs.length
        : 0,
      budgetStatus: Object.fromEntries(
        Array.from(this.budgets.entries()).map(([cat, budget]) => [
          cat,
          this.checkBudget(cat)
        ])
      )
    };
  }
}

// Cost model for agent operations
// 智能体运营的成本模型
class AgentCostModel {
  private costTracker: CostTracker;

  // API cost rates (per 1K tokens)
  // API成本费率（每1K令牌）
  private apiRates = {
    gpt4: { input: 0.03, output: 0.06 },
    gpt35: { input: 0.001, output: 0.002 },
    embedding: 0.0001
  };

  constructor(costTracker: CostTracker) {
    this.costTracker = costTracker;
  }

  // Calculate API cost
  calculateAPICost(model: string, inputTokens: number, outputTokens: number): number {
    const rates = this.apiRates[model as keyof typeof this.apiRates];
    if (!rates) return 0;

    const inputCost = (inputTokens / 1000) * rates.input;
    const outputCost = (outputTokens / 1000) * rates.output;

    return inputCost + outputCost;
  }

  // Track agent operation cost
  trackOperation(
    operationType: string,
    model: string,
    inputTokens: number,
    outputTokens: number,
    computeSeconds: number
  ): void {
    // API cost
    const apiCost = this.calculateAPICost(model, inputTokens, outputTokens);
    this.costTracker.trackCost(
      CostCategory.API_CALLS,
      apiCost,
      `${operationType} - API calls`,
      { model, inputTokens, outputTokens }
    );

    // Compute cost ($0.01 per second of compute)
    const computeCost = computeSeconds * 0.01;
    this.costTracker.trackCost(
      CostCategory.COMPUTE,
      computeCost,
      `${operationType} - Compute`,
      { computeSeconds }
    );
  }
}

// Example usage: 创建示例
const costTracker = new CostTracker();
const costModel = new AgentCostModel(costTracker);

// Track some operations
costModel.trackOperation("research_task", "gpt4", 2000, 1500, 5);
costModel.trackOperation("analysis_task", "gpt35", 5000, 2000, 2);

// Set budgets
costTracker.setBudget(CostCategory.API_CALLS, 1000, "month");
costTracker.setBudget(CostCategory.COMPUTE, 200, "month");

// Generate report
console.log("\n=== Cost Report ===");
const report = costTracker.generateReport({
  start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
  end: new Date()
});
console.log(JSON.stringify(report, null, 2));

// ROI calculator for agent investments
// 智能体投资的投资回报率计算器
import { ChatOpenAI } from "@langchain/openai";

// Investment parameters
// 投资参数
interface InvestmentParams {
  developmentCost: number;
  monthlyOperationalCost: number;
  expectedLifespanMonths: number;
  hoursSavedPerMonth: number;
  hourlyLaborRate: number;
  revenueIncreasePercent: number;
  baselineRevenue: number;
}

// ROI metrics
// 投资回报率指标
interface ROIMetrics {
  totalInvestment: number;
  totalBenefits: number;
  netValue: number;
  roi: number;
  paybackPeriodMonths: number;
  monthlySavings: number;
  annualSavings: number;
  breakEvenPoint: number;
}

// ROI Calculator
// 投资回报率计算器
class ROICalculator {
  // Calculate full ROI metrics
  calculateROI(params: InvestmentParams): ROIMetrics {
    // Total investment (development + operational over lifespan)
    const totalOperationalCost = params.monthlyOperationalCost * params.expectedLifespanMonths;
    const totalInvestment = params.developmentCost + totalOperationalCost;

    // Calculate benefits
    // Labor savings
    const monthlySavings = params.hoursSavedPerMonth * params.hourlyLaborRate;
    const annualSavings = monthlySavings * 12;
    const totalLaborSavings = monthlySavings * params.expectedLifespanMonths;

    // Revenue increase
    const monthlyRevenueIncrease = params.baselineRevenue * (params.revenueIncreasePercent / 100);
    const annualRevenueIncrease = monthlyRevenueIncrease * 12;
    const totalRevenueIncrease = monthlyRevenueIncrease * params.expectedLifespanMonths;

    // Total benefits
    const totalBenefits = totalLaborSavings + totalRevenueIncrease;

    // Net value
    const netValue = totalBenefits - totalInvestment;

    // ROI percentage
    const roi = (netValue / totalInvestment) * 100;

    // Payback period (in months)
    const monthlyNetBenefit = monthlySavings + monthlyRevenueIncrease - params.monthlyOperationalCost;
    const paybackPeriodMonths = monthlyNetBenefit > 0
      ? params.developmentCost / monthlyNetBenefit
      : Infinity;

    // Break-even point
    const breakEvenPoint = monthlyNetBenefit > 0
      ? params.developmentCost / monthlyNetBenefit
      : -1;

    return {
      totalInvestment,
      totalBenefits,
      netValue,
      roi,
      paybackPeriodMonths: Math.ceil(paybackPeriodMonths),
      monthlySavings,
      annualSavings,
      breakEvenPoint: Math.ceil(breakEvenPoint)
    };
  }

  // Compare multiple agent investments
  compareInvestments(investments: { name: string; params: InvestmentParams }[]): any[] {
    return investments.map(inv => ({
      name: inv.name,
      metrics: this.calculateROI(inv.params)
    }));
  }

  // Sensitivity analysis
  sensitivityAnalysis(
    baseParams: InvestmentParams,
    variable: keyof InvestmentParams,
    ranges: number[]
  ): any[] {
    return ranges.map(value => {
      const params = { ...baseParams, [variable]: value };
      const metrics = this.calculateROI(params);
      return { [variable]: value, metrics };
    });
  }

  // Generate recommendation
  generateRecommendation(metrics: ROIMetrics): string {
    if (metrics.roi > 100 && metrics.paybackPeriodMonths < 6) {
      return "Highly recommended - excellent ROI and quick payback";
    } else if (metrics.roi > 50 && metrics.paybackPeriodMonths < 12) {
      return "Recommended - good ROI with reasonable payback";
    } else if (metrics.roi > 0 && metrics.paybackPeriodMonths < 24) {
      return "Consider - positive ROI but longer payback period";
    } else if (metrics.roi > 0) {
      return "Risky - positive but marginal ROI with long payback";
    } else {
      return "Not recommended - negative ROI";
    }
  }
}

// Example: ROI calculation for customer service agent
// 示例：客户服务智能体的投资回报率计算
function demoROI() {
  const calculator = new ROICalculator();

  // Scenario: Deploying a customer service agent
  // 场景：部署客户服务智能体
  const agentInvestment = {
    developmentCost: 50000, // One-time development cost
    monthlyOperationalCost: 2000, // API costs, maintenance
    expectedLifespanMonths: 36, // 3-year lifespan
    hoursSavedPerMonth: 200, // 2 FTEs freed up
    hourlyLaborRate: 50, // $50/hour average labor cost
    revenueIncreasePercent: 5, // 5% revenue increase from better service
    baselineRevenue: 1000000 // $1M monthly revenue
  };

  const metrics = calculator.calculateROI(agentInvestment);

  console.log("=== ROI Analysis: Customer Service Agent ===\n");
  console.log(`Total Investment: $${metrics.totalInvestment.toLocaleString()}`);
  console.log(`Total Benefits: $${metrics.totalBenefits.toLocaleString()}`);
  console.log(`Net Value: $${metrics.netValue.toLocaleString()}`);
  console.log(`ROI: ${metrics.roi.toFixed(1)}%`);
  console.log(`Payback Period: ${metrics.paybackPeriodMonths} months`);
  console.log(`Monthly Savings: $${metrics.monthlySavings.toLocaleString()}`);
  console.log(`Annual Savings: $${metrics.annualSavings.toLocaleString()}`);
  console.log(`\nRecommendation: ${calculator.generateRecommendation(metrics)}`);

  // Sensitivity analysis on labor rate
  console.log("\n=== Sensitivity Analysis: Hourly Labor Rate ===");
  const sensitivity = calculator.sensitivityAnalysis(
    agentInvestment,
    "hourlyLaborRate",
    [30, 40, 50, 60, 70, 80]
  );

  sensitivity.forEach(s => {
    console.log(`$${s.hourlyLaborRate}/hr -> ROI: ${s.metrics.roi.toFixed(1)}%, Payback: ${s.metrics.paybackPeriodMonths}mo`);
  });
}

demoROI();

// Usage-based pricing model for agent services
// 智能体服务的基于使用量的定价模型
import { ChatOpenAI } from "@langchain/openai";

// Pricing tiers
// 定价层级
interface PricingTier {
  name: string;
  monthlyFee: number;
  includedOperations: number;
  overageRate: number;
  features: string[];
}

// Usage record
// 使用量记录
interface UsageRecord {
  userId: string;
  tier: string;
  operations: number;
  period: string;
  cost: number;
}

// Usage-based pricing engine
// 基于使用量的定价引擎
class UsagePricingEngine {
  private tiers: Map<string, PricingTier> = new Map();
  private usage: Map<string, UsageRecord[]> = new Map();

  // Define pricing tiers
  defineTiers(tiers: PricingTier[]): void {
    tiers.forEach(tier => {
      this.tiers.set(tier.name, tier);
      console.log(`[Pricing] Defined tier: ${tier.name} - $${tier.monthlyFee}/mo`);
    });
  }

  // Record usage
  recordUsage(userId: string, tierName: string, operations: number, period: string): void {
    const tier = this.tiers.get(tierName);
    if (!tier) throw new Error(`Tier not found: ${tierName}`);

    // Calculate cost
    const included = tier.includedOperations;
    const overage = Math.max(0, operations - included);
    const overageCost = overage * tier.overageRate;
    const totalCost = tier.monthlyFee + overageCost;

    // Store record
    const record: UsageRecord = {
      userId,
      tier: tierName,
      operations,
      period,
      cost: totalCost
    };

    const existing = this.usage.get(userId) || [];
    existing.push(record);
    this.usage.set(userId, existing);

    console.log(`[Usage] User ${userId}: ${operations} ops = $${totalCost.toFixed(2)}`);
  }

  // Get user billing
  getUserBilling(userId: string): any {
    const records = this.usage.get(userId) || [];
    const totalCost = records.reduce((sum, r) => sum + r.cost, 0);

    return {
      userId,
      periods: records,
      totalBilled: totalCost,
      averagePerPeriod: records.length > 0 ? totalCost / records.length : 0
    };
  }

  // Calculate LTV (Lifetime Value)
  calculateLTV(userId: string, avgMonths: number): number {
    const billing = this.getUserBilling(userId);
    return billing.averagePerPeriod * avgMonths;
  }

  // Revenue report
  getRevenueReport(): any {
    const allRecords = Array.from(this.usage.values()).flat();

    return {
      totalRevenue: allRecords.reduce((sum, r) => sum + r.cost, 0),
      totalTransactions: allRecords.reduce((sum, r) => sum + r.operations, 0),
      averageRevenuePerUser: allRecords.length > 0
        ? allRecords.reduce((sum, r) => sum + r.cost, 0) / this.usage.size
        : 0,
      byTier: this.getRevenueByTier()
    };
  }

  private getRevenueByTier(): Record<string, number> {
    const byTier: Record<string, number> = {};
    const allRecords = Array.from(this.usage.values()).flat();

    allRecords.forEach(r => {
      byTier[r.tier] = (byTier[r.tier] || 0) + r.cost;
    });

    return byTier;
  }
}

// Subscription + usage model
// 订阅+使用量模式
class HybridPricingModel {
  private baseSubscription: number = 99; // Base monthly fee
  private usageRates = {
    simple: 0.01,    // $0.01 per operation
    standard: 0.005, // $0.005 per operation
    premium: 0.001   // $0.001 per operation
  };

  // Calculate price
  calculatePrice(operations: number, tier: "simple" | "standard" | "premium"): number {
    const rate = this.usageRates[tier];
    const usageCost = operations * rate;
    return this.baseSubscription + usageCost;
  }

  // Generate invoice
  generateInvoice(userId: string, operations: number, tier: "simple" | "standard" | "premium"): any {
    const price = this.calculatePrice(operations, tier);
    const rate = this.usageRates[tier];

    return {
      userId,
      period: new Date().toISOString().slice(0, 7),
      subscription: this.baseSubscription,
      operations,
      rate,
      usageCost: operations * rate,
      total: price,
      currency: "USD"
    };
  }
}

// Example usage: 创建示例
const pricingEngine = new UsagePricingEngine();

// Define tiers
pricingEngine.defineTiers([
  {
    name: "starter",
    monthlyFee: 29,
    includedOperations: 1000,
    overageRate: 0.02,
    features: ["basic_agents", "email_support"]
  },
  {
    name: "professional",
    monthlyFee: 99,
    includedOperations: 10000,
    overageRate: 0.01,
    features: ["advanced_agents", "priority_support", "analytics"]
  },
  {
    name: "enterprise",
    monthlyFee: 499,
    includedOperations: 100000,
    overageRate: 0.005,
    features: ["custom_agents", "24/7_support", "full_analytics", "sla"]
  }
]);

// Record usage
pricingEngine.recordUsage("user-1", "starter", 1500, "2024-01");
pricingEngine.recordUsage("user-2", "professional", 8500, "2024-01");
pricingEngine.recordUsage("user-3", "enterprise", 95000, "2024-01");

// Revenue report
console.log("\n=== Revenue Report ===");
console.log(pricingEngine.getRevenueReport());

// Hybrid pricing example
const hybrid = new HybridPricingModel();
const invoice = hybrid.generateInvoice("user-1", 5000, "standard");
console.log("\n=== Invoice ===");
console.log(invoice);

// Business model canvas for AI agent services
// AI智能体服务的商业模式画布
import { ChatOpenAI } from "@langchain/openai";

// Agent business model canvas
// 智能体商业模式画布
class AgentBusinessModelCanvas {
  // Value Propositions
  // 价值主张
  valuePropositions: string[] = [];
  customerJobs: string[] = [];
  painRelievers: string[] = [];
  gainCreators: string[] = [];

  // Customer Segments
  // 客户细分
  customerSegments: string[] = [];
  customerRelationships: string[] = [];
  channels: string[] = [];

  // Revenue Streams
  // 收入来源
  revenueStreams: {
    type: string;
    pricingModel: string;
    price: number;
    description: string;
  }[] = [];

  // Key Resources
  // 关键资源
  keyResources: string[] = [];
  keyActivities: string[] = [];
  keyPartners: string[] = [];

  // Cost Structure
  // 成本结构
  fixedCosts: { category: string; amount: number }[] = [];
  variableCosts: { category: string; rate: number }[] = [];

  // Add value proposition
  addValueProposition(value: string): void {
    this.valuePropositions.push(value);
  }

  // Add customer segment
  addCustomerSegment(segment: string): void {
    this.customerSegments.push(segment);
  }

  // Add revenue stream
  addRevenueStream(type: string, pricingModel: string, price: number, description: string): void {
    this.revenueStreams.push({ type, pricingModel, price, description });
  }

  // Add cost
  addFixedCost(category: string, amount: number): void {
    this.fixedCosts.push({ category, amount });
  }

  addVariableCost(category: string, rate: number): void {
    this.variableCosts.push({ category, rate });
  }

  // Calculate unit economics
  calculateUnitEconomics(opsPerCustomer: number): any {
    const monthlyRevenue = this.revenueStreams.reduce((sum, rs) => sum + rs.price, 0);
    const monthlyFixedCosts = this.fixedCosts.reduce((sum, fc) => sum + fc.amount, 0);
    const monthlyVariableCosts = this.variableCosts.reduce(
      (sum, vc) => sum + (opsPerCustomer * vc.rate),
      0
    );

    const grossProfit = monthlyRevenue - monthlyVariableCosts;
    const netProfit = grossProfit - monthlyFixedCosts;
    const margin = monthlyRevenue > 0 ? (grossProfit / monthlyRevenue) * 100 : 0;

    return {
      monthlyRevenue,
      monthlyFixedCosts,
      monthlyVariableCosts,
      grossProfit,
      netProfit,
      grossMargin: margin,
      contributionMargin: monthlyVariableCosts > 0
        ? ((monthlyRevenue - monthlyVariableCosts) / monthlyRevenue) * 100
        : 100
    };
  }

  // Generate business model summary
  generateSummary(): any {
    return {
      valuePropositions: this.valuePropositions,
      customerSegments: this.customerSegments,
      revenueStreams: this.revenueStreams,
      costStructure: {
        fixed: this.fixedCosts,
        variable: this.variableCosts
      },
      unitEconomics: this.calculateUnitEconomics(1000)
    };
  }
}

// Example: SaaS Agent Platform Business Model
// 示例：SaaS智能体平台商业模式
function demoBusinessModel() {
  const canvas = new AgentBusinessModelCanvas();

  // Value Propositions
  canvas.addValueProposition("24/7 automated customer support");
  canvas.addValueProposition("80% reduction in response time");
  canvas.addValueProposition("Seamless human handoff");
  canvas.addValueProposition("Multi-language support");

  // Customer Segments
  canvas.addCustomerSegment("E-commerce companies");
  canvas.addCustomerSegment("SaaS businesses");
  canvas.addCustomerSegment("Financial services");

  // Revenue Streams
  canvas.addRevenueStream("subscription", "monthly", 299, "Basic plan");
  canvas.addRevenueStream("subscription", "monthly", 799, "Pro plan");
  canvas.addRevenueStream("usage", "per_interaction", 0.05, "Additional interactions");
  canvas.addRevenueStream("professional_services", "one_time", 5000, "Implementation");

  // Cost Structure
  canvas.addFixedCost("engineering", 25000);
  canvas.addFixedCost("infrastructure", 5000);
  canvas.addFixedCost("marketing", 10000);
  canvas.addFixedCost("support", 8000);
  canvas.addVariableCost("api_calls", 0.002);
  canvas.addVariableCost("human_handoff", 15);

  // Generate summary
  console.log("=== Business Model Canvas ===\n");
  const summary = canvas.generateSummary();

  console.log("Value Propositions:");
  summary.valuePropositions.forEach(vp => console.log(`  - ${vp}`));

  console.log("\nCustomer Segments:");
  summary.customerSegments.forEach(cs => console.log(`  - ${cs}`));

  console.log("\nRevenue Streams:");
  summary.revenueStreams.forEach(rs => {
    console.log(`  - ${rs.type}: $${rs.price} (${rs.pricingModel}) - ${rs.description}`);
  });

  console.log("\nUnit Economics (per customer, 1000 ops/mo):");
  const ue = summary.unitEconomics;
  console.log(`  Revenue: $${ue.monthlyRevenue}`);
  console.log(`  Fixed Costs: $${ue.monthlyFixedCosts}`);
  console.log(`  Variable Costs: $${ue.monthlyVariableCosts}`);
  console.log(`  Gross Margin: ${ue.grossMargin.toFixed(1)}%`);
  console.log(`  Net Profit: $${ue.netProfit}`);
}

demoBusinessModel();

// Economic performance metrics for agent operations
// 智能体运营的经济绩效指标
import { ChatOpenAI } from "@langchain/openai";

// Performance metrics
// 绩效指标
interface PerformanceMetrics {
  timestamp: number;
  totalRequests: number;
  successfulRequests: number;
  failedRequests: number;
  totalCost: number;
  revenue: number;
  latency: number;
  userSatisfaction: number;
}

// Metrics collector
// 指标收集器
class EconomicMetricsCollector {
  private metrics: PerformanceMetrics[] = [];

  // Record metrics
  record(metrics: Omit<PerformanceMetrics, "timestamp">): void {
    this.metrics.push({
      ...metrics,
      timestamp: Date.now()
    });
  }

  // Calculate key metrics
  calculateKPIs(): any {
    const recent = this.metrics.slice(-30); // Last 30 data points

    const totalRequests = recent.reduce((sum, m) => sum + m.totalRequests, 0);
    const successfulRequests = recent.reduce((sum, m) => sum + m.successfulRequests, 0);
    const totalCost = recent.reduce((sum, m) => sum + m.totalCost, 0);
    const revenue = recent.reduce((sum, m) => sum + m.revenue, 0);

    return {
      // Operational KPIs
      successRate: totalRequests > 0 ? (successfulRequests / totalRequests) * 100 : 0,
      avgLatency: recent.reduce((sum, m) => sum + m.latency, 0) / recent.length,
      userSatisfaction: recent.reduce((sum, m) => sum + m.userSatisfaction, 0) / recent.length,

      // Financial KPIs
      totalCost,
      totalRevenue,
      grossProfit: revenue - totalCost,
      grossMargin: revenue > 0 ? ((revenue - totalCost) / revenue) * 100 : 0,

      // Efficiency KPIs
      costPerRequest: totalRequests > 0 ? totalCost / totalRequests : 0,
      revenuePerRequest: totalRequests > 0 ? revenue / totalRequests : 0,
      profitPerRequest: totalRequests > 0 ? (revenue - totalCost) / totalRequests : 0
    };
  }

  // Calculate growth metrics
  calculateGrowth(): any {
    if (this.metrics.length < 2) return { growth: 0 };

    const sorted = this.metrics.sort((a, b) => a.timestamp - b.timestamp);
    const midpoint = Math.floor(sorted.length / 2);

    const firstHalf = sorted.slice(0, midpoint);
    const secondHalf = sorted.slice(midpoint);

    const firstRevenue = firstHalf.reduce((sum, m) => sum + m.revenue, 0);
    const secondRevenue = secondHalf.reduce((sum, m) => sum + m.revenue, 0);

    const firstCost = firstHalf.reduce((sum, m) => sum + m.totalCost, 0);
    const secondCost = secondHalf.reduce((sum, m) => sum + m.totalCost, 0);

    const revenueGrowth = firstRevenue > 0 ? ((secondRevenue - firstRevenue) / firstRevenue) * 100 : 0;
    const costGrowth = firstCost > 0 ? ((secondCost - firstCost) / firstCost) * 100 : 0;

    return {
      revenueGrowth,
      costGrowth,
      unitEconomicsImprovement: costGrowth < revenueGrowth
    };
  }

  // Dashboard summary
  getDashboardSummary(): any {
    return {
      kpis: this.calculateKPIs(),
      growth: this.calculateGrowth(),
      health: this.calculateHealthScore()
    };
  }

  private calculateHealthScore(): string {
    const kpis = this.calculateKPIs();

    if (kpis.successRate > 99 && kpis.grossMargin > 70) return "Excellent";
    if (kpis.successRate > 95 && kpis.grossMargin > 50) return "Good";
    if (kpis.successRate > 90 && kpis.grossMargin > 30) return "Fair";
    return "Needs Attention";
  }
}

// Example usage: 创建示例
const collector = new EconomicMetricsCollector();

// Simulate metrics over time
for (let i = 0; i < 30; i++) {
  collector.record({
    totalRequests: 1000 + Math.random() * 500,
    successfulRequests: 950 + Math.random() * 50,
    failedRequests: 10 + Math.random() * 20,
    totalCost: 500 + Math.random() * 100,
    revenue: 800 + Math.random() * 200,
    latency: 200 + Math.random() * 100,
    userSatisfaction: 4 + Math.random()
  });
}

console.log("=== Economic Performance Dashboard ===\n");
const dashboard = collector.getDashboardSummary();

console.log("KPIs:");
console.log(`  Success Rate: ${dashboard.kpis.successRate.toFixed(2)}%`);
console.log(`  Gross Margin: ${dashboard.kpis.grossMargin.toFixed(2)}%`);
console.log(`  Cost per Request: $${dashboard.kpis.costPerRequest.toFixed(4)}`);
console.log(`  Revenue per Request: $${dashboard.kpis.revenuePerRequest.toFixed(4)}`);

console.log("\nGrowth:");
console.log(`  Revenue Growth: ${dashboard.growth.revenueGrowth.toFixed(2)}%`);
console.log(`  Cost Growth: ${dashboard.growth.costGrowth.toFixed(2)}%`);

console.log("\nHealth:", dashboard.health);

// Investment agent with economic analysis capabilities
// 具有经济分析能力的投资智能体
import { ChatOpenAI } from "@langchain/openai";

// Investment economics
// 投资经济学
interface InvestmentEconomics {
  initialInvestment: number;
  expectedReturn: number;
  riskAdjustedReturn: number;
  paybackPeriod: number;
  npv: number;
  irr: number;
}

// Economic analysis for trading strategies
// 交易策略的经济分析
class TradingEconomicsAnalyzer {
  private costTracker: CostTracker;

  constructor(costTracker: CostTracker) {
    this.costTracker = costTracker;
  }

  // Analyze trading strategy economics
  analyzeStrategy(strategy: {
    name: string;
    tradesPerMonth: number;
    avgTradeValue: number;
    winRate: number;
    avgWinLoss: number;
    holdingPeriodDays: number;
  }): InvestmentEconomics {
    // Calculate expected values
    const monthlyTrades = strategy.tradesPerMonth;
    const winsPerMonth = monthlyTrades * strategy.winRate;
    const lossesPerMonth = monthlyTrades * (1 - strategy.winRate);

    const avgWin = strategy.avgTradeValue * strategy.avgWinLoss;
    const avgLoss = strategy.avgTradeValue;

    // Monthly P&L
    const monthlyProfit = (winsPerMonth * avgWin) - (lossesPerMonth * avgLoss);
    const annualProfit = monthlyProfit * 12;

    // Assume $100K initial capital needed
    const initialInvestment = 100000;
    const expectedReturn = (annualProfit / initialInvestment) * 100;

    // Risk-adjusted (simplified Sharpe-like calculation)
    const volatility = Math.sqrt(monthlyTrades * 12) * strategy.avgTradeValue * 0.3;
    const riskAdjustedReturn = volatility > 0 ? expectedReturn / (volatility / initialInvestment) : 0;

    // Payback period
    const paybackPeriod = monthlyProfit > 0 ? initialInvestment / monthlyProfit : Infinity;

    // NPV (assume 10% discount rate)
    const npv = this.calculateNPV(initialInvestment, annualProfit, 5, 0.1);

    // IRR (simplified)
    const irr = this.calculateIRR(initialInvestment, annualProfit, 5);

    return {
      initialInvestment,
      expectedReturn,
      riskAdjustedReturn,
      paybackPeriod: Math.ceil(paybackPeriod),
      npv,
      irr
    };
  }

  private calculateNPV(initial: number, annualCashFlow: number, years: number, discountRate: number): number {
    let npv = -initial;
    for (let i = 1; i <= years; i++) {
      npv += annualCashFlow / Math.pow(1 + discountRate, i);
    }
    return npv;
  }

  private calculateIRR(initial: number, annualCashFlow: number, years: number): number {
    // Simplified IRR calculation
    let low = -1;
    let high = 2;
    let irr = 0;

    for (let i = 0; i < 100; i++) {
      irr = (low + high) / 2;
      const npv = this.calculateNPV(initial, annualCashFlow, years, irr);

      if (Math.abs(npv) < 0.01) break;
      if (npv > 0) low = irr;
      else high = irr;
    }

    return irr * 100;
  }
}

// Investment agent with economic decision making
// 具有经济决策能力的投资智能体
class InvestmentEconomicsAgent {
  private analyzer: TradingEconomicsAnalyzer;
  private roiCalculator: ROICalculator;

  constructor(costTracker: CostTracker) {
    this.analyzer = new TradingEconomicsAnalyzer(costTracker);
    this.roiCalculator = new ROICalculator();
  }

  // Evaluate trading strategy
  evaluateStrategy(strategy: any): { economics: InvestmentEconomics; recommendation: string } {
    const economics = this.analyzer.analyzeStrategy(strategy);

    let recommendation = "";
    if (economics.expectedReturn > 20 && economics.paybackPeriod < 24) {
      recommendation = "Highly recommended";
    } else if (economics.expectedReturn > 10 && economics.paybackPeriod < 36) {
      recommendation = "Recommended";
    } else if (economics.expectedReturn > 0) {
      recommendation = "Consider with caution";
    } else {
      recommendation = "Not recommended";
    }

    return { economics, recommendation };
  }

  // Compare multiple strategies
  compareStrategies(strategies: any[]): any[] {
    return strategies.map(s => ({
      name: s.name,
      ...this.evaluateStrategy(s)
    }));
  }
}

// Example: Run investment economics analysis
// 示例：运行投资经济分析
function demoInvestmentEconomics() {
  const costTracker = new CostTracker();
  const agent = new InvestmentEconomicsAgent(costTracker);

  console.log("=== Investment Economics Analysis ===\n");

  // Compare strategies
  const strategies = [
    {
      name: "High-Frequency Momentum",
      tradesPerMonth: 100,
      avgTradeValue: 10000,
      winRate: 0.55,
      avgWinLoss: 1.5,
      holdingPeriodDays: 1
    },
    {
      name: "Swing Trading",
      tradesPerMonth: 10,
      avgTradeValue: 50000,
      winRate: 0.65,
      avgWinLoss: 2.0,
      holdingPeriodDays: 14
    },
    {
      name: "Long-Term Value",
      tradesPerMonth: 2,
      avgTradeValue: 100000,
      winRate: 0.75,
      avgWinLoss: 3.0,
      holdingPeriodDays: 180
    }
  ];

  const results = agent.compareStrategies(strategies);

  results.forEach(r => {
    console.log(`\n${r.name}:`);
    console.log(`  Expected Return: ${r.economics.expectedReturn.toFixed(1)}%`);
    console.log(`  Risk-Adjusted Return: ${r.economics.riskAdjustedReturn.toFixed(1)}`);
    console.log(`  Payback Period: ${r.economics.paybackPeriod} months`);
    console.log(`  NPV: $${r.economics.npv.toFixed(0)}`);
    console.log(`  IRR: ${r.economics.irr.toFixed(1)}%`);
    console.log(`  Recommendation: ${r.recommendation}`);
  });
}

demoInvestmentEconomics();