const { TrialAbuseGuard } = require('trial-abuse-guard');

const guard = new TrialAbuseGuard();

// Check a user for trial abuse - exactly as requested!
const result = await guard.checkUser(
  '[email protected]',
  '192.168.1.100'
);

console.log(result.recommendation); // 'allow', 'flag', or 'block'
console.log(result.overall); // Risk score 0-100
console.log(result.details); // Detailed explanation

// Automatic updates from multiple external sources
const guard = new TrialAbuseGuard({
  tempEmailAutoUpdate: true,        // Auto-update enabled (default)
  tempEmailUpdateInterval: 24,      // Update every 24 hours
  tempEmailStoragePath: './domains.json' // Custom storage location
});

// Add your own domains to the blacklist
await guard.addTempEmailDomains(['suspicious.com', 'fake-trials.org']);

// Remove domains if needed
await guard.removeTempEmailDomains(['legit-domain.com']);

// Get statistics
const stats = guard.getTempEmailStats();
console.log(`Tracking ${stats.totalDomains} temp email domains`);

// Search domains
const results = guard.searchTempEmailDomains('temp');

// Export/Import domain lists
await guard.exportTempEmailDomains('./backup.json');
await guard.importTempEmailDomains('./custom-domains.txt');

// Force update from external sources
await guard.updateTempEmailDomains();

import NextAuth from 'next-auth';
import { NextAuthTrialAbuseAdapter } from 'trial-abuse-guard/nextauth';

const trialAbuseAdapter = new NextAuthTrialAbuseAdapter({
  blockHighRisk: true,
  blockThreshold: 80,
  onUserBlocked: async (email, riskData) => {
    console.log(`Blocked user: ${email} (Risk: ${riskData.overall})`);
  }
});

export const { handlers, auth } = NextAuth(
  trialAbuseAdapter.getNextAuthConfig({
    providers: [/* your providers */],
    // Your existing config is preserved and enhanced
  })
);

// Webhook handler: app/api/webhooks/clerk/route.ts
import { ClerkTrialAbuseAdapter } from 'trial-abuse-guard/clerk';

const clerkAdapter = new ClerkTrialAbuseAdapter({
  blockHighRisk: true,
  clerkSecretKey: process.env.CLERK_SECRET_KEY,
  onUserBlocked: async (email, riskData) => {
    // User is automatically deleted from Clerk
    console.log(`Blocked and deleted: ${email}`);
  }
});

export async function POST(request) {
  const webhookHandler = clerkAdapter.createWebhookHandler();
  return Response.json(await webhookHandler(request));
}

// Check risk before allowing signup
const { allowed, risk, action } = await clerkAdapter.preSignUpCheck(
  email, 
  ipAddress
);

if (!allowed) {
  return res.status(403).json({ error: 'Sign-up not available' });
}

const { TrialAbuseGuard, MongoStorageAdapter } = require('trial-abuse-guard');

// Configure with MongoDB storage
const mongoAdapter = new MongoStorageAdapter({
  connectionString: 'mongodb://localhost:27017',
  databaseName: 'myapp'
});

await mongoAdapter.connect();

const guard = new TrialAbuseGuard({
  // Detection settings
  emailSimilarityCheck: true,
  emailSimilarityThreshold: 0.8,
  tempEmailCheck: true,
  ipCheck: true,
  vpnCheck: true,
  
  // Custom disposable domains
  customDisposableDomains: ['mydisposable.com'],
  
  // API keys for enhanced detection
  apiKeys: {
    ipQualityScore: 'your-api-key',
    vpnapi: 'your-api-key',
    proxyCheck: 'your-api-key'
  },
  
  // Storage adapter
  storageAdapter: mongoAdapter
});

const express = require('express');
const { TrialAbuseGuard } = require('trial-abuse-guard');

const app = express();
const guard = new TrialAbuseGuard();

app.post('/register', async (req, res) => {
  const { email } = req.body;
  const ipAddress = req.ip;
  
  const risk = await guard.checkUser(email, ipAddress);
  
  if (risk.recommendation === 'block') {
    return res.status(403).json({ 
      error: 'Registration blocked due to security concerns' 
    });
  }
  
  // Proceed with registration...
});

const { MongoStorageAdapter } = require('trial-abuse-guard');

const mongoAdapter = new MongoStorageAdapter({
  connectionString: 'mongodb://localhost:27017',
  databaseName: 'myapp',
  collectionName: 'trial_users' // optional
});

const { PostgreSQLStorageAdapter } = require('trial-abuse-guard');

const pgAdapter = new PostgreSQLStorageAdapter({
  connectionString: 'postgresql://user:pass@localhost/mydb',
  tableName: 'trial_users' // optional
});

const { RedisStorageAdapter } = require('trial-abuse-guard');

const redisAdapter = new RedisStorageAdapter({
  host: 'localhost',
  port: 6379,
  password: 'your-password', // optional
  keyPrefix: 'trial_abuse:' // optional
});

{
  overall: 75,                    // Overall risk score (0-100)
  recommendation: 'flag',         // 'allow', 'flag', or 'block'
  factors: {
    emailSimilarity: {
      score: 85,
      detected: true,
      confidence: 0.9,
      details: "Similar to existing emails: [email protected]"
    },
    tempEmail: {
      score: 0,
      detected: false,
      confidence: 0.05,
      details: "Email appears legitimate"
    },
    ipRisk: {
      score: 60,
      detected: true,
      confidence: 0.8,
      details: "IP Risk Score: 60, Country: US"
    },
    vpnDetection: {
      score: 80,
      detected: true,
      confidence: 0.9,
      details: "VPN/Proxy detected: VPN=true, Proxy=false, Tor=false"
    }
  },
  details: [
    "Similar to existing emails: [email protected]",
    "VPN/Proxy detected: VPN=true, Proxy=false, Tor=false"
  ]
}

class CustomStorageAdapter {
  async getExistingEmails() {
    // Return array of existing emails
    return ['[email protected]', '[email protected]'];
  }
  
  async getExistingIPs(email) {
    // Return array of IPs for this email
    return ['192.168.1.1', '203.0.113.1'];
  }
  
  async storeUserData(data) {
    // Store user data for future comparisons
    console.log('Storing:', data);
  }
}

const guard = new TrialAbuseGuard({
  storageAdapter: new CustomStorageAdapter()
});

const { 
  EmailSimilarityDetector, 
  TempEmailDetector, 
  IPAnalyzer, 
  VPNDetector 
} = require('trial-abuse-guard');

// Use individual detectors for specific needs
const emailDetector = new EmailSimilarityDetector(config);
const result = await emailDetector.checkSimilarity('[email protected]');