import { revaliFetch, subscribe, mutate } from 'revali';

// Fetch data with caching and SWR behavior
const userData = await revaliFetch(
  'user/1',
  () => fetch('https://api.example.com/users/1').then((r) => r.json()),
  {
    ttl: 5 * 60 * 1000, // 5 minutes cache
    retries: 3, // Retry failed requests 3 times
    revalidateOnFocus: true, // Refresh when window regains focus
    refreshInterval: 30 * 1000, // Poll every 30 seconds
  },
);

// Subscribe to cache updates (with error handling)
const unsubscribe = subscribe('user/1', (data, error) => {
  if (error) {
    console.error('Fetch error:', error);
  } else {
    console.log('Updated data:', data);
  }
});

// Optimistic updates with automatic revalidation
mutate(
  'user/1',
  (prev) => ({
    ...prev,
    name: 'Updated Name',
  }),
  true,
); // Will revalidate after mutation

// Cache management
import { clearCache, getCacheInfo, cleanup } from 'revali';

clearCache('user/1'); // Clear specific cache
clearCache(); // Clear all cache
console.log(getCacheInfo()); // { size: 5, keys: ["user/1", ...] }

// Manual revalidation control
import { triggerRevalidation } from 'revali';

triggerRevalidation(); // Manually trigger revalidation for all eligible entries

// Clean up everything
cleanup(); // Clear all cache and remove all subscribers
unsubscribe(); // Or just unsubscribe from specific key

const data = await revaliFetch('posts/1', () => fetch('/api/posts/1').then((r) => r.json()), {
  ttl: 5 * 60 * 1000, // Cache for 5 minutes
  retries: 3, // Retry 3 times on failure
  retryDelay: 1000, // Initial retry delay
  maxCacheSize: 50, // Max cache entries
  revalidateOnFocus: true, // Revalidate on window focus
  revalidateOnReconnect: true, // Revalidate on network reconnect
});

const unsubscribe = subscribe('user/1', (data, error) => {
  if (error) console.error('Error:', error);
  else console.log('Data updated:', data);
});

// Update with new data
mutate('user/1', { id: 1, name: 'John Doe' });

// Update with function
mutate('user/1', (prev) => ({ ...prev, name: 'Jane Doe' }));

// Update without revalidation
mutate('user/1', newData, false);

clearCache('user/1'); // Clear specific key
clearCache(); // Clear all cache

const { size, keys } = getCacheInfo();
console.log(`Cache has ${size} entries:`, keys);

import { cleanup } from 'revali';

// Clear everything - cache and subscribers
cleanup();

import { triggerRevalidation } from 'revali';

// Manually revalidate all entries that have revalidateOnFocus or revalidateOnReconnect enabled
triggerRevalidation();

import { initAutoRevalidation } from 'revali';

// Manually set up window focus and network reconnect listeners
// (This is done automatically when importing Revali)
initAutoRevalidation();

import { getPollingInfo } from 'revali';

const pollingInfo = getPollingInfo();
console.log(`Active polling tasks: ${pollingInfo.activeCount}`);
console.log('Polling keys:', pollingInfo.keys);

import { hasActivePolling } from 'revali';

if (hasActivePolling('user/1')) {
  console.log('User data is being polled');
}

import { cleanupPolling } from 'revali';

// Stop all polling tasks
cleanupPolling();

export type Fetcher<T> = () => Promise<T>;
export type Subscriber<T> = (data: T | undefined, error?: Error) => void;

export interface RevaliOptions {
  retries?: number; // Max retry attempts (default: 2)
  retryDelay?: number; // Initial retry delay in ms (default: 300)
  ttl?: number; // Cache TTL in ms (default: 300000 = 5min)
  maxCacheSize?: number; // Max cache entries (default: 100)
  revalidateOnFocus?: boolean; // Revalidate on focus (default: true)
  revalidateOnReconnect?: boolean; // Revalidate on reconnect (default: true)
  refreshInterval?: number; // Polling interval in ms, 0 means no polling (default: 0)
  refreshWhenHidden?: boolean; // Continue polling when page is hidden (default: false)
  refreshWhenOffline?: boolean; // Continue polling when offline (default: false)
  dedupingInterval?: number; // Deduping interval in ms (default: 2000)
}

export interface CacheEntry<T> {
  data: T | undefined;
  timestamp: number;
  error?: Error;
  fetcher: Fetcher<T>;
  options: RevaliOptions;
}

export interface RevaliState<T> {
  data?: T;
  error?: Error;
  isLoading: boolean;
  isValidating: boolean;
}

// Default configuration constant
export const DEFAULT_OPTIONS: Required<RevaliOptions>;

import { revaliFetch } from 'revali';
// Automatically listens for:
// - Window focus events (revalidates when tab becomes active)
// - Network online events (revalidates when connection restored)

import { triggerRevalidation, initAutoRevalidation, DEFAULT_OPTIONS } from 'revali';

// Use default options as base for custom configuration
const customOptions = {
  ...DEFAULT_OPTIONS,
  ttl: 10 * 60 * 1000, // Override TTL to 10 minutes
  retries: 5, // Override retries to 5
};

// Manually trigger revalidation
triggerRevalidation();

// Access default configuration
console.log('Default TTL:', DEFAULT_OPTIONS.ttl);

import { revaliFetch, getPollingInfo, hasActivePolling } from 'revali';

// Basic polling - refresh every 30 seconds
const liveStats = await revaliFetch(
  'live-stats',
  () => fetch('/api/stats').then(r => r.json()),
  {
    refreshInterval: 30 * 1000, // 30 seconds
    ttl: 5 * 60 * 1000, // 5 minutes cache
  }
);

// Advanced polling configuration
const criticalData = await revaliFetch(
  'critical-data',
  fetchCriticalData,
  {
    refreshInterval: 5 * 1000,   // Poll every 5 seconds
    refreshWhenHidden: true,     // Continue when tab is not active
    refreshWhenOffline: false,   // Pause when offline
    dedupingInterval: 2000,      // Prevent requests closer than 2s
    ttl: 10 * 1000,             // Short cache TTL for fresh data
  }
);

// Check polling status
console.log('Polling info:', getPollingInfo());
console.log('Is polling active:', hasActivePolling('live-stats'));

// Polling automatically stops when cache is cleared
clearCache('live-stats'); // Stops polling for this key

import { revaliFetch, cancel } from 'revali';

// Cancel a specific request
const key = 'user-data';
const promise = revaliFetch(key, async (signal) => {
  const response = await fetch('/api/user', { signal });
  return response.json();
});

// Cancel the request
cancel(key);

// The promise will reject with CancellationError
try {
  await promise;
} catch (error) {
  if (error.name === 'CancellationError') {
    console.log('Request was cancelled');
  }
}

import { revaliFetch } from 'revali';

// Use your own AbortController
const controller = new AbortController();
const promise = revaliFetch('data', async (signal) => {
  const response = await fetch('/api/data', { signal });
  return response.json();
}, {
  signal: controller.signal
});

// Cancel using your controller
controller.abort();

import { revaliFetch } from 'revali';

// Automatically cancel after timeout
const data = await revaliFetch('slow-api', async (signal) => {
  const response = await fetch('/api/slow', { signal });
  return response.json();
}, {
  abortTimeout: 5000 // Cancel after 5 seconds
});

import { revaliFetch } from 'revali';

// Cancel previous request when starting new one
const searchResults = await revaliFetch(`search-${query}`, async (signal) => {
  const response = await fetch(`/api/search?q=${query}`, { signal });
  return response.json();
}, {
  abortOnRevalidate: true // Cancel previous search when new search starts
});

import { 
  cancel, 
  cancelAll, 
  isCancelled, 
  getCancellationInfo,
  isCancellationError 
} from 'revali';

// Cancel specific request
const cancelled = cancel('request-key');
console.log('Cancelled:', cancelled);

// Cancel all active requests
const cancelledCount = cancelAll();
console.log('Cancelled count:', cancelledCount);

// Check if request was cancelled
const wasCancelled = isCancelled('request-key');

// Get cancellation information
const info = getCancellationInfo();
console.log('Active requests:', info.activeCount);
console.log('Active keys:', info.keys);

// Check if error is cancellation error
try {
  await someRequest();
} catch (error) {
  if (isCancellationError(error)) {
    console.log('Request was cancelled');
  }
}

// Only imports the functions you use
import { revaliFetch, mutate } from 'revali';
// ✅ Other modules (cleanup, revalidation) won't be included in bundle

// ✅ Good - consistent and descriptive
const userId = 123;
const userData = await revaliFetch(`user/${userId}`, fetchUser);
const userPosts = await revaliFetch(`user/${userId}/posts`, fetchUserPosts);

// ❌ Avoid - inconsistent or too generic
const userData = await revaliFetch(`user-${userId}`, fetchUser);
const userPosts = await revaliFetch(`posts`, fetchUserPosts);

// Fast-changing data - shorter TTL
const liveData = await revaliFetch('live-stats', fetchStats, {
  ttl: 30 * 1000, // 30 seconds
});

// Relatively stable data - longer TTL
const userData = await revaliFetch('user/profile', fetchProfile, {
  ttl: 5 * 60 * 1000, // 5 minutes
});

// Static data - very long TTL
const appConfig = await revaliFetch('app/config', fetchConfig, {
  ttl: 60 * 60 * 1000, // 1 hour
});

const options = {
  maxCacheSize: 50, // Limit cache entries for memory efficiency
  ttl: 5 * 60 * 1000,
};

useEffect(() => {
  const unsubscribe = subscribe(key, handleUpdate);
  return () => {
    unsubscribe(); // Prevent memory leaks
  };
}, [key]);