import express from 'express';
import crypto from 'crypto';
import bcrypt from 'bcryptjs';
import { v4 as uuid } from 'uuid';
import db from '../config/database.js';
import { renderPage } from '../middleware/render.js';
import { loginLimiter, registerLimiter } from '../middleware/rate-limit.js';
import { safeNext, requireAuth } from '../middleware/auth.js';
import { googleConfigured, authorizeUrl, exchangeCode, fetchUserinfo } from '../config/google.js';
import { premiumUnlocked } from '../services/PatreonService.js';

// Fan-login (luisteraars inloggen met Google om te reageren) is een premium-
// feature: beschikbaar als Google is ingesteld ÉN de premium-laag ontgrendeld is
// (premium uit = vrij; aan = Patreon vereist).
function fanLoginReady() {
  return googleConfigured() && premiumUnlocked();
}
import { mailerConfigured, sendMail } from '../config/mailer.js';
import { resolveLang, t } from '../services/i18n.js';
import { setSetting } from '../services/SettingsService.js';

const router = express.Router();

// Vaste dummy-hash: zo draait login altijd één bcrypt-vergelijking, ook als de
// user niet bestaat of geen wachtwoord heeft — geen timing-oracle voor enumeratie.
const DUMMY_HASH = bcrypt.hashSync('constant-time-login-guard', 10);

// Canonieke basis-URL voor links in e-mails (reset). Uit headers bouwen is
// spoofbaar (X-Forwarded-Host); een vaste config sluit dat uit.
function publicBaseUrl(req) {
  const cfg = (process.env.PUBLIC_BASE_URL || '').replace(/\/$/, '');
  if (cfg) return cfg;
  // Fallback (dev): trust-proxy-gesaneerde protocol + Host-header (NIET de rauwe
  // X-Forwarded-Host).
  return `${req.protocol}://${req.get('host')}`;
}

function hashToken(raw) {
  return crypto.createHash('sha256').update(String(raw)).digest('hex');
}

// Eerste-keer-setup? Pas zolang er nog geen enkele gebruiker is mag /register een
// beheerder aanmaken. Daarna is registratie dicht (luisteraars komen via Google).
function isSetupMode() {
  return db.prepare('SELECT COUNT(*) AS c FROM users').get().c === 0;
}

// ==================== LOGIN ====================
// Publieke loginpagina: voor BEZOEKERS alleen Google-login (luisteraars/fans).
// De beheerders-login (wachtwoord) staat hier bewust NIET — die zit verborgen op
// /auth/admin (zie hieronder), zodat de admin-login niet zichtbaar is op de plek
// waar bezoekers heen worden gestuurd.
router.get('/login', (req, res) => {
  const next = safeNext(req.query.next) || '';
  if (req.session.user) return res.redirect(next || '/');
  if (isSetupMode()) return res.redirect('/auth/register' + (next ? '?next=' + encodeURIComponent(next) : ''));
  renderPage(req, res, 'pages/auth-login', {
    pageTitle: 'Inloggen',
    bodyClass: 'on-special on-auth',
    error: req.query.error || null,
    gerr: req.query.gerr || null, // foutcode voor een rijkere uitleg (bv. 'admin')
    success: req.query.success || null,
    username: '',
    adminLogin: false,
    googleReady: fanLoginReady(),
    next,
  });
});

// Verborgen beheerders-login (gebruikersnaam + wachtwoord). Nergens in de UI
// gelinkt — de beheerder navigeert hier rechtstreeks naartoe (/auth/admin).
router.get('/admin', (req, res) => {
  const next = safeNext(req.query.next) || '';
  if (req.session.user) return res.redirect(next || '/');
  if (isSetupMode()) return res.redirect('/auth/register' + (next ? '?next=' + encodeURIComponent(next) : ''));
  renderPage(req, res, 'pages/auth-login', {
    pageTitle: 'Beheerder inloggen',
    bodyClass: 'on-special on-auth',
    error: req.query.error || null,
    gerr: null,
    success: req.query.success || null,
    username: '',
    adminLogin: true,
    googleReady: false,
    next,
  });
});

router.post('/login', loginLimiter, (req, res) => {
  const { username, password } = req.body;
  const next = safeNext(req.body.next) || '';

  // Foutweergave op de (verborgen) beheerders-loginpagina: toon het wachtwoord-
  // formulier opnieuw (adminLogin:true), niet de Google-only publieke pagina.
  const renderErr = (error, status = 400) => {
    res.status(status);
    return renderPage(req, res, 'pages/auth-login', {
      pageTitle: 'Beheerder inloggen', bodyClass: 'on-special on-auth',
      error, gerr: null, success: null, username: username || '',
      adminLogin: true, googleReady: false, next,
    });
  };

  if (!username || !password) return renderErr('Gebruikersnaam en wachtwoord vereist');

  const user = db.prepare('SELECT * FROM users WHERE username = ? OR email = ?').get(username, username);
  // Altijd één bcrypt-vergelijking (dummy als de user geen bruikbaar wachtwoord
  // heeft) zodat de responstijd niets over het bestaan van een account verraadt.
  const usable = !!(user && user.password_hash && user.password_hash !== '!google-oauth');
  const ok = bcrypt.compareSync(password, usable ? user.password_hash : DUMMY_HASH);
  if (!usable || !ok) return renderErr('Ongeldige inloggegevens', 401);

  req.session.user = {
    id: user.id, username: user.username, email: user.email, role: user.role,
    avatar_url: user.avatar_url, palette: user.palette, theme: user.theme,
    readonly: !!user.readonly,
  };
  res.redirect(next || '/');
});

// ==================== EERSTE-KEER-SETUP (beheerder aanmaken) ====================
router.get('/register', (req, res) => {
  const next = safeNext(req.query.next) || '';
  if (req.session.user) return res.redirect(next || '/');
  // Geen publieke registratie: alleen de allereerste beheerder mag hier aangemaakt.
  if (!isSetupMode()) return res.redirect('/auth/login' + (next ? '?next=' + encodeURIComponent(next) : ''));
  renderPage(req, res, 'pages/auth-register', {
    pageTitle: t(resolveLang(req), 'setup.title'), bodyClass: 'on-special',
    error: null, username: '', email: '', siteName: '', next,
  });
});

router.post('/register', registerLimiter, (req, res) => {
  const { username, email, password, siteName } = req.body;
  const next = safeNext(req.body.next) || '';
  const renderErr = (error) => renderPage(req, res, 'pages/auth-register', {
    pageTitle: t(resolveLang(req), 'setup.title'), bodyClass: 'on-special',
    error, username: username || '', email: email || '', siteName: siteName || '', next,
  });

  // Hard gesloten zodra er een gebruiker is — voorkomt een tweede "admin" via deze route.
  if (!isSetupMode()) return res.redirect('/auth/login');

  if (!username || !email || !password) return renderErr('Alle velden zijn verplicht');
  if (!/^[a-z0-9_-]{3,32}$/i.test(username)) {
    return renderErr('Gebruikersnaam: 3-32 tekens, letters/cijfers/_/- alleen');
  }
  if (password.length < 8) return renderErr('Wachtwoord moet minstens 8 tekens zijn');

  const userId = uuid();
  const hash = bcrypt.hashSync(password, 10);
  // De allereerste gebruiker is de beheerder (god).
  db.prepare(`
    INSERT INTO users (id, username, email, password_hash, role, theme, palette)
    VALUES (?, ?, ?, ?, 'god', 'dark', 'sage')
  `).run(userId, username, email, hash);

  // Persoonlijke site auto-aanmaken (single-tenant-ombouw volgt later).
  // Setup-wizard: sitenaam + taal komen uit het formulier; taal = de taal waarin
  // de bezoeker de wizard invulde (resolveLang) en wordt meteen de site-standaard.
  if (!db.prepare('SELECT 1 FROM sites LIMIT 1').get()) {
    const siteId = uuid();
    const lang = resolveLang(req);
    const title = (siteName || '').trim().slice(0, 80) || (username + "'s Site");
    db.prepare(`
      INSERT INTO sites (id, slug, title, description, owner_id, palette, accent, language)
      VALUES (?, ?, ?, ?, ?, 'klonkt', '#e8b04b', ?)
    `).run(siteId, username.toLowerCase(), title, '', userId, lang);
    db.prepare(`INSERT INTO site_members (site_id, user_id, role) VALUES (?, ?, 'admin')`).run(siteId, userId);
    try { setSetting('default_lang', lang); } catch (e) { /* niet fataal */ }
  }

  req.session.user = { id: userId, username, email, role: 'god', palette: 'klonkt', theme: 'dark' };
  res.redirect(next || '/');
});

// ==================== WACHTWOORD VERGETEN (aanvraag) ====================
router.get('/reset-request', (req, res) => {
  if (req.session.user) return res.redirect('/');
  renderPage(req, res, 'pages/auth-reset-request', {
    pageTitle: 'Wachtwoord resetten', bodyClass: 'on-special',
    error: null, sent: false, devResetUrl: null, mailer: mailerConfigured(),
  });
});

router.post('/reset-request', registerLimiter, async (req, res) => {
  const email = (req.body.email || '').trim().toLowerCase();
  let devResetUrl = null;

  if (email) {
    const user = db.prepare('SELECT id, email FROM users WHERE LOWER(email) = ?').get(email);
    if (user) {
      const token = crypto.randomBytes(32).toString('hex'); // ruw: gaat alleen de mail/link in
      const expires = new Date(Date.now() + 30 * 60 * 1000).toISOString(); // 30 min
      // Alleen de HASH opslaan: DB-leestoegang levert zo geen bruikbaar token op.
      db.prepare('UPDATE users SET reset_token = ?, reset_token_expires = ? WHERE id = ?')
        .run(hashToken(token), expires, user.id);

      const url = `${publicBaseUrl(req)}/auth/reset/${token}`;

      if (mailerConfigured()) {
        try {
          await sendMail({
            to: user.email,
            subject: 'Wachtwoord resetten',
            text: `Reset je wachtwoord via deze link (30 min geldig):\n\n${url}\n\nNiet aangevraagd? Negeer deze mail.`,
            html: `<p>Reset je wachtwoord via deze link (30 min geldig):</p><p><a href="${url}">${url}</a></p><p>Niet aangevraagd? Negeer deze mail.</p>`,
          });
        } catch (e) {
          console.error('[reset-request] mail faalde:', e.message);
        }
      } else if (process.env.NODE_ENV !== 'production') {
        // Dev zonder SMTP: link in log + op de pagina tonen.
        console.log(`[password-reset] ${user.email} -> ${url}`);
        devResetUrl = url;
      } else {
        // Productie zonder SMTP: NOOIT het token loggen. Verwijs naar de CLI break-glass.
        console.log(`[password-reset] aangevraagd voor ${user.email} (geen SMTP — gebruik 'npm run reset-admin')`);
      }
    }
  }

  // Anti-enumeratie: zelfde antwoord ongeacht of het adres bestaat.
  renderPage(req, res, 'pages/auth-reset-request', {
    pageTitle: 'Wachtwoord resetten', bodyClass: 'on-special',
    error: null, sent: true, devResetUrl, mailer: mailerConfigured(),
  });
});

// ==================== WACHTWOORD RESETTEN (toepassen) ====================
router.get('/reset/:token', (req, res) => {
  const row = db.prepare(`
    SELECT id, username FROM users
    WHERE reset_token = ? AND reset_token_expires > datetime('now')
  `).get(hashToken(req.params.token));
  renderPage(req, res, 'pages/auth-reset', {
    pageTitle: 'Wachtwoord resetten', bodyClass: 'on-special',
    error: row ? null : 'Deze reset-link is ongeldig of verlopen.',
    token: row ? req.params.token : null,
    username: row ? row.username : null,
  });
});

router.post('/reset/:token', (req, res) => {
  const { new_password, confirm } = req.body;
  const row = db.prepare(`
    SELECT id, username FROM users
    WHERE reset_token = ? AND reset_token_expires > datetime('now')
  `).get(hashToken(req.params.token));

  const renderError = (msg) => renderPage(req, res, 'pages/auth-reset', {
    pageTitle: 'Wachtwoord resetten', bodyClass: 'on-special',
    error: msg, token: row ? req.params.token : null, username: row ? row.username : null,
  });

  if (!row) return renderError('Deze reset-link is ongeldig of verlopen.');
  if (!new_password || new_password.length < 8) return renderError('Wachtwoord moet minstens 8 tekens zijn');
  if (new_password !== confirm) return renderError('Wachtwoorden komen niet overeen');

  const hash = bcrypt.hashSync(new_password, 10);
  db.prepare(`
    UPDATE users SET password_hash = ?, reset_token = NULL, reset_token_expires = NULL,
      updated_at = CURRENT_TIMESTAMP WHERE id = ?
  `).run(hash, row.id);
  res.redirect('/auth/admin?success=' + encodeURIComponent('Wachtwoord gereset — log nu in.'));
});

// ==================== GOOGLE-LOGIN (luisteraars/reageerders) ====================
// Per-instance, eigen Google-client. Geeft ALTIJD rol member — nooit beheer.
router.get('/google', (req, res) => {
  if (!fanLoginReady()) {
    return res.redirect('/auth/login?gerr=unavailable');
  }
  const state = crypto.randomBytes(16).toString('hex');
  req.session.oauthState = state;
  req.session.oauthNext = safeNext(req.query.next) || '';
  delete req.session.oauthLink;
  res.redirect(authorizeUrl(state));
});

// Google KOPPELEN aan het huidige (ingelogde) account — bv. een beheerder die
// voortaan óók met Google wil inloggen. Vereist dat je al ingelogd bent (met
// wachtwoord); de koppeling slaat de google_sub op het eigen account op.
// Alleen googleConfigured() nodig (geen premium-gate — dit is geen fan-login).
router.get('/google/link', requireAuth, (req, res) => {
  if (!googleConfigured()) {
    return res.redirect('/account?error=' + encodeURIComponent('Google-login is op deze site niet ingesteld.'));
  }
  const state = crypto.randomBytes(16).toString('hex');
  req.session.oauthState = state;
  req.session.oauthLink = true; // koppel-modus i.p.v. login-modus
  res.redirect(authorizeUrl(state));
});

function uniqueUsername(base) {
  let u = String(base || 'luisteraar').toLowerCase().replace(/[^a-z0-9_-]/g, '').slice(0, 28);
  if (u.length < 3) u = 'luisteraar';
  let candidate = u, n = 1;
  while (db.prepare('SELECT 1 FROM users WHERE username = ?').get(candidate)) {
    candidate = (u.slice(0, 26) + n).slice(0, 32);
    n++;
  }
  return candidate;
}

router.get('/google/callback', async (req, res) => {
  const linking = !!req.session.oauthLink;
  const failLogin = (code) => res.redirect('/auth/login?gerr=' + code);
  const failLink = (msg) => res.redirect('/account?error=' + encodeURIComponent(msg));

  try {
    const { code, state } = req.query;
    if (!code || !state || state !== req.session.oauthState) {
      delete req.session.oauthState; delete req.session.oauthLink; delete req.session.oauthNext;
      return linking ? failLink('Google-koppeling afgebroken of sessie verlopen. Probeer opnieuw.') : failLogin('session');
    }

    const tok = await exchangeCode(String(code));
    const info = await fetchUserinfo(tok.access_token);
    const email = (info.email || '').trim().toLowerCase();

    // ── KOPPEL-MODUS: Google aan het huidige (ingelogde) account hangen ──
    if (linking) {
      delete req.session.oauthState; delete req.session.oauthLink;
      if (!req.session.user) return failLogin('session');
      if (!info.sub) return failLink('Google gaf geen account-id terug. Probeer opnieuw.');
      if (info.email && info.email_verified === false) return failLink('Je Google-adres is niet geverifieerd.');
      // Dit Google-account mag niet al aan een ANDER account hangen.
      const other = db.prepare('SELECT id FROM users WHERE google_sub = ? AND id != ?').get(info.sub, req.session.user.id);
      if (other) return failLink('Dit Google-account is al aan een andere gebruiker gekoppeld.');
      db.prepare(`
        UPDATE users SET google_sub = ?, avatar_url = COALESCE(avatar_url, ?),
          updated_at = CURRENT_TIMESTAMP WHERE id = ?
      `).run(info.sub, info.picture || null, req.session.user.id);
      return res.redirect('/account?success=' + encodeURIComponent('Google-account gekoppeld — je kunt nu ook met Google inloggen.'));
    }

    // ── LOGIN-MODUS (luisteraars/fans + gekoppelde beheerder) ──
    if (!fanLoginReady()) return failLogin('unavailable');
    const next = safeNext(req.session.oauthNext) || '';
    delete req.session.oauthState; delete req.session.oauthNext;
    if (!email || info.email_verified === false) return failLogin('email');

    // Zoek EERST op de gekoppelde Google-account (google_sub). Een sub-match is het
    // expliciete koppel-bewijs → log in met de eigen rol, OOK als het Google-
    // mailadres afwijkt van het account-mailadres (bv. een beheerder die een ander
    // Gmail koppelt). Daarna pas op e-mail.
    let user = info.sub ? db.prepare('SELECT * FROM users WHERE google_sub = ?').get(info.sub) : null;

    if (user) {
      // Gekoppeld account gevonden → eigen rol behouden. Avatar bijwerken indien leeg.
      db.prepare(`
        UPDATE users SET avatar_url = COALESCE(avatar_url, ?), updated_at = CURRENT_TIMESTAMP WHERE id = ?
      `).run(info.picture || null, user.id);
    } else {
      user = db.prepare('SELECT * FROM users WHERE LOWER(email) = ?').get(email);
      if (user && (user.role === 'god' || user.role === 'admin')) {
        // Beheerder gevonden op e-mail maar ZONDER gekoppelde sub → Google geeft
        // nooit beheer. Eerst koppelen via Account → Inloggen met Google.
        return failLogin('admin');
      } else if (user) {
        // Bestaande luisteraar: koppel google_sub/avatar als die ontbreken.
        db.prepare(`
          UPDATE users SET google_sub = COALESCE(google_sub, ?), avatar_url = COALESCE(avatar_url, ?),
            updated_at = CURRENT_TIMESTAMP WHERE id = ?
        `).run(info.sub || null, info.picture || null, user.id);
      } else {
        // Nieuwe luisteraar — altijd member.
        const userId = uuid();
        const username = uniqueUsername(info.name || email.split('@')[0]);
        db.prepare(`
          INSERT INTO users (id, username, email, password_hash, role, avatar_url, theme, palette, google_sub)
          VALUES (?, ?, ?, '!google-oauth', 'member', ?, 'dark', 'sage', ?)
        `).run(userId, username, info.email || email, info.picture || null, info.sub || null);
        user = db.prepare('SELECT * FROM users WHERE id = ?').get(userId);
      }
    }

    req.session.user = {
      id: user.id, username: user.username, email: user.email, role: user.role,
      avatar_url: user.avatar_url, palette: user.palette, theme: user.theme,
      readonly: !!user.readonly,
    };
    res.redirect(next || '/');
  } catch (e) {
    console.error('[auth/google/callback]', e.message);
    delete req.session.oauthState; delete req.session.oauthLink; delete req.session.oauthNext;
    return linking
      ? res.redirect('/account?error=' + encodeURIComponent('Google koppelen mislukt — probeer opnieuw.'))
      : failLogin('failed');
  }
});

// ==================== LOGOUT ====================
router.get('/logout', (req, res) => { req.session.destroy(() => res.redirect('/')); });
router.post('/logout', (req, res) => { req.session.destroy(() => res.redirect('/')); });

export default router;