// Real-time expense ingestion service
const axios = require('axios');
const { EventEmitter } = require('events');
const PQueue = require('p-queue');

class ExpenseIngestor extends EventEmitter {
  constructor(config) {
    super();
    this.sources = config.sources;
    this.queue = new PQueue({ concurrency: 3 });
    this.processedTransactions = new Set();
  }

  async ingestFromSource(source) {
    const { type, endpoint, apiKey, transform } = source;

    try {
      const response = await axios.get(endpoint, {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      });

      const transactions = transform ?
        response.data.map(transform) :
        response.data;

      for (const tx of transactions) {
        if (!this.processedTransactions.has(tx.id)) {
          await this.processTransaction(tx);
          this.processedTransactions.add(tx.id);
        }
      }
    } catch (error) {
      console.error(`Failed to ingest from ${source.name}:`, error.message);
      this.emit('error', { source: source.name, error });
    }
  }

  async processTransaction(tx) {
    // Normalize currency
    const normalizedTx = {
      id: tx.id,
      amount: this.normalizeAmount(tx.amount, tx.currency),
      category: this.categorizeExpense(tx.description, tx.merchant),
      team: tx.team_id || tx.department,
      user: tx.user_id,
      timestamp: new Date(tx.date),
      source: tx.source
    };

    this.emit('transaction', normalizedTx);
  }

  normalizeAmount(amount, currency) {
    // Convert to base currency (USD)
    const rates = { EUR: 1.08, GBP: 1.27, JPY: 0.0067, CAD: 0.74 };
    return amount * (rates[currency] || 1);
  }

  categorizeExpense(description, merchant) {
    const categories = {
      'aws': 'infrastructure',
      'google cloud': 'infrastructure',
      'slack': 'software',
      'notion': 'software',
      'uber': 'travel',
      'airbnb': 'travel'
    };

    const lowerDesc = (description + merchant).toLowerCase();
    for (const [key, category] of Object.entries(categories)) {
      if (lowerDesc.includes(key)) return category;
    }
    return 'general';
  }

  async start() {
    // Poll each source every 60 seconds
    setInterval(() => {
      this.sources.forEach(source =>
        this.queue.add(() => this.ingestFromSource(source))
      );
    }, 60000);

    // Initial ingestion
    await Promise.all(
      this.sources.map(source =>
        this.queue.add(() => this.ingestFromSource(source))
      )
    );
  }
}

// Usage with multiple data sources
const ingestor = new ExpenseIngestor({
  sources: [
    {
      name: 'expensify',
      endpoint: 'https://api.expensify.com/v1/expenses',
      apiKey: process.env.EXPENSIFY_KEY,
      transform: (tx) => ({
        id: `expense_${tx.transaction_id}`,
        amount: tx.amount,
        currency: tx.currency,
        description: tx.comment,
        merchant: tx.merchant,
        team: tx.tag,
        user: tx.actor_email,
        date: tx.created
      })
    },
    {
      name: 'stripe',
      endpoint: 'https://api.stripe.com/v1/balance_transactions',
      apiKey: process.env.STRIPE_KEY,
      transform: (tx) => ({
        id: `stripe_${tx.id}`,
        amount: tx.amount / 100,
        currency: tx.currency,
        description: tx.description,
        merchant: tx.description,
        team: tx.metadata?.team_id,
        user: tx.metadata?.user_id,
        date: tx.created
      })
    }
  ]
});

ingestor.on('transaction', (tx) => {
  console.log('New transaction:', tx);
  // Push to dashboard update stream
});

// Dashboard data hook with real-time updates
import { useState, useEffect, useMemo } from 'react';
import { createConsumer } from 'pusher-js';

export function useExpenseDashboard(dateRange) {
  const [transactions, setTransactions] = useState([]);
  const [summary, setSummary] = useState({
    total: 0,
    byCategory: {},
    byTeam: {},
    trends: []
  });

  // Load initial data
  useEffect(() => {
    fetch(`/api/expenses?from=${dateRange.start}&to=${dateRange.end}`)
      .then(res => res.json())
      .then(data => {
        setTransactions(data.transactions);
        setSummary(calculateSummary(data.transactions));
      });
  }, [dateRange]);

  // Subscribe to real-time updates
  useEffect(() => {
    const consumer = new Consumer('dashboard-pusher-key');
    const channel = consumer.subscribe('expense-updates');

    channel.bind('new-transaction', (tx) => {
      setTransactions(prev => [tx, ...prev]);
      setSummary(prev => updateSummary(prev, tx));
    });

    return () => consumer.disconnect();
  }, []);

  const calculateSummary = (txs) => {
    const byCategory = {};
    const byTeam = {};
    let total = 0;

    for (const tx of txs) {
      total += tx.amount;
      byCategory[tx.category] = (byCategory[tx.category] || 0) + tx.amount;
      byTeam[tx.team] = (byTeam[tx.team] || 0) + tx.amount;
    }

    return { total, byCategory, byTeam };
  };

  return { transactions, summary };
}

// Budget alert configuration
export const BudgetAlert = ({ threshold, current, category }) => {
  const percentage = (current / threshold) * 100;
  const color = percentage > 90 ? '#ef4444' : percentage > 75 ? '#f59e0b' : '#22c55e';

  return (
    <div className="budget-alert">
      <div className="label">{category} Budget</div>
      <div className="progress-bar">
        <div
          className="fill"
          style={{ width: `${Math.min(percentage, 100)}%`, background: color }}
        />
      </div>
      <div className="details">
        ${current.toLocaleString()} / ${threshold.toLocaleString()} ({percentage.toFixed(1)}%)
      </div>
    </div>
  );
};

// Simple anomaly detection
function detectAnomalies(transactions, category) {
  const categoryTxns = transactions.filter(t => t.category === category);
  const amounts = categoryTxns.map(t => t.amount);

  const mean = amounts.reduce((a, b) => a + b, 0) / amounts.length;
  const stdDev = Math.sqrt(
    amounts.reduce((sq, n) => sq + Math.pow(n - mean, 2), 0) / amounts.length
  );

  return categoryTxns.filter(t =>
    Math.abs(t.amount - mean) > (2.5 * stdDev)
  );
}