import { Request, Response } from 'express';
import { env } from '../../config/env';
import { UnauthorizedError } from '../../lib/errors';
import { verifyRefreshToken } from '../../lib/jwt';
import {
  signupSchema,
  loginSchema,
  updateProfileSchema,
  changePasswordSchema,
  otpVerifySchema,
  otpResendSchema,
  profileOtpResendSchema,
  totpLoginSchema,
  loginEmailCodeSchema,
  totpCodeSchema,
  totpEnableSchema,
} from './auth.schemas';
import * as twoFactor from './two-factor.service';
import * as authService from './auth.service';
import { noteSignIn } from '../crm/crm-mail';

const REFRESH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7d, matches JWT_REFRESH_EXPIRES_IN default

export function setRefreshCookie(res: Response, token: string): void {
  res.cookie(env.REFRESH_COOKIE_NAME, token, {
    httpOnly: true,
    secure: env.NODE_ENV === 'production' || env.NODE_ENV === 'staging',
    sameSite: 'lax',
    path: '/api/auth',
    maxAge: REFRESH_MAX_AGE_MS,
  });
}

export async function signupStatus(_req: Request, res: Response): Promise<void> {
  res.json({ available: await authService.isSignupAvailable() });
}

export async function signup(req: Request, res: Response): Promise<void> {
  const input = signupSchema.parse(req.body);
  const { user, accessToken, refreshToken } = await authService.signupSuperAdmin(input);
  setRefreshCookie(res, refreshToken);
  res.status(201).json({ user, accessToken });
}

export async function login(req: Request, res: Response): Promise<void> {
  const input = loginSchema.parse(req.body);
  const result = await authService.login(input);
  if ('twoFactorRequired' in result) {
    // No session yet — no token, no cookie. The client asks for the code.
    res.json(result);
    return;
  }
  const { user, accessToken, refreshToken } = result;
  setRefreshCookie(res, refreshToken);
  res.json({ user, accessToken });
}

/** Second sign-in step. Answers exactly like a password-only login. */
export async function verifyLogin(req: Request, res: Response): Promise<void> {
  const { challengeId, code } = otpVerifySchema.parse(req.body);
  const { user, accessToken, refreshToken } = await authService.verifyLoginOtp(challengeId, code);
  setRefreshCookie(res, refreshToken);
  res.json({ user, accessToken });
  // A CRM user signing in from a browser they have not used before is told so.
  if (user.role === 'CRM_USER') void noteSignIn(user.id, req.header('user-agent'), req.ip);
}

/** Second step with the authenticator app (or a recovery code). */
export async function verifyLoginTotp(req: Request, res: Response): Promise<void> {
  const { challengeId, code } = totpLoginSchema.parse(req.body);
  const { user, accessToken, refreshToken, usedRecoveryCode, recoveryCodesLeft } = await authService.verifyLoginWithTotp(challengeId, code);
  setRefreshCookie(res, refreshToken);
  res.json({ user, accessToken, ...(usedRecoveryCode ? { usedRecoveryCode, recoveryCodesLeft } : {}) });
  if (user.role === 'CRM_USER') void noteSignIn(user.id, req.header('user-agent'), req.ip);
}

/** "Email me a code instead" on a sign-in that started with the authenticator app. */
export async function loginEmailCode(req: Request, res: Response): Promise<void> {
  const { challengeId } = loginEmailCodeSchema.parse(req.body);
  res.json(await twoFactor.emailLoginCode(challengeId));
}

// ── Authenticator app on the signed-in user's own profile ─────────────────

export async function totpSetup(req: Request, res: Response): Promise<void> {
  res.json(await twoFactor.totpSetup(req.user!.sub));
}

export async function totpEnable(req: Request, res: Response): Promise<void> {
  const { code } = totpEnableSchema.parse(req.body);
  const r = await twoFactor.totpEnable(req.user!.sub, code);
  res.json({ ...r, user: await authService.getMe(req.user!.sub) });
}

export async function totpDisable(req: Request, res: Response): Promise<void> {
  const { code } = totpCodeSchema.parse(req.body);
  await twoFactor.totpDisable(req.user!.sub, code);
  res.json({ user: await authService.getMe(req.user!.sub) });
}

export async function totpRecoveryCodes(req: Request, res: Response): Promise<void> {
  const { code } = totpCodeSchema.parse(req.body);
  res.json(await twoFactor.totpNewRecoveryCodes(req.user!.sub, code));
}

export async function totpStatus(req: Request, res: Response): Promise<void> {
  res.json({ recoveryCodesLeft: await twoFactor.recoveryCodesLeft(req.user!.sub) });
}

export async function resendLogin(req: Request, res: Response): Promise<void> {
  const { challengeId } = otpResendSchema.parse(req.body);
  res.json(await authService.resendLoginOtp(challengeId));
}

// ── Two-step verification on the signed-in user's own profile ────────────

export async function twoFactorEnableStart(req: Request, res: Response): Promise<void> {
  res.json(await twoFactor.startEnable(req.user!.sub));
}

export async function twoFactorEnableConfirm(req: Request, res: Response): Promise<void> {
  const { challengeId, code } = otpVerifySchema.parse(req.body);
  await twoFactor.confirmEnable(req.user!.sub, challengeId, code);
  res.json({ user: await authService.getMe(req.user!.sub) });
}

export async function twoFactorDisableStart(req: Request, res: Response): Promise<void> {
  res.json(await twoFactor.startDisable(req.user!.sub));
}

export async function twoFactorDisableConfirm(req: Request, res: Response): Promise<void> {
  const { challengeId, code } = otpVerifySchema.parse(req.body);
  await twoFactor.confirmDisable(req.user!.sub, challengeId, code);
  res.json({ user: await authService.getMe(req.user!.sub) });
}

export async function twoFactorResend(req: Request, res: Response): Promise<void> {
  const { challengeId, purpose } = profileOtpResendSchema.parse(req.body);
  res.json(await twoFactor.resendOtp(challengeId, twoFactor.profilePurpose(purpose), req.user!.sub));
}

export async function refresh(req: Request, res: Response): Promise<void> {
  const token = req.cookies?.[env.REFRESH_COOKIE_NAME];
  if (!token) throw new UnauthorizedError('No refresh token');
  const { sub, iat } = verifyRefreshToken(token);
  const { user, accessToken } = await authService.refresh(sub, iat);
  res.json({ user, accessToken });
}

export async function logout(_req: Request, res: Response): Promise<void> {
  res.clearCookie(env.REFRESH_COOKIE_NAME, { path: '/api/auth' });
  res.status(204).send();
}

export async function me(req: Request, res: Response): Promise<void> {
  const user = await authService.getMe(req.user!.sub);
  res.json({ user });
}

export async function updateProfile(req: Request, res: Response): Promise<void> {
  const input = updateProfileSchema.parse(req.body);
  res.json({ user: await authService.updateProfile(req.user!.sub, input) });
}

export async function changePassword(req: Request, res: Response): Promise<void> {
  const input = changePasswordSchema.parse(req.body);
  await authService.changePassword(req.user!.sub, input);
  // This browser's refresh token predates the change, so drop it and make the
  // user sign in again with the new password.
  res.clearCookie(env.REFRESH_COOKIE_NAME, { path: '/api/auth' });
  res.status(204).send();
}
