import {
  NetworkDetector,
  DeviceDetector,
  AttributionDetector,
  LocationDetector,
} from 'user-analytics-tracker';

// Detect network type
const network = NetworkDetector.detect();
console.log(network.type); // 'wifi' | 'cellular' | 'hotspot' | 'ethernet' | 'unknown'

// Detect device info
const device = await DeviceDetector.detect();
console.log(device.deviceBrand, device.deviceModel);

// Detect attribution (UTM params, referrer, etc.)
const attribution = AttributionDetector.detect();
console.log(attribution.utm_source);

// Detect location (automatic IP-based if no consent, GPS if consent granted)
const location = await LocationDetector.detect();
console.log(location.lat, location.lon);
console.log(location.ip); // Public IP (when using IP-based location)
console.log(location.country, location.city); // Location details

// Or get IP-based location only (no permission needed)
const ipLocation = await LocationDetector.detectIPOnly();
console.log(ipLocation.ip, ipLocation.country, ipLocation.city);

useAnalytics(options?: UseAnalyticsOptions): UseAnalyticsReturn

interface UseAnalyticsOptions {
  autoSend?: boolean; // Auto-send analytics on mount (default: true)
  config?: Partial<AnalyticsConfig>;
  onReady?: (data: {
    sessionId: string;
    networkInfo: NetworkInfo;
    deviceInfo: DeviceInfo;
    location: LocationInfo;
    attribution: AttributionInfo;
  }) => void; // Callback when data is ready
}

interface AnalyticsConfig {
  apiEndpoint: string;
  // Batching options
  batchSize?: number;        // Events per batch (default: 10)
  batchInterval?: number;    // Flush interval in ms (default: 5000)
  maxQueueSize?: number;     // Max queued events (default: 100)
  // Retry options
  maxRetries?: number;       // Max retry attempts (default: 3)
  retryDelay?: number;       // Initial retry delay in ms (default: 1000)
  // Session options
  sessionTimeout?: number;   // Session timeout in ms (default: 1800000 = 30 min)
  // Logging options
  logLevel?: LogLevel;       // 'silent' | 'error' | 'warn' | 'info' | 'debug' (default: 'warn')
  // Metrics options
  enableMetrics?: boolean;   // Enable metrics collection (default: false)
  // IP Geolocation (ipwho.is) - pass your own API key via env var for higher rate limits
  ipGeolocation?: {
    apiKey?: string;   // Use env var. Required for paid; optional for ipwho.is free tier.
    baseUrl?: string;  // Default: 'https://ipwho.is'. Use 'https://ipwhois.pro' for paid (URL: baseUrl/{IP}?key=API_KEY)
    timeout?: number;  // Default: 5000
    ip?: string;       // When provided (paid/server-side), lookup this IP
  };
  // Existing options
  autoSend?: boolean;
  enableLocation?: boolean;
  enableIPGeolocation?: boolean;
  enableNetworkDetection?: boolean;
  enableDeviceDetection?: boolean;
  enableAttribution?: boolean;
  sessionStoragePrefix?: string;
  localStoragePrefix?: string;
}

interface UseAnalyticsReturn {
  sessionId: string | null;
  networkInfo: NetworkInfo | null;
  deviceInfo: DeviceInfo | null;
  location: LocationInfo | null;
  attribution: AttributionInfo | null;
  pageVisits: number;
  interactions: number;
  logEvent: (customData?: Record<string, any>) => Promise<void>;
  trackEvent: (eventName: string, parameters?: Record<string, any>) => Promise<void>;
  trackPageView: (pageName?: string, parameters?: Record<string, any>) => Promise<void>;
  incrementInteraction: () => void;
  refresh: () => Promise<{
    net: NetworkInfo;
    dev: DeviceInfo;
    attr: AttributionInfo;
    loc: LocationInfo;
  }>;
}

const network = NetworkDetector.detect();
// Returns:
// {
//   type: 'wifi' | 'cellular' | 'hotspot' | 'ethernet' | 'unknown';
//   effectiveType?: string; // '2g', '3g', '4g', etc.
//   downlink?: number; // Mbps
//   rtt?: number; // ms
//   saveData?: boolean;
//   connectionType?: string;
// }

const device = await DeviceDetector.detect();
// Returns:
// {
//   type: 'mobile' | 'tablet' | 'desktop' | 'unknown';
//   os: string;
//   osVersion: string;
//   browser: string;
//   browserVersion: string;
//   deviceModel: string;
//   deviceBrand: string;
//   screenResolution: string;
//   // ... more fields
// }

const location = await LocationDetector.detect();
// Returns:
// {
//   lat?: number | null;
//   lon?: number | null;
//   accuracy?: number | null;  // GPS only
//   permission: 'granted' | 'denied' | 'prompt' | 'unsupported';
//   source: 'gps' | 'ip' | 'unknown';
//   ts?: string;
//   // IP-based location includes:
//   ip?: string | null;         // Public IP address
//   country?: string;           // Country name
//   countryCode?: string;       // ISO country code
//   city?: string;              // City name
//   region?: string;            // Region/state
//   timezone?: string;          // Timezone
// }

const location = await LocationDetector.detectIPOnly();
// Returns IP-based location with IP address, country, city, coordinates
// Works immediately without user permission

const location = await LocationDetector.detectWithAutoConsent();
// 1. Automatically grants location consent
// 2. Tries GPS location (if available)
// 3. Falls back to IP-based location if GPS fails/denied/unavailable

import { getPublicIP } from 'user-analytics-tracker';

const ip = await getPublicIP();
console.log(ip); // "203.0.113.42"

const attribution = AttributionDetector.detect();
// Returns:
// {
//   landingUrl: string;
//   referrerUrl: string | null;
//   referrerDomain: string | null;
//   utm_source?: string | null;
//   utm_medium?: string | null;
//   utm_campaign?: string | null;
//   // ... more UTM fields
//   firstTouch?: Record<string, string | null> | null;
//   lastTouch?: Record<string, string | null> | null;
//   sessionStart?: string | null;
// }

import { AnalyticsService } from 'user-analytics-tracker';

AnalyticsService.configure({
  apiEndpoint: 'https://api.yourcompany.com/analytics',
  batchSize: 20,              // Events per batch (default: 10)
  batchInterval: 10000,       // Flush interval in ms (default: 5000)
  maxQueueSize: 100,          // Max queued events (default: 100)
  maxRetries: 5,              // Max retry attempts (default: 3)
  retryDelay: 2000,           // Initial retry delay in ms (default: 1000)
  sessionTimeout: 1800000,    // Session timeout in ms (default: 30 min)
  logLevel: 'info',           // Logging verbosity (default: 'warn')
  enableMetrics: true,        // Enable metrics collection (default: false)
});

import { AnalyticsService } from 'user-analytics-tracker';

// Configure endpoint - use your own server
AnalyticsService.configure({ 
  apiEndpoint: 'https://api.yourcompany.com/analytics' 
});

// Or use relative path (same domain)
// AnalyticsService.configure({ apiEndpoint: '/api/analytics' });

// Track event
await AnalyticsService.trackUserJourney({
  sessionId: 'abc123',
  pageUrl: 'https://example.com/page',
  networkInfo: network,
  deviceInfo: device,
  location: location,
  attribution: attribution,
  customData: { userId: 'user123', action: 'purchase' },
});

// Flush all queued events immediately
await AnalyticsService.flushQueue();

const size = AnalyticsService.getQueueSize();
console.log(`Queue has ${size} events`);

const metrics = AnalyticsService.getMetrics();
if (metrics) {
  console.log(`Sent: ${metrics.eventsSent}, Failed: ${metrics.eventsFailed}`);
}

import { logger } from 'user-analytics-tracker';

// Set log level
logger.setLevel('debug'); // 'silent' | 'error' | 'warn' | 'info' | 'debug'

// Use logger
logger.debug('Debug message');
logger.info('Info message');
logger.warn('Warning message');
logger.error('Error message');

import { pluginManager } from 'user-analytics-tracker';

// Register a plugin
pluginManager.register({
  name: 'my-plugin',
  beforeSend: (event) => {
    // Transform event
    return event;
  },
});

// Unregister a plugin
pluginManager.unregister('my-plugin');

// Get all plugins
const plugins = pluginManager.getPlugins();

import { QueueManager } from 'user-analytics-tracker';

const queue = new QueueManager({
  batchSize: 20,
  batchInterval: 10000,
  maxQueueSize: 200,
  storageKey: 'my-queue',
});

queue.setFlushCallback(async (events) => {
  // Custom flush logic
});

import { metricsCollector } from 'user-analytics-tracker';

// Metrics are automatically collected when enableMetrics is true
// Access metrics
const metrics = metricsCollector.getMetrics();

// Reset metrics
metricsCollector.reset();

import {
  setLocationConsentGranted,
  hasLocationConsent,
  checkAndSetLocationConsent,
  clearLocationConsent,
} from 'user-analytics-tracker';

// When user enters MSISDN, grant location consent
checkAndSetLocationConsent(msisdn); // Returns true if consent granted

// Check if consent exists
if (hasLocationConsent()) {
  // Location tracking allowed
}

// Manually grant/revoke consent
setLocationConsentGranted();
clearLocationConsent();

import {
  getOrCreateSession,
  updateSessionActivity,
  getSession,
  clearSession,
} from 'user-analytics-tracker';

// Get or create session with custom timeout (30 minutes)
const session = getOrCreateSession(30 * 60 * 1000);
// Returns: { sessionId, startTime, lastActivity, pageViews }

// Update session activity
updateSessionActivity();

// Get current session
const currentSession = getSession();

// Clear session
clearSession();

import { initDebug } from 'user-analytics-tracker';

// Initialize debug tools (automatically called in development)
initDebug();

// Then access via window.__analyticsDebug in browser console

import { getPublicIP } from 'user-analytics-tracker';

// Get just the public IP address (no location data)
const ip = await getPublicIP();
console.log('Your IP:', ip); // "203.0.113.42"

import { getIPLocation, getIPFromRequest } from 'user-analytics-tracker';

// In your API route (Next.js example)
export async function POST(req: Request) {
  const ip = getIPFromRequest(req);

  // Free tier (ipwho.is)
  const location = await getIPLocation(ip);

  // Paid (ipwhois.pro): baseUrl/{IP}?key=API_KEY
  // const location = await getIPLocation(ip, {
  //   baseUrl: 'https://ipwhois.pro',
  //   apiKey: process.env.IPWHOIS_PRO_API_KEY,
  // });
  // location contains: country, region, city, lat, lon, timezone, isp, etc.
}

import { checkAndSetLocationConsent } from 'user-analytics-tracker';

// When MSISDN is entered
checkAndSetLocationConsent(phoneNumber);
// Location consent is now granted, GPS will be requested automatically

import { AnalyticsService } from 'user-analytics-tracker';

class MyAnalyticsService extends AnalyticsService {
  static async trackUserJourney(data: any) {
    // Custom tracking logic
    await fetch('/my-custom-endpoint', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }
}

const { trackEvent, trackPageView } = useAnalytics();

// Track button click
await trackEvent('button_click', {
  button_name: 'signup',
  button_location: 'header',
  button_color: 'blue'
});

// Track purchase
await trackEvent('purchase', {
  transaction_id: 'T12345',
  value: 29.99,
  currency: 'USD',
  items: [
    { id: 'item1', name: 'Product 1', price: 29.99 }
  ]
});

// Track page views
await trackPageView('/dashboard', {
  page_title: 'Dashboard',
  user_type: 'premium'
});

// Track current page view
await trackPageView();

const { logEvent, incrementInteraction } = useAnalytics();

// Log custom event with full control
await logEvent({
  eventType: 'purchase',
  productId: '123',
  amount: 99.99,
});

// Increment interaction counter
incrementInteraction();

// app/api/analytics/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { getIPFromRequest, getIPLocation } from 'user-analytics-tracker';

export async function POST(req: NextRequest) {
  const body = await req.json();
  const ip = getIPFromRequest(req);
  const ipLocation = await getIPLocation(ip);
  
  // Store analytics with IP location
  await storeAnalytics({
    ...body,
    ip,
    ipLocation,
  });
  
  return NextResponse.json({ ok: true });
}

import type {
  NetworkInfo,
  DeviceInfo,
  LocationInfo,
  AttributionInfo,
  IPLocation,
  UseAnalyticsReturn,
} from 'user-analytics-tracker';