import { FraudDetector, Transaction } from 'fraud-catcher';

// Initialize with all 9 algorithms
const detector = new FraudDetector({
  rules: ['velocity', 'amount', 'location', 'device', 'time', 'merchant', 'behavioral', 'network', 'ml'],
  thresholds: {
    velocity: 0.8,
    amount: 0.9,
    location: 0.7,
    device: 0.6,
    time: 0.5,
    merchant: 0.6,
    behavioral: 0.7,
    network: 0.6,
    ml: 0.5
  },
  globalThreshold: 0.6,
  enableLogging: true
});

// Analyze a transaction
const transaction: Transaction = {
  id: 'tx_001',
  userId: 'user_123',
  amount: 1000,
  currency: 'USD',
  timestamp: new Date(),
  location: {
    lat: 40.7128,
    lng: -74.0060,
    country: 'US',
    city: 'New York',
    state: 'NY'
  },
  deviceId: 'device_456',
  ipAddress: '192.168.1.1',
  merchantId: 'merchant_001',
  merchantCategory: 'retail',
  paymentMethod: 'credit_card',
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
};

const result = await detector.analyze(transaction);

console.log('Risk Score:', result.riskScore);        // 0.0 - 1.0
console.log('Is Fraudulent:', result.isFraudulent);  // boolean
console.log('Confidence:', result.confidence);       // 0.0 - 1.0
console.log('Triggered Rules:', result.triggeredRules); // ['amount', 'location']
console.log('Processing Time:', result.processingTime); // milliseconds

import { 
  FraudDetector, 
  CountryService,
  VelocityAlgorithm,
  AmountAlgorithm,
  LocationAlgorithm
} from 'fraud-catcher';

// Custom algorithm configuration
const detector = new FraudDetector({
  rules: ['velocity', 'amount', 'location'],
  thresholds: {
    velocity: 0.8,
    amount: 0.9,
    location: 0.7
  },
  globalThreshold: 0.7,
  enableLogging: true,
  customRules: [
    {
      name: 'high_value_weekend',
      weight: 0.9,
      threshold: 0.8,
      enabled: true,
      config: {
        minAmount: 5000,
        weekendOnly: true
      }
    }
  ]
});

// Access country service for risk analysis
const countryService = new CountryService();
const countryRisk = countryService.getCountryRisk('US');
console.log('Country Risk Level:', countryRisk.riskLevel);

class FraudDetector {
  constructor(config: FraudDetectorConfig)
  async analyze(transaction: Transaction): Promise<FraudResult>
  getAlgorithm(name: string): any
  updateThreshold(rule: string, threshold: number): void
  enableRule(rule: string): void
  disableRule(rule: string): void
}

interface FraudDetectorConfig {
  rules: string[];                    // Algorithms to enable
  thresholds: Record<string, number>; // Risk thresholds (0.0-1.0)
  globalThreshold: number;            // Overall fraud threshold
  enableLogging: boolean;             // Enable debug logging
  customRules?: DetectionRule[];      // Custom detection rules
}

interface Transaction {
  id: string;                         // Unique transaction ID
  userId: string;                     // User identifier
  amount: number;                     // Transaction amount
  currency: string;                   // Currency code (USD, EUR, etc.)
  timestamp: Date | string;           // Transaction timestamp
  location?: Location;                // Geographic location
  merchantId?: string;                // Merchant identifier
  merchantCategory?: string;          // Merchant category
  paymentMethod?: string;             // Payment method used
  deviceId?: string;                  // Device identifier
  ipAddress?: string;                 // IP address
  userAgent?: string;                 // Browser user agent
  metadata?: Record<string, any>;     // Additional metadata
}

interface Location {
  lat: number;                        // Latitude
  lng: number;                        // Longitude
  country?: string;                   // Country code
  city?: string;                      // City name
  state?: string;                     // State/province
}

interface FraudResult {
  transactionId: string;              // Transaction ID
  riskScore: number;                  // Overall risk score (0.0-1.0)
  isFraudulent: boolean;              // Fraud detection result
  isFraud: boolean;                   // Alias for isFraudulent
  confidence: number;                 // Confidence level (0.0-1.0)
  triggeredRules: string[];           // Rules that were triggered
  processingTime: number;             // Processing time in ms
  timestamp: Date;                    // Analysis timestamp
  details: {
    algorithm: string;                // Primary algorithm used
    processingTime: number;           // Algorithm processing time
    timestamp: Date;                  // Analysis timestamp
    algorithmScores?: Record<string, number>; // Individual algorithm scores
  };
  recommendations?: string[];         // Fraud prevention recommendations
}

import { COUNTRIES, COUNTRY_RISK_LEVELS } from 'fraud-catcher';

// Get all supported countries
console.log(COUNTRIES);

// Check country risk level
const riskLevel = COUNTRY_RISK_LEVELS['US']; // 'LOW' | 'MEDIUM' | 'HIGH' | 'VERY_HIGH'

import { CURRENCY_MULTIPLIERS } from 'fraud-catcher';

// Currency conversion multipliers
console.log(CURRENCY_MULTIPLIERS);
// {
//   'USD': 1,
//   'EUR': 1.1,
//   'GBP': 1.3,
//   'JPY': 0.007,
//   // ... 50+ more currencies
// }

import { 
  VelocityAlgorithm, 
  AmountAlgorithm, 
  LocationAlgorithm 
} from 'fraud-catcher';

// Configure velocity algorithm
const velocityConfig = {
  timeWindow: 60,        // 1 hour window
  maxTransactions: 10,   // Max transactions per window
  maxAmount: 5000        // Max amount per window
};
const velocityAlgo = new VelocityAlgorithm(velocityConfig);

// Configure amount algorithm
const amountConfig = {
  suspiciousThreshold: 1000,
  highRiskThreshold: 5000,
  currencyMultipliers: {
    'USD': 1,
    'EUR': 1.1,
    'GBP': 1.3
  }
};
const amountAlgo = new AmountAlgorithm(amountConfig);

// Process multiple transactions
const transactions: Transaction[] = [
  // ... array of transactions
];

const results = await Promise.all(
  transactions.map(tx => detector.analyze(tx))
);

// Filter fraudulent transactions
const fraudulentTxs = results.filter(result => result.isFraudulent);

const customRule: DetectionRule = {
  name: 'weekend_high_value',
  weight: 0.9,
  threshold: 0.8,
  enabled: true,
  config: {
    minAmount: 5000,
    weekendOnly: true,
    excludeHolidays: true
  }
};

const detector = new FraudDetector({
  rules: ['amount', 'time'],
  thresholds: { amount: 0.8, time: 0.6 },
  globalThreshold: 0.7,
  enableLogging: true,
  customRules: [customRule]
});

// Enable only necessary algorithms
const detector = new FraudDetector({
  rules: ['amount', 'location'], // Only enable what you need
  thresholds: { amount: 0.8, location: 0.7 },
  globalThreshold: 0.7,
  enableLogging: false // Disable in production
});

// Use caching for repeated analysis
const cache = new Map<string, FraudResult>();

async function analyzeWithCache(transaction: Transaction) {
  const key = `${transaction.userId}-${transaction.amount}-${transaction.timestamp}`;
  
  if (cache.has(key)) {
    return cache.get(key);
  }
  
  const result = await detector.analyze(transaction);
  cache.set(key, result);
  
  return result;
}

// E-commerce specific configuration
const ecommerceDetector = new FraudDetector({
  rules: ['velocity', 'amount', 'location', 'device', 'merchant'],
  thresholds: {
    velocity: 0.7,    // Lower threshold for e-commerce
    amount: 0.8,
    location: 0.6,
    device: 0.5,
    merchant: 0.7
  },
  globalThreshold: 0.6,
  enableLogging: true
});

// Analyze e-commerce transaction
const ecommerceTx: Transaction = {
  id: 'ecom_001',
  userId: 'customer_123',
  amount: 299.99,
  currency: 'USD',
  timestamp: new Date(),
  location: { lat: 40.7128, lng: -74.0060, country: 'US' },
  merchantId: 'store_001',
  merchantCategory: 'electronics',
  paymentMethod: 'credit_card',
  deviceId: 'device_456',
  ipAddress: '192.168.1.1'
};

const result = await ecommerceDetector.analyze(ecommerceTx);

// High-security financial configuration
const financialDetector = new FraudDetector({
  rules: ['velocity', 'amount', 'location', 'device', 'behavioral', 'network', 'ml'],
  thresholds: {
    velocity: 0.9,    // Higher thresholds for financial
    amount: 0.95,
    location: 0.8,
    device: 0.7,
    behavioral: 0.8,
    network: 0.7,
    ml: 0.6
  },
  globalThreshold: 0.8,
  enableLogging: true
});

// Add monitoring and metrics
const detector = new FraudDetector({
  // ... config
  enableLogging: true
});

// Monitor performance
detector.on('analysisComplete', (result) => {
  console.log(`Analysis completed in ${result.processingTime}ms`);
  // Send to monitoring service
});