script.js

/* ===== PassGen — Password Generator Logic ===== */
// Developer: zrnge.com
// Repo: github.com/zrnge/passgen

(function () {
  'use strict';

  // Character sets
  const CHARSETS = {
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    lower: 'abcdefghijklmnopqrstuvwxyz',
    number: '0123456789',
    symbol: '!@#$%^&*()_+-=[]{}|;:,.<>?~'
  };

  const AMBIGUOUS = 'Il1O0';

  // DOM
  const passwordText   = document.getElementById('passwordText');
  const passwordDisplay= document.getElementById('passwordDisplay');
  const copyBtn        = document.getElementById('copyBtn');
  const lengthSlider   = document.getElementById('lengthSlider');
  const lengthValue    = document.getElementById('lengthValue');
  const upperEl        = document.getElementById('uppercase');
  const lowerEl        = document.getElementById('lowercase');
  const numberEl       = document.getElementById('numbers');
  const symbolEl       = document.getElementById('symbols');
  const excludeAmbEl   = document.getElementById('excludeAmbiguous');
  const generateBtn    = document.getElementById('generateBtn');
  const strengthFill   = document.getElementById('strengthFill');
  const strengthLabel  = document.getElementById('strengthLabel');
  const toast          = document.getElementById('toast');

  let currentPassword = '';

  // ---- Secure random integer using crypto ----
  function secureRandomInt(max) {
    if (max <= 0) return 0;
    const array = new Uint32Array(1);
    // Rejection sampling for uniform distribution
    const limit = 4294967296 - (4294967296 % max);
    let val;
    do {
      crypto.getRandomValues(array);
      val = array[0];
    } while (val >= limit);
    return val % max;
  }

  // ---- Build the character pool ----
  function buildPool() {
    let pool = '';
    const sets = [];
    if (upperEl.checked)  sets.push(CHARSETS.upper);
    if (lowerEl.checked)  sets.push(CHARSETS.lower);
    if (numberEl.checked) sets.push(CHARSETS.number);
    if (symbolEl.checked) sets.push(CHARSETS.symbol);

    if (sets.length === 0) return { pool: '', sets: [] };

    // Filter ambiguous characters if requested
    if (excludeAmbEl.checked) {
      for (let i = 0; i < sets.length; i++) {
        sets[i] = sets[i].split('').filter(c => !AMBIGUOUS.includes(c)).join('');
      }
    }

    pool = sets.join('');
    return { pool, sets };
  }

  // ---- Generate password ----
  function generatePassword() {
    const length = parseInt(lengthSlider.value, 10);
    const { pool, sets } = buildPool();

    if (!pool) {
      passwordText.textContent = 'Select at least one option';
      passwordText.classList.add('empty');
      currentPassword = '';
      updateStrength('');
      return;
    }

    const chars = [];

    // Guarantee at least one char from each selected set
    for (let i = 0; i < sets.length && i < length; i++) {
      chars.push(sets[i][secureRandomInt(sets[i].length)]);
    }

    // Fill the rest from the full pool
    while (chars.length < length) {
      chars.push(pool[secureRandomInt(pool.length)]);
    }

    // Shuffle (Fisher-Yates with secure random)
    for (let i = chars.length - 1; i > 0; i--) {
      const j = secureRandomInt(i + 1);
      [chars[i], chars[j]] = [chars[j], chars[i]];
    }

    currentPassword = chars.join('');
    passwordText.textContent = currentPassword;
    passwordText.classList.remove('empty');
    updateStrength(currentPassword);
  }

  // ---- Strength estimation ----
  function updateStrength(pw) {
    if (!pw) {
      strengthFill.style.width = '0%';
      strengthFill.style.background = 'var(--danger)';
      strengthLabel.textContent = '—';
      strengthLabel.style.color = 'var(--text-dim)';
      return;
    }

    let poolSize = 0;
    if (/[a-z]/.test(pw))  poolSize += 26;
    if (/[A-Z]/.test(pw))  poolSize += 26;
    if (/[0-9]/.test(pw))  poolSize += 10;
    if (/[^a-zA-Z0-9]/.test(pw)) poolSize += 26;

    const entropy = pw.length * Math.log2(poolSize || 1);
    const pct = Math.min(100, (entropy / 128) * 100);

    let label, color;
    if (entropy < 40)       { label = 'Weak';     color = 'var(--danger)'; }
    else if (entropy < 60)  { label = 'Fair';     color = 'var(--warn)'; }
    else if (entropy < 80)  { label = 'Strong';   color = '#4dffaa'; }
    else                    { label = 'Very Strong'; color = 'var(--ok)'; }

    strengthFill.style.width = pct + '%';
    strengthFill.style.background = color;
    strengthLabel.textContent = label;
    strengthLabel.style.color = color;
  }

  // ---- Copy to clipboard ----
  function copyPassword() {
    if (!currentPassword) return;
    if (navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(currentPassword).then(() => {
        copyBtn.classList.add('copied');
        showToast('Copied to clipboard!');
        setTimeout(() => copyBtn.classList.remove('copied'), 1500);
      }).catch(fallbackCopy);
    } else {
      fallbackCopy();
    }
  }

  // Legacy fallback for non-secure contexts (file://, HTTP)
  function fallbackCopy() {
    const ta = document.createElement('textarea');
    ta.value = currentPassword;
    ta.setAttribute('readonly', '');
    ta.style.position = 'absolute';
    ta.style.left = '-9999px';
    document.body.appendChild(ta);
    ta.select();
    try {
      document.execCommand('copy');
      copyBtn.classList.add('copied');
      showToast('Copied to clipboard!');
      setTimeout(() => copyBtn.classList.remove('copied'), 1500);
    } catch (e) {
      showToast('Copy failed');
    }
    document.body.removeChild(ta);
  }

  // ---- Toast ----
  let toastTimer;
  function showToast(msg) {
    toast.textContent = msg;
    toast.classList.add('show');
    clearTimeout(toastTimer);
    toastTimer = setTimeout(() => toast.classList.remove('show'), 2000);
  }

  // ---- Events ----
  let sliderTimer;
  lengthSlider.addEventListener('input', () => {
    lengthValue.textContent = lengthSlider.value;
    // Regenerate in real-time, debounced so dragging stays smooth
    clearTimeout(sliderTimer);
    sliderTimer = setTimeout(generatePassword, 120);
  });

  generateBtn.addEventListener('click', generatePassword);
  copyBtn.addEventListener('click', (e) => { e.stopPropagation(); copyPassword(); });
  passwordDisplay.addEventListener('click', copyPassword);
  passwordDisplay.addEventListener('keydown', (e) => {
    if (e.code === 'Space' || e.code === 'Enter') {
      e.preventDefault();
      e.stopPropagation();
      copyPassword();
    }
  });

  // Regenerate when options change (if a password already exists)
  [upperEl, lowerEl, numberEl, symbolEl, excludeAmbEl].forEach(el => {
    el.addEventListener('change', () => {
      if (currentPassword) generatePassword();
    });
  });

  // Keyboard shortcut: Space / Enter to generate
  document.addEventListener('keydown', (e) => {
    if (e.code === 'Space' && e.target === document.body) {
      e.preventDefault();
      generatePassword();
    }
  });

  // ---- Mouse-following glow ----
  const mouseGlow = document.getElementById('mouseGlow');
  const orbsContainer = document.querySelector('.bg-orbs');
  let mouseX = window.innerWidth / 2;
  let mouseY = window.innerHeight / 2;
  let glowX = mouseX;
  let glowY = mouseY;
  let glowActive = false;
  let parallaxX = 0;
  let parallaxY = 0;
  let rafId = null;

  // Start the animation loop on demand (stops when converged to save CPU)
  function startGlowLoop() {
    if (rafId) return;
    rafId = requestAnimationFrame(animateGlow);
  }

  document.addEventListener('mousemove', (e) => {
    mouseX = e.clientX;
    mouseY = e.clientY;
    if (!glowActive) {
      glowActive = true;
      mouseGlow.classList.add('active');
    }
    startGlowLoop();
  });

  // Use documentElement — mouseleave on document doesn't fire reliably
  document.documentElement.addEventListener('mouseleave', () => {
    glowActive = false;
    mouseGlow.classList.remove('active');
  });

  // Smooth animation loop — lerp the glow toward the cursor
  // and shift the orb container slightly for a parallax effect.
  // Stops itself when converged to avoid running 60 fps forever.
  function animateGlow() {
    glowX += (mouseX - glowX) * 0.12;
    glowY += (mouseY - glowY) * 0.12;
    mouseGlow.style.transform = 'translate(' + glowX + 'px, ' + glowY + 'px)';

    // Subtle parallax on the orb container (opposite direction for depth).
    // Applied to the container because CSS animations on individual orbs
    // override inline transforms, so per-orb JS transforms were ignored.
    const targetPX = -(mouseX - window.innerWidth / 2) / window.innerWidth * 25;
    const targetPY = -(mouseY - window.innerHeight / 2) / window.innerHeight * 25;
    parallaxX += (targetPX - parallaxX) * 0.12;
    parallaxY += (targetPY - parallaxY) * 0.12;
    if (orbsContainer) {
      orbsContainer.style.transform = 'translate(' + parallaxX + 'px, ' + parallaxY + 'px)';
    }

    // Stop the loop when everything has converged
    if (Math.abs(mouseX - glowX) < 0.5 &&
        Math.abs(mouseY - glowY) < 0.5 &&
        Math.abs(targetPX - parallaxX) < 0.5 &&
        Math.abs(targetPY - parallaxY) < 0.5) {
      rafId = null;
      return;
    }

    rafId = requestAnimationFrame(animateGlow);
  }
  startGlowLoop();

  // ---- Theme toggle (dark / light) ----
  const themeToggle = document.getElementById('themeToggle');

  function applyTheme(theme) {
    if (theme === 'light') {
      document.body.classList.add('light');
    } else {
      document.body.classList.remove('light');
    }
  }

  // Restore saved preference (defaults to dark)
  try {
    const saved = localStorage.getItem('passgen-theme');
    applyTheme(saved === 'light' ? 'light' : 'dark');
  } catch (e) {
    applyTheme('dark');
  }

  themeToggle.addEventListener('click', () => {
    const isLight = document.body.classList.toggle('light');
    try { localStorage.setItem('passgen-theme', isLight ? 'light' : 'dark'); } catch (e) {}
  });

  // ---- Initial generation ----
  generatePassword();
})();