/**
 * 🏗️  NOSTR_LOGIN_LITE Build Script
 *
 * ⚠️  IMPORTANT: This file contains the source code for the NOSTR_LOGIN_LITE library!
 * ⚠️  DO NOT edit lite/nostr-lite.js directly - it's auto-generated by this script!
 * ⚠️  To modify the library, edit this file (build.js) and run: node build.js
 *
 * This script builds the two-file architecture:
 * 1. nostr.bundle.js (official nostr-tools bundle - static file)
 * 2. nostr-lite.js (NOSTR_LOGIN_LITE library - built by this script)
 *
 * Features included:
 * - CSS-Only Theme System (no JSON duplication)
 * - Modal UI Component
 * - FloatingTab Component
 * - Extension Bridge
 * - Window.nostr facade
 * - Main NostrLite class with all functionality
 */

const fs = require('fs');
const path = require('path');

function createNostrLoginLiteBundle() {
  console.log('🔧 Creating NOSTR_LOGIN_LITE bundle for two-file architecture...');
  
  const outputPath = path.join(__dirname, 'nostr-lite.js');
  
  // Remove old bundle
  try {
    if (fs.existsSync(outputPath)) {
      fs.unlinkSync(outputPath);
    }
  } catch (e) {
    console.log('No old bundle to remove');
  }

  // Start with the bundle header
  let bundle = `/**
 * NOSTR_LOGIN_LITE - Authentication Library
 *
 * ⚠️  WARNING: THIS FILE IS AUTO-GENERATED - DO NOT EDIT MANUALLY!
 * ⚠️  To make changes, edit lite/build.js and run: cd lite && node build.js
 * ⚠️  Any manual edits to this file will be OVERWRITTEN when build.js runs!
 *
 * Two-file architecture:
 * 1. Load nostr.bundle.js (official nostr-tools bundle)
 * 2. Load nostr-lite.js (this file - NOSTR_LOGIN_LITE library with CSS-only themes)
 * Generated on: ${new Date().toISOString()}
 */

// Verify dependencies are loaded
if (typeof window !== 'undefined') {
  if (!window.NostrTools) {
    console.error('NOSTR_LOGIN_LITE: nostr.bundle.js must be loaded first');
    throw new Error('Missing dependency: nostr.bundle.js');
  }
  
  console.log('NOSTR_LOGIN_LITE: Dependencies verified ✓');
  console.log('NOSTR_LOGIN_LITE: NostrTools available with keys:', Object.keys(window.NostrTools));
  console.log('NOSTR_LOGIN_LITE: NIP-06 available:', !!window.NostrTools.nip06);
  console.log('NOSTR_LOGIN_LITE: NIP-46 available:', !!window.NostrTools.nip46);
}

// ======================================
// NOSTR_LOGIN_LITE Components
// ======================================

`;

  // Embed CSS themes
  console.log('🎨 Adding CSS-Only Theme System...');
  
  const defaultThemeCssPath = path.join(__dirname, '../themes/default/theme.css');
  const darkThemeCssPath = path.join(__dirname, '../themes/dark/theme.css');
  
  if (fs.existsSync(defaultThemeCssPath) && fs.existsSync(darkThemeCssPath)) {
    const defaultThemeCss = fs.readFileSync(defaultThemeCssPath, 'utf8')
      .replace(/\\/g, '\\\\')
      .replace(/`/g, '\\`')
      .replace(/\${/g, '\\${');
      
    const darkThemeCss = fs.readFileSync(darkThemeCssPath, 'utf8')
      .replace(/\\/g, '\\\\')
      .replace(/`/g, '\\`')
      .replace(/\${/g, '\\${');
    
    bundle += `// ======================================\n`;
    bundle += `// CSS-Only Theme System\n`;
    bundle += `// ======================================\n\n`;
    
    bundle += `const THEME_CSS = {\n`;
    bundle += `  'default': \`${defaultThemeCss}\`,\n`;
    bundle += `  'dark': \`${darkThemeCss}\`\n`;
    bundle += `};\n\n`;
    
    bundle += `// Theme management functions\n`;
    bundle += `function injectThemeCSS(themeName = 'default') {\n`;
    bundle += `  if (typeof document !== 'undefined') {\n`;
    bundle += `    // Remove existing theme CSS\n`;
    bundle += `    const existingStyle = document.getElementById('nl-theme-css');\n`;
    bundle += `    if (existingStyle) {\n`;
    bundle += `      existingStyle.remove();\n`;
    bundle += `    }\n`;
    bundle += `    \n`;
    bundle += `    // Inject selected theme CSS\n`;
    bundle += `    const themeCss = THEME_CSS[themeName] || THEME_CSS['default'];\n`;
    bundle += `    const style = document.createElement('style');\n`;
    bundle += `    style.id = 'nl-theme-css';\n`;
    bundle += `    style.textContent = themeCss;\n`;
    bundle += `    document.head.appendChild(style);\n`;
    bundle += `    console.log(\`NOSTR_LOGIN_LITE: \${themeName} theme CSS injected\`);\n`;
    bundle += `  }\n`;
    bundle += `}\n\n`;
    
    // Auto-inject default theme on load
    bundle += `// Auto-inject default theme when DOM is ready\n`;
    bundle += `if (typeof document !== 'undefined') {\n`;
    bundle += `  if (document.readyState === 'loading') {\n`;
    bundle += `    document.addEventListener('DOMContentLoaded', () => injectThemeCSS('default'));\n`;
    bundle += `  } else {\n`;
    bundle += `    injectThemeCSS('default');\n`;
    bundle += `  }\n`;
    bundle += `}\n\n`;
  }

  // Add Modal UI
  const modalPath = path.join(__dirname, 'ui/modal.js');
  if (fs.existsSync(modalPath)) {
    console.log('📄 Adding Modal UI...');
    
    let modalContent = fs.readFileSync(modalPath, 'utf8');
    
    // Skip header comments
    let lines = modalContent.split('\n');
    let contentStartIndex = 0;
    
    for (let i = 0; i < Math.min(15, lines.length); i++) {
      const line = lines[i].trim();
      if (line.startsWith('/**') || line.startsWith('*') ||
          line.startsWith('/*') || line.startsWith('//')) {
        contentStartIndex = i + 1;
      } else if (line && !line.startsWith('*') && !line.startsWith('//')) {
        break;
      }
    }
    
    if (contentStartIndex > 0) {
      lines = lines.slice(contentStartIndex);
    }
    
    bundle += `// ======================================\n`;
    bundle += `// Modal UI Component\n`;
    bundle += `// ======================================\n\n`;
    bundle += lines.join('\n');
    bundle += '\n\n';
  } else {
    console.warn('⚠️  Modal UI not found: ui/modal.js');
  }
  
  // Add main library code
  console.log('📄 Adding Main Library...');
  bundle += `
// ======================================
// FloatingTab Component (Recovered from git history)
// ======================================

class FloatingTab {
  constructor(modal, options = {}) {
    this.modal = modal;
    this.options = {
      enabled: true,
      hPosition: 1.0, // 0.0 = left, 1.0 = right
      vPosition: 0.5, // 0.0 = top, 1.0 = bottom
      offset: { x: 0, y: 0 },
      appearance: {
        style: 'pill', // 'pill', 'square', 'circle'
        theme: 'auto', // 'auto', 'light', 'dark'
        icon: '',
        text: 'Login',
        iconOnly: false
      },
      behavior: {
        hideWhenAuthenticated: true,
        showUserInfo: true,
        autoSlide: true,
        persistent: false
      },
      getUserInfo: false,
      getUserRelay: [],
      ...options
    };

    this.isAuthenticated = false;
    this.userInfo = null;
    this.userProfile = null;
    this.container = null;
    this.isVisible = false;

    if (this.options.enabled) {
      this._init();
    }
  }

  _init() {
    console.log('FloatingTab: Initializing with options:', this.options);
    this._createContainer();
    this._setupEventListeners();
    this._updateAppearance();
    this._position();
    this.show();
  }

  _createContainer() {
    // Remove existing floating tab if any
    const existingTab = document.getElementById('nl-floating-tab');
    if (existingTab) {
      existingTab.remove();
    }

    this.container = document.createElement('div');
    this.container.id = 'nl-floating-tab';
    this.container.className = 'nl-floating-tab';
    
    // Base styles - positioning and behavior
    this.container.style.cssText = \`
      position: fixed;
      z-index: 9999;
      cursor: pointer;
      user-select: none;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.2s ease;
      font-size: 14px;
      font-weight: 500;
      padding: 8px 16px;
      min-width: 80px;
      max-width: 200px;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
    \`;

    document.body.appendChild(this.container);
  }

  _setupEventListeners() {
    if (!this.container) return;

    // Click handler
    this.container.addEventListener('click', (e) => {
      e.preventDefault();
      e.stopPropagation();
      this._handleClick();
    });

    // Hover effects
    this.container.addEventListener('mouseenter', () => {
      if (this.options.behavior.autoSlide) {
        this._slideIn();
      }
    });

    this.container.addEventListener('mouseleave', () => {
      if (this.options.behavior.autoSlide) {
        this._slideOut();
      }
    });

    // Listen for authentication events
    window.addEventListener('nlMethodSelected', (e) => {
      console.log('FloatingTab: Authentication method selected:', e.detail);
      this._handleAuth(e.detail);
    });

    window.addEventListener('nlLogout', () => {
      console.log('FloatingTab: Logout detected');
      this._handleLogout();
    });
  }

  _handleClick() {
    console.log('FloatingTab: Clicked');
    
    if (this.isAuthenticated && this.options.behavior.showUserInfo) {
      // Show user menu or profile options
      this._showUserMenu();
    } else {
      // Open login modal
      if (this.modal) {
        this.modal.open({ startScreen: 'login' });
      }
    }
  }

  async _handleAuth(authData) {
    console.log('FloatingTab: Handling authentication:', authData);
    this.isAuthenticated = true;
    this.userInfo = authData;
    
    // Fetch user profile if enabled and we have a pubkey
    if (this.options.getUserInfo && authData.pubkey) {
      console.log('FloatingTab: Fetching user profile for:', authData.pubkey);
      try {
        const profile = await this._fetchUserProfile(authData.pubkey);
        this.userProfile = profile;
        console.log('FloatingTab: User profile fetched:', profile);
      } catch (error) {
        console.warn('FloatingTab: Failed to fetch user profile:', error);
        this.userProfile = null;
      }
    }
    
    if (this.options.behavior.hideWhenAuthenticated) {
      this.hide();
    } else {
      this._updateAppearance();
    }
  }

  _handleLogout() {
    console.log('FloatingTab: Handling logout');
    this.isAuthenticated = false;
    this.userInfo = null;
    this.userProfile = null;
    
    if (this.options.behavior.hideWhenAuthenticated) {
      this.show();
    }
    
    this._updateAppearance();
  }

  _showUserMenu() {
    // Simple user menu - could be expanded
    const menu = document.createElement('div');
    menu.style.cssText = \`
      position: fixed;
      background: var(--nl-secondary-color);
      border: var(--nl-border-width) solid var(--nl-primary-color);
      border-radius: var(--nl-border-radius);
      padding: 12px;
      z-index: 10000;
      font-family: var(--nl-font-family);
      box-shadow: 0 4px 12px rgba(0,0,0,0.15);
    \`;

    // Position near the floating tab
    const tabRect = this.container.getBoundingClientRect();
    if (this.options.hPosition > 0.5) {
      // Tab is on right side, show menu to the left
      menu.style.right = (window.innerWidth - tabRect.left) + 'px';
    } else {
      // Tab is on left side, show menu to the right
      menu.style.left = tabRect.right + 'px';
    }
    menu.style.top = tabRect.top + 'px';

    // Menu content
    const userDisplay = this.userInfo?.pubkey ?
      \`\${this.userInfo.pubkey.slice(0, 8)}...\${this.userInfo.pubkey.slice(-4)}\` :
      'Authenticated';

    menu.innerHTML = \`
      <div style="margin-bottom: 8px; font-weight: bold; color: var(--nl-primary-color);">\${userDisplay}</div>
      <button onclick="window.NOSTR_LOGIN_LITE.logout(); this.parentElement.remove();"
              style="background: var(--nl-secondary-color); color: var(--nl-primary-color);
                     border: 1px solid var(--nl-primary-color); border-radius: 4px;
                     padding: 6px 12px; cursor: pointer; width: 100%;">
        Logout
      </button>
    \`;

    document.body.appendChild(menu);

    // Auto-remove menu after delay or on outside click
    const removeMenu = () => menu.remove();
    setTimeout(removeMenu, 5000);
    
    document.addEventListener('click', function onOutsideClick(e) {
      if (!menu.contains(e.target) && e.target !== this.container) {
        removeMenu();
        document.removeEventListener('click', onOutsideClick);
      }
    });
  }

  _updateAppearance() {
    if (!this.container) return;

    // Update content
    if (this.isAuthenticated && this.options.behavior.showUserInfo) {
      let display;
      
      // Use profile name if available, otherwise fall back to pubkey
      if (this.userProfile?.name || this.userProfile?.display_name) {
        const userName = this.userProfile.name || this.userProfile.display_name;
        display = this.options.appearance.iconOnly
          ? userName.slice(0, 8)
          : userName;
      } else if (this.userInfo?.pubkey) {
        // Fallback to pubkey display
        display = this.options.appearance.iconOnly
          ? this.userInfo.pubkey.slice(0, 6)
          : \`\${this.userInfo.pubkey.slice(0, 6)}...\`;
      } else {
        display = this.options.appearance.iconOnly ? 'User' : 'Authenticated';
      }
      
      this.container.textContent = display;
      this.container.className = 'nl-floating-tab nl-floating-tab--logged-in';
    } else {
      const display = this.options.appearance.iconOnly ?
        this.options.appearance.icon :
        (this.options.appearance.icon ? \`\${this.options.appearance.icon} \${this.options.appearance.text}\` : this.options.appearance.text);
      
      this.container.textContent = display;
      this.container.className = 'nl-floating-tab nl-floating-tab--logged-out';
    }

    // Apply appearance styles based on current state
    this._applyThemeStyles();
  }

  _applyThemeStyles() {
    if (!this.container) return;

    // The CSS classes will handle the theming through CSS custom properties
    // Additional style customizations can be added here if needed
    
    // Apply style variant
    if (this.options.appearance.style === 'circle') {
      this.container.style.borderRadius = '50%';
      this.container.style.width = '48px';
      this.container.style.height = '48px';
      this.container.style.minWidth = '48px';
      this.container.style.padding = '0';
    } else if (this.options.appearance.style === 'square') {
      this.container.style.borderRadius = '4px';
    } else {
      // pill style (default)
      this.container.style.borderRadius = 'var(--nl-border-radius)';
    }
  }

  async _fetchUserProfile(pubkey) {
    if (!this.options.getUserInfo) {
      console.log('FloatingTab: getUserInfo disabled, skipping profile fetch');
      return null;
    }

    // Determine which relays to use
    const relays = this.options.getUserRelay.length > 0
      ? this.options.getUserRelay
      : ['wss://relay.damus.io', 'wss://nos.lol'];

    console.log('FloatingTab: Fetching profile from relays:', relays);

    try {
      // Create a SimplePool instance for querying
      const pool = new window.NostrTools.SimplePool();
      
      // Query for kind 0 (user metadata) events
      const events = await pool.querySync(relays, {
        kinds: [0],
        authors: [pubkey],
        limit: 1
      }, { timeout: 5000 });

      console.log('FloatingTab: Profile query returned', events.length, 'events');

      if (events.length === 0) {
        console.log('FloatingTab: No profile events found');
        return null;
      }

      // Get the most recent event
      const latestEvent = events.sort((a, b) => b.created_at - a.created_at)[0];
      
      try {
        const profile = JSON.parse(latestEvent.content);
        console.log('FloatingTab: Parsed profile:', profile);
        
        // Find the best name from any key containing "name" (case-insensitive)
        let bestName = null;
        const nameKeys = Object.keys(profile).filter(key =>
          key.toLowerCase().includes('name') &&
          typeof profile[key] === 'string' &&
          profile[key].trim().length > 0
        );
        
        if (nameKeys.length > 0) {
          // Find the shortest name value
          bestName = nameKeys
            .map(key => profile[key].trim())
            .reduce((shortest, current) =>
              current.length < shortest.length ? current : shortest
            );
          console.log('FloatingTab: Found name keys:', nameKeys, 'selected:', bestName);
        }
        
        // Return relevant profile fields with the best name
        return {
          name: bestName,
          display_name: profile.display_name || null,
          about: profile.about || null,
          picture: profile.picture || null,
          nip05: profile.nip05 || null
        };
      } catch (parseError) {
        console.warn('FloatingTab: Failed to parse profile JSON:', parseError);
        return null;
      }
    } catch (error) {
      console.error('FloatingTab: Profile fetch error:', error);
      return null;
    }
  }

  _position() {
    if (!this.container) return;

    const padding = 16; // Distance from screen edge
    
    // Calculate position based on percentage
    const x = this.options.hPosition * (window.innerWidth - this.container.offsetWidth - padding * 2) + padding + this.options.offset.x;
    const y = this.options.vPosition * (window.innerHeight - this.container.offsetHeight - padding * 2) + padding + this.options.offset.y;
    
    this.container.style.left = \`\${x}px\`;
    this.container.style.top = \`\${y}px\`;

    console.log(\`FloatingTab: Positioned at (\${x}, \${y})\`);
  }

  _slideIn() {
    if (!this.container || !this.options.behavior.autoSlide) return;
    
    // Slide towards center slightly
    const currentTransform = this.container.style.transform || '';
    if (this.options.hPosition > 0.5) {
      this.container.style.transform = currentTransform + ' translateX(-8px)';
    } else {
      this.container.style.transform = currentTransform + ' translateX(8px)';
    }
  }

  _slideOut() {
    if (!this.container || !this.options.behavior.autoSlide) return;
    
    // Reset position
    this.container.style.transform = '';
  }

  show() {
    if (!this.container) return;
    this.container.style.display = 'flex';
    this.isVisible = true;
    console.log('FloatingTab: Shown');
  }

  hide() {
    if (!this.container) return;
    this.container.style.display = 'none';
    this.isVisible = false;
    console.log('FloatingTab: Hidden');
  }

  destroy() {
    if (this.container) {
      this.container.remove();
      this.container = null;
    }
    this.isVisible = false;
    console.log('FloatingTab: Destroyed');
  }

  // Update options and re-apply
  updateOptions(newOptions) {
    this.options = { ...this.options, ...newOptions };
    if (this.container) {
      this._updateAppearance();
      this._position();
    }
  }

  // Get current state
  getState() {
    return {
      isVisible: this.isVisible,
      isAuthenticated: this.isAuthenticated,
      userInfo: this.userInfo,
      options: this.options
    };
  }
}

// ======================================
// Main NOSTR_LOGIN_LITE Library
// ======================================

// Extension Bridge for managing browser extensions
class ExtensionBridge {
  constructor() {
    this.extensions = new Map();
    this.primaryExtension = null;
    this._detectExtensions();
  }
  
  _detectExtensions() {
    // Common extension locations
    const locations = [
      { path: 'window.nostr', name: 'Generic' },
      { path: 'window.alby?.nostr', name: 'Alby' },
      { path: 'window.nos2x?.nostr', name: 'nos2x' },
      { path: 'window.flamingo?.nostr', name: 'Flamingo' },
      { path: 'window.getAlby?.nostr', name: 'Alby Legacy' },
      { path: 'window.mutiny?.nostr', name: 'Mutiny' }
    ];
    
    for (const location of locations) {
      try {
        const obj = eval(location.path);
        if (obj && typeof obj.getPublicKey === 'function') {
          this.extensions.set(location.name, {
            name: location.name,
            extension: obj,
            constructor: obj.constructor?.name || 'Unknown'
          });
          
          if (!this.primaryExtension) {
            this.primaryExtension = this.extensions.get(location.name);
          }
        }
      } catch (e) {
        // Extension not available
      }
    }
  }
  
  getAllExtensions() {
    return Array.from(this.extensions.values());
  }
  
  getExtensionCount() {
    return this.extensions.size;
  }
}

// Main NostrLite class
class NostrLite {
  constructor() {
    this.options = {};
    this.extensionBridge = new ExtensionBridge();
    this.initialized = false;
    this.currentTheme = 'default';
    this.modal = null;
    this.floatingTab = null;
  }
  
  async init(options = {}) {
    console.log('NOSTR_LOGIN_LITE: Initializing with options:', options);
    
    this.options = {
      theme: 'default',
      methods: {
        extension: true,
        local: true,
        seedphrase: false,
        readonly: true,
        connect: false,
        otp: false
      },
      floatingTab: {
        enabled: false,
        hPosition: 1.0,
        vPosition: 0.5,
        offset: { x: 0, y: 0 },
        appearance: {
          style: 'pill',
          theme: 'auto',
          icon: '',
          text: 'Login',
          iconOnly: false
        },
        behavior: {
          hideWhenAuthenticated: true,
          showUserInfo: true,
          autoSlide: true,
          persistent: false
        },
        getUserInfo: false,
        getUserRelay: []
      },
      ...options
    };
    
    // Apply the selected theme (CSS-only)
    this.switchTheme(this.options.theme);
    
    // Always set up window.nostr facade to handle multiple extensions properly
    this._setupWindowNostrFacade();
    
    // Create modal during init (matching original git architecture)
    this.modal = new Modal(this.options);
    console.log('NOSTR_LOGIN_LITE: Modal created during init');
    
    // Initialize floating tab if enabled
    if (this.options.floatingTab.enabled) {
      this.floatingTab = new FloatingTab(this.modal, this.options.floatingTab);
      console.log('NOSTR_LOGIN_LITE: Floating tab initialized');
    }
    
    this.initialized = true;
    console.log('NOSTR_LOGIN_LITE: Initialization complete');
    
    return this;
  }
  
  _setupWindowNostrFacade() {
    if (typeof window !== 'undefined') {
      console.log('NOSTR_LOGIN_LITE: === TRUE SINGLE-EXTENSION ARCHITECTURE ===');
      console.log('NOSTR_LOGIN_LITE: Initial window.nostr:', window.nostr);
      console.log('NOSTR_LOGIN_LITE: Initial window.nostr constructor:', window.nostr?.constructor?.name);
      
      // Store existing window.nostr if it exists (from extensions)
      const existingNostr = window.nostr;
      
      // TRUE SINGLE-EXTENSION ARCHITECTURE: Don't install facade when extensions detected
      if (this._isRealExtension(existingNostr)) {
        console.log('NOSTR_LOGIN_LITE: ✓ REAL EXTENSION DETECTED IMMEDIATELY - PRESERVING WITHOUT FACADE');
        console.log('NOSTR_LOGIN_LITE: Extension constructor:', existingNostr.constructor?.name);
        console.log('NOSTR_LOGIN_LITE: Extension keys:', Object.keys(existingNostr));
        console.log('NOSTR_LOGIN_LITE: Leaving window.nostr untouched for extension compatibility');
        this.preservedExtension = existingNostr;
        this.facadeInstalled = false;
        // DON'T install facade - leave window.nostr as the extension
        return;
      }
      
      // DEFERRED EXTENSION DETECTION: Extensions like nos2x may load after us
      console.log('NOSTR_LOGIN_LITE: No real extension detected initially, starting deferred detection...');
      this.facadeInstalled = false;
      
      let checkCount = 0;
      const maxChecks = 10; // Check for up to 2 seconds
      const checkInterval = setInterval(() => {
        checkCount++;
        const currentNostr = window.nostr;
        
        console.log('NOSTR_LOGIN_LITE: === DEFERRED CHECK ' + checkCount + '/' + maxChecks + ' ===');
        console.log('NOSTR_LOGIN_LITE: Current window.nostr:', currentNostr);
        console.log('NOSTR_LOGIN_LITE: Constructor:', currentNostr?.constructor?.name);
        
        // Skip if it's our facade
        if (currentNostr?.constructor?.name === 'WindowNostr') {
          console.log('NOSTR_LOGIN_LITE: Skipping - this is our facade');
          return;
        }
        
        if (this._isRealExtension(currentNostr)) {
          console.log('NOSTR_LOGIN_LITE: ✓✓✓ LATE EXTENSION DETECTED - PRESERVING WITHOUT FACADE ✓✓✓');
          console.log('NOSTR_LOGIN_LITE: Extension detected after ' + (checkCount * 200) + 'ms!');
          console.log('NOSTR_LOGIN_LITE: Extension constructor:', currentNostr.constructor?.name);
          console.log('NOSTR_LOGIN_LITE: Extension keys:', Object.keys(currentNostr));
          console.log('NOSTR_LOGIN_LITE: Leaving window.nostr untouched for extension compatibility');
          this.preservedExtension = currentNostr;
          this.facadeInstalled = false;
          clearInterval(checkInterval);
          // DON'T install facade - leave window.nostr as the extension
          return;
        }
        
        // Stop checking after max attempts - no extension found
        if (checkCount >= maxChecks) {
          console.log('NOSTR_LOGIN_LITE: ⚠️ MAX CHECKS REACHED - NO EXTENSION FOUND');
          clearInterval(checkInterval);
          console.log('NOSTR_LOGIN_LITE: Installing facade for local/NIP-46/readonly methods');
          this._installFacade();
        }
      }, 200); // Check every 200ms
      
      console.log('NOSTR_LOGIN_LITE: Waiting for deferred detection to complete...');
    }
  }
  
  _installFacade(existingNostr = null) {
    if (typeof window !== 'undefined' && !this.facadeInstalled) {
      console.log('NOSTR_LOGIN_LITE: === _installFacade CALLED ===');
      console.log('NOSTR_LOGIN_LITE: existingNostr parameter:', existingNostr);
      console.log('NOSTR_LOGIN_LITE: existingNostr constructor:', existingNostr?.constructor?.name);
      console.log('NOSTR_LOGIN_LITE: window.nostr before installation:', window.nostr);
      console.log('NOSTR_LOGIN_LITE: window.nostr constructor before:', window.nostr?.constructor?.name);
      
      const facade = new WindowNostr(this, existingNostr);
      window.nostr = facade;
      this.facadeInstalled = true;
      
      console.log('NOSTR_LOGIN_LITE: === FACADE INSTALLED WITH EXTENSION ===');
      console.log('NOSTR_LOGIN_LITE: window.nostr after installation:', window.nostr);
      console.log('NOSTR_LOGIN_LITE: window.nostr constructor after:', window.nostr.constructor?.name);
      console.log('NOSTR_LOGIN_LITE: facade.existingNostr:', window.nostr.existingNostr);
    }
  }
  
  // Helper method to identify real browser extensions
  _isRealExtension(obj) {
    console.log('NOSTR_LOGIN_LITE: === _isRealExtension DEBUG ===');
    console.log('NOSTR_LOGIN_LITE: obj:', obj);
    console.log('NOSTR_LOGIN_LITE: typeof obj:', typeof obj);
    
    if (!obj || typeof obj !== 'object') {
      console.log('NOSTR_LOGIN_LITE: ✗ Not an object');
      return false;
    }
    
    console.log('NOSTR_LOGIN_LITE: Object keys:', Object.keys(obj));
    console.log('NOSTR_LOGIN_LITE: getPublicKey type:', typeof obj.getPublicKey);
    console.log('NOSTR_LOGIN_LITE: signEvent type:', typeof obj.signEvent);
    
    // Must have required Nostr methods
    if (typeof obj.getPublicKey !== 'function' || typeof obj.signEvent !== 'function') {
      console.log('NOSTR_LOGIN_LITE: ✗ Missing required methods');
      return false;
    }

    // Exclude our own library classes
    const constructorName = obj.constructor?.name;
    console.log('NOSTR_LOGIN_LITE: Constructor name:', constructorName);
    
    if (constructorName === 'WindowNostr' || constructorName === 'NostrLite') {
      console.log('NOSTR_LOGIN_LITE: ✗ Is our library class');
      return false;
    }

    // Exclude NostrTools library object
    if (obj === window.NostrTools) {
      console.log('NOSTR_LOGIN_LITE: ✗ Is NostrTools object');
      return false;
    }

    // Real extensions typically have internal properties or specific characteristics
    console.log('NOSTR_LOGIN_LITE: Extension property check:');
    console.log('  _isEnabled:', !!obj._isEnabled);
    console.log('  enabled:', !!obj.enabled);
    console.log('  kind:', !!obj.kind);
    console.log('  _eventEmitter:', !!obj._eventEmitter);
    console.log('  _scope:', !!obj._scope);
    console.log('  _requests:', !!obj._requests);
    console.log('  _pubkey:', !!obj._pubkey);
    console.log('  name:', !!obj.name);
    console.log('  version:', !!obj.version);
    console.log('  description:', !!obj.description);
    
    const hasExtensionProps = !!(
      obj._isEnabled || obj.enabled || obj.kind ||
      obj._eventEmitter || obj._scope || obj._requests || obj._pubkey ||
      obj.name || obj.version || obj.description
    );

    console.log('NOSTR_LOGIN_LITE: Extension detection result for', constructorName, ':', hasExtensionProps);
    return hasExtensionProps;
  }
  
  launch(startScreen = 'login') {
    console.log('NOSTR_LOGIN_LITE: Launching with screen:', startScreen);
    
    if (this.modal) {
      this.modal.open({ startScreen });
    } else {
      console.error('NOSTR_LOGIN_LITE: Modal not initialized - call init() first');
    }
  }
  
  logout() {
    console.log('NOSTR_LOGIN_LITE: Logout called');
    
    // Clear stored data
    if (typeof localStorage !== 'undefined') {
      localStorage.removeItem('nl_current');
    }
    
    // Dispatch logout event
    if (typeof window !== 'undefined') {
      window.dispatchEvent(new CustomEvent('nlLogout', {
        detail: { timestamp: Date.now() }
      }));
    }
  }
  
  // CSS-only theme switching
  switchTheme(themeName) {
    console.log(\`NOSTR_LOGIN_LITE: Switching to \${themeName} theme\`);
    
    if (THEME_CSS[themeName]) {
      injectThemeCSS(themeName);
      this.currentTheme = themeName;
      
      // Dispatch theme change event
      if (typeof window !== 'undefined') {
        window.dispatchEvent(new CustomEvent('nlThemeChanged', {
          detail: { theme: themeName }
        }));
      }
      
      return { theme: themeName };
    } else {
      console.warn(\`Theme '\${themeName}' not found, using default\`);
      injectThemeCSS('default');
      this.currentTheme = 'default';
      return { theme: 'default' };
    }
  }
  
  getCurrentTheme() {
    return this.currentTheme;
  }
  
  getAvailableThemes() {
    return Object.keys(THEME_CSS);
  }
  
  embed(container, options = {}) {
    console.log('NOSTR_LOGIN_LITE: Creating embedded modal in container:', container);
    
    const embedOptions = {
      ...this.options,
      ...options,
      embedded: container
    };
    
    // Create new modal instance for embedding
    const embeddedModal = new Modal(embedOptions);
    embeddedModal.open();
    
    return embeddedModal;
  }

  // Floating tab management methods
  showFloatingTab() {
    if (this.floatingTab) {
      this.floatingTab.show();
    } else {
      console.warn('NOSTR_LOGIN_LITE: Floating tab not enabled');
    }
  }

  hideFloatingTab() {
    if (this.floatingTab) {
      this.floatingTab.hide();
    }
  }

  toggleFloatingTab() {
    if (this.floatingTab) {
      if (this.floatingTab.isVisible) {
        this.floatingTab.hide();
      } else {
        this.floatingTab.show();
      }
    }
  }

  updateFloatingTab(options) {
    if (this.floatingTab) {
      this.floatingTab.updateOptions(options);
    }
  }

  getFloatingTabState() {
    return this.floatingTab ? this.floatingTab.getState() : null;
  }
}

// NIP-07 compliant window.nostr provider
class WindowNostr {
  constructor(nostrLite, existingNostr = null) {
    this.nostrLite = nostrLite;
    this.authState = null;
    this.existingNostr = existingNostr;
    this.authenticatedExtension = null;
    this._setupEventListeners();
  }

  _setupEventListeners() {
    // Listen for authentication events to store auth state
    if (typeof window !== 'undefined') {
      window.addEventListener('nlMethodSelected', (event) => {
        this.authState = event.detail;
        
        // If extension method, capture the specific extension the user chose
        if (event.detail.method === 'extension') {
          this.authenticatedExtension = event.detail.extension;
          console.log('WindowNostr: Captured authenticated extension:', this.authenticatedExtension?.constructor?.name);
        }
        
        // CRITICAL FIX: Re-install our facade for ALL authentication methods
        // Extensions may overwrite window.nostr after ANY authentication, not just extension auth
        if (typeof window !== 'undefined') {
          console.log('WindowNostr: Re-installing facade after', this.authState?.method, 'authentication');
          window.nostr = this;
        }
        
        console.log('WindowNostr: Auth state updated:', this.authState?.method);
      });

      window.addEventListener('nlLogout', () => {
        this.authState = null;
        this.authenticatedExtension = null;
        console.log('WindowNostr: Auth state cleared');
        
        // Re-install facade after logout to ensure we maintain control
        if (typeof window !== 'undefined') {
          console.log('WindowNostr: Re-installing facade after logout');
          window.nostr = this;
        }
      });
    }
  }

  async getPublicKey() {
    if (!this.authState) {
      throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
    }

    switch (this.authState.method) {
      case 'extension':
        // Use the captured authenticated extension, not current window.nostr
        const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
        if (!ext) throw new Error('Extension not available');
        return await ext.getPublicKey();
        
      case 'local':
      case 'nip46':
        return this.authState.pubkey;
        
      case 'readonly':
        throw new Error('Read-only mode - cannot get public key');
        
      default:
        throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
    }
  }

  async signEvent(event) {
    if (!this.authState) {
      throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
    }

    if (this.authState.method === 'readonly') {
      throw new Error('Read-only mode - cannot sign events');
    }

    switch (this.authState.method) {
      case 'extension':
        // Use the captured authenticated extension, not current window.nostr
        console.log('WindowNostr: signEvent - authenticatedExtension:', this.authenticatedExtension);
        console.log('WindowNostr: signEvent - authState.extension:', this.authState.extension);
        console.log('WindowNostr: signEvent - existingNostr:', this.existingNostr);
        
        const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
        console.log('WindowNostr: signEvent - using extension:', ext);
        console.log('WindowNostr: signEvent - extension constructor:', ext?.constructor?.name);
        
        if (!ext) throw new Error('Extension not available');
        return await ext.signEvent(event);
        
      case 'local': {
        // Use nostr-tools to sign with local secret key
        const { nip19, finalizeEvent } = window.NostrTools;
        let secretKey;
        
        if (this.authState.secret.startsWith('nsec')) {
          const decoded = nip19.decode(this.authState.secret);
          secretKey = decoded.data;
        } else {
          // Convert hex to Uint8Array
          secretKey = this._hexToUint8Array(this.authState.secret);
        }
        
        return finalizeEvent(event, secretKey);
      }
      
      case 'nip46': {
        // Use BunkerSigner for NIP-46
        if (!this.authState.signer?.bunkerSigner) {
          throw new Error('NIP-46 signer not available');
        }
        return await this.authState.signer.bunkerSigner.signEvent(event);
      }
      
      default:
        throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
    }
  }

  async getRelays() {
    // Return default relays since we removed the relays configuration
    return ['wss://relay.damus.io', 'wss://nos.lol'];
  }

  get nip04() {
    return {
      encrypt: async (pubkey, plaintext) => {
        if (!this.authState) {
          throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
        }

        if (this.authState.method === 'readonly') {
          throw new Error('Read-only mode - cannot encrypt');
        }

        switch (this.authState.method) {
          case 'extension': {
            const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
            if (!ext) throw new Error('Extension not available');
            return await ext.nip04.encrypt(pubkey, plaintext);
          }
            
          case 'local': {
            const { nip04, nip19 } = window.NostrTools;
            let secretKey;
            
            if (this.authState.secret.startsWith('nsec')) {
              const decoded = nip19.decode(this.authState.secret);
              secretKey = decoded.data;
            } else {
              secretKey = this._hexToUint8Array(this.authState.secret);
            }
            
            return await nip04.encrypt(secretKey, pubkey, plaintext);
          }
          
          case 'nip46': {
            if (!this.authState.signer?.bunkerSigner) {
              throw new Error('NIP-46 signer not available');
            }
            return await this.authState.signer.bunkerSigner.nip04Encrypt(pubkey, plaintext);
          }
          
          default:
            throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
        }
      },

      decrypt: async (pubkey, ciphertext) => {
        if (!this.authState) {
          throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
        }

        if (this.authState.method === 'readonly') {
          throw new Error('Read-only mode - cannot decrypt');
        }

        switch (this.authState.method) {
          case 'extension': {
            const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
            if (!ext) throw new Error('Extension not available');
            return await ext.nip04.decrypt(pubkey, ciphertext);
          }
            
          case 'local': {
            const { nip04, nip19 } = window.NostrTools;
            let secretKey;
            
            if (this.authState.secret.startsWith('nsec')) {
              const decoded = nip19.decode(this.authState.secret);
              secretKey = decoded.data;
            } else {
              secretKey = this._hexToUint8Array(this.authState.secret);
            }
            
            return await nip04.decrypt(secretKey, pubkey, ciphertext);
          }
          
          case 'nip46': {
            if (!this.authState.signer?.bunkerSigner) {
              throw new Error('NIP-46 signer not available');
            }
            return await this.authState.signer.bunkerSigner.nip04Decrypt(pubkey, ciphertext);
          }
          
          default:
            throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
        }
      }
    };
  }

  get nip44() {
    return {
      encrypt: async (pubkey, plaintext) => {
        if (!this.authState) {
          throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
        }

        if (this.authState.method === 'readonly') {
          throw new Error('Read-only mode - cannot encrypt');
        }

        switch (this.authState.method) {
          case 'extension': {
            const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
            if (!ext) throw new Error('Extension not available');
            return await ext.nip44.encrypt(pubkey, plaintext);
          }
            
          case 'local': {
            const { nip44, nip19 } = window.NostrTools;
            let secretKey;
            
            if (this.authState.secret.startsWith('nsec')) {
              const decoded = nip19.decode(this.authState.secret);
              secretKey = decoded.data;
            } else {
              secretKey = this._hexToUint8Array(this.authState.secret);
            }
            
            return nip44.encrypt(plaintext, nip44.getConversationKey(secretKey, pubkey));
          }
          
          case 'nip46': {
            if (!this.authState.signer?.bunkerSigner) {
              throw new Error('NIP-46 signer not available');
            }
            return await this.authState.signer.bunkerSigner.nip44Encrypt(pubkey, plaintext);
          }
          
          default:
            throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
        }
      },

      decrypt: async (pubkey, ciphertext) => {
        if (!this.authState) {
          throw new Error('Not authenticated - use NOSTR_LOGIN_LITE.launch()');
        }

        if (this.authState.method === 'readonly') {
          throw new Error('Read-only mode - cannot decrypt');
        }

        switch (this.authState.method) {
          case 'extension': {
            const ext = this.authenticatedExtension || this.authState.extension || this.existingNostr;
            if (!ext) throw new Error('Extension not available');
            return await ext.nip44.decrypt(pubkey, ciphertext);
          }
            
          case 'local': {
            const { nip44, nip19 } = window.NostrTools;
            let secretKey;
            
            if (this.authState.secret.startsWith('nsec')) {
              const decoded = nip19.decode(this.authState.secret);
              secretKey = decoded.data;
            } else {
              secretKey = this._hexToUint8Array(this.authState.secret);
            }
            
            return nip44.decrypt(ciphertext, nip44.getConversationKey(secretKey, pubkey));
          }
          
          case 'nip46': {
            if (!this.authState.signer?.bunkerSigner) {
              throw new Error('NIP-46 signer not available');
            }
            return await this.authState.signer.bunkerSigner.nip44Decrypt(pubkey, ciphertext);
          }
          
          default:
            throw new Error(\`Unsupported auth method: \${this.authState.method}\`);
        }
      }
    };
  }

  _hexToUint8Array(hex) {
    if (hex.length % 2 !== 0) {
      throw new Error('Invalid hex string length');
    }
    const bytes = new Uint8Array(hex.length / 2);
    for (let i = 0; i < bytes.length; i++) {
      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
    }
    return bytes;
  }
}

// Initialize and export
if (typeof window !== 'undefined') {
  const nostrLite = new NostrLite();
  
  // Export main API
  window.NOSTR_LOGIN_LITE = {
    init: (options) => nostrLite.init(options),
    launch: (startScreen) => nostrLite.launch(startScreen),
    logout: () => nostrLite.logout(),
    
    // Embedded modal method
    embed: (container, options) => nostrLite.embed(container, options),
    
    // CSS-only theme management API
    switchTheme: (themeName) => nostrLite.switchTheme(themeName),
    getCurrentTheme: () => nostrLite.getCurrentTheme(),
    getAvailableThemes: () => nostrLite.getAvailableThemes(),
    
    // Floating tab management API
    showFloatingTab: () => nostrLite.showFloatingTab(),
    hideFloatingTab: () => nostrLite.hideFloatingTab(),
    toggleFloatingTab: () => nostrLite.toggleFloatingTab(),
    updateFloatingTab: (options) => nostrLite.updateFloatingTab(options),
    getFloatingTabState: () => nostrLite.getFloatingTabState(),
    
    // Expose for debugging
    _extensionBridge: nostrLite.extensionBridge,
    _instance: nostrLite
  };
  
  console.log('NOSTR_LOGIN_LITE: Library loaded and ready');
  console.log('NOSTR_LOGIN_LITE: Use window.NOSTR_LOGIN_LITE.init(options) to initialize');
  console.log('NOSTR_LOGIN_LITE: Detected', nostrLite.extensionBridge.getExtensionCount(), 'browser extensions');
} else {
  // Node.js environment
  module.exports = { NostrLite };
}
`;
  
  // Write the complete bundle
  fs.writeFileSync(outputPath, bundle, 'utf8');
  
  const sizeKB = (bundle.length / 1024).toFixed(2);
  console.log(`\n✅ nostr-lite.js bundle created: ${outputPath}`);
  console.log(`📏 Bundle size: ${sizeKB} KB`);
  console.log(`📄 Total lines: ${bundle.split('\n').length}`);
  
  // Check what's included
  const hasModal = bundle.includes('class Modal');
  const hasNostrLite = bundle.includes('NOSTR_LOGIN_LITE');
  const hasThemeCss = bundle.includes('THEME_CSS');
  
  console.log('\n📋 Bundle contents:');
  console.log(`  Modal UI: ${hasModal ? '✅ Included' : '❌ Missing'}`);
  console.log(`  NOSTR_LOGIN_LITE: ${hasNostrLite ? '✅ Included' : '❌ Missing'}`);
  console.log(`  CSS-Only Themes: ${hasThemeCss ? '✅ Included' : '❌ Missing'}`);
  console.log(`  Extension Bridge: ✅ Included`);
  console.log(`  Window.nostr facade: ✅ Included`);
  
  console.log('\n📋 Two-file architecture:');
  console.log('  1. nostr.bundle.js (official nostr-tools - 220KB)');
  console.log(`  2. nostr-lite.js (NOSTR_LOGIN_LITE with CSS-only themes - ${sizeKB}KB)`);
  
  return bundle;
}

// Run if called directly
if (typeof require !== 'undefined' && require.main === module) {
  createNostrLoginLiteBundle();
}

module.exports = { createNostrLoginLiteBundle };