// Cache bust: v61 - Force dep re-optimization
import React from "react";
import { createRoot } from "react-dom/client";
import App from "./App.tsx";
import "./index.css";
import { initPerformanceHints, deferOperation } from "./lib/performance";
import { isNative } from "./lib/platform";
import { logger } from "./lib/logger";

// Defer Sentry init until after page load — prevents 147KB download from
// competing with critical resources on slow networks
window.addEventListener('load', () => {
  deferOperation(() => {
    import("./lib/sentry").then(({ initSentry }) => initSentry());
  }, 2000);
});


// Force dark mode on initialization
try {
  const savedTheme = localStorage.getItem('archetypeTheme') || 'dark';
  document.documentElement.classList.add(savedTheme);
} catch {
  document.documentElement.classList.add('dark');
}

// Initialize RevenueCat for native platforms (iOS/Android IAP) — dynamic import
// keeps the ~50KB SDK out of the main bundle entirely on web
if (isNative()) {
  import("./lib/revenuecat").then(({ initializeRevenueCat }) => {
    initializeRevenueCat().catch((error) => {
      logger.error('[Main] Failed to initialize RevenueCat:', error);
    });
  });
}

// Initialize performance optimizations
deferOperation(() => {
  initPerformanceHints();
}, 1000);

// Clear stale auth tokens on app load to prevent infinite loops
const clearStaleAuthTokens = () => {
  try {
    // Check for stale Supabase tokens that might cause issues
    const supabaseKey = Object.keys(localStorage).find(key =>
      key.startsWith('sb-') && key.endsWith('-auth-token')
    );

    if (supabaseKey) {
      const tokenData = localStorage.getItem(supabaseKey);
      if (tokenData) {
        try {
          const parsed = JSON.parse(tokenData);
          const expiresAt = parsed?.expires_at;

          // If token is expired or about to expire (within 5 minutes), clear it
          if (expiresAt && (expiresAt * 1000) < (Date.now() + 5 * 60 * 1000)) {
            logger.info('[Auth] Clearing expired auth token');
            localStorage.removeItem(supabaseKey);
          }
        } catch {
          // If we can't parse it, it's corrupted - clear it
          logger.info('[Auth] Clearing corrupted auth token');
          localStorage.removeItem(supabaseKey);
        }
      }
    }
  } catch (e) {
    logger.error('[Auth] Error checking stale tokens:', e);
  }
};

// Run stale token check immediately
clearStaleAuthTokens();

// Service worker registration — production only (Vite dev server handles HMR;
// SW reload() calls cause infinite loops inside the preview iframe)
if (import.meta.env.PROD) {
  // Force service worker update and cache clearing for all users
  const forceServiceWorkerUpdate = async () => {
    if (!('serviceWorker' in navigator)) return;

    const CURRENT_SW_VERSION = 'v51';
    const STORED_VERSION_KEY = 'sw-version';
    let storedVersion: string | null = null;
    try { storedVersion = localStorage.getItem(STORED_VERSION_KEY); } catch { /* noop */ }

    try {
      // Clear old caches if version mismatch
      if (storedVersion !== CURRENT_SW_VERSION && 'caches' in window) {
        logger.info('[SW] Version mismatch, clearing old caches...');
        const cacheNames = await caches.keys();
        await Promise.all(
          cacheNames
            .filter(name => !name.includes(CURRENT_SW_VERSION.replace('v', '')))
            .map(name => {
              logger.info('[SW] Deleting old cache:', name);
              return caches.delete(name);
            })
        );
        try { localStorage.setItem(STORED_VERSION_KEY, CURRENT_SW_VERSION); } catch { /* noop */ }
      }

      // Get existing registration
      const registration = await navigator.serviceWorker.getRegistration();

      if (registration) {
        // Force update check
        logger.info('[SW] Checking for updates...');
        await registration.update();

        // If there's a waiting worker, activate it immediately
        if (registration.waiting) {
          logger.info('[SW] New version available, activating...');
          registration.waiting.postMessage({ type: 'SKIP_WAITING' });

          // Reload to get new version
          window.location.reload();
          return;
        }
      }

      // Register service worker with cache-busting query param
      const swRegistration = await navigator.serviceWorker.register(`/sw.js?v=${CURRENT_SW_VERSION}`);
      logger.info('[SW] Service Worker registered:', swRegistration);

      // Listen for new versions
      swRegistration.addEventListener('updatefound', () => {
        const newWorker = swRegistration.installing;
        if (newWorker) {
          newWorker.addEventListener('statechange', () => {
            if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
              logger.info('[SW] New version installed, will activate on next load');
            }
          });
        }
      });

    } catch (error) {
      logger.error('[SW] Service Worker registration failed:', error);
    }
  };

  // Defer service worker registration — skip on native iOS
  if (!isNative()) {
    window.addEventListener('load', () => {
      if ('requestIdleCallback' in window) {
        requestIdleCallback(() => forceServiceWorkerUpdate());
      } else {
        setTimeout(forceServiceWorkerUpdate, 2000);
      }
    });
  }

  // Listen for SW messages (web only)
  if (!isNative() && 'serviceWorker' in navigator) {
    navigator.serviceWorker.addEventListener('controllerchange', () => {
      logger.info('[SW] Controller changed, new service worker activated');
    });
  }
}

createRoot(document.getElementById("root")!).render(
  React.createElement(React.StrictMode, null, React.createElement(App))
);