// @WHO:   vps-deploy/api/kds/src/routes/auth.ts
// @WHAT:  Auth routes — login and register for Kedai Ayam Warisan 81
// @PART:  auth
// @ENTRY: authRouter

import { Router } from 'express';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import { z } from 'zod';
import { prisma } from '../lib/prisma';

export const authRouter = Router();

const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret';
const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '7d';

// ── Schemas ──

const loginSchema = z.object({
  email: z.string().email('Email tidak valid'),
  password: z.string().min(6, 'Password minimal 6 karakter'),
});

const registerSchema = z.object({
  name: z.string().min(2, 'Nama minimal 2 karakter'),
  email: z.string().email('Email tidak valid'),
  phone: z.string().optional(),
  password: z.string().min(6, 'Password minimal 6 karakter'),
});

// @FLOW:     AUTH_LOGIN
// @CALLS:    DB:users SELECT, bcrypt compare, JWT sign
// @MUTATES:  none
authRouter.post('/login', async (req, res) => {
  try {
    const parsed = loginSchema.safeParse(req.body);
    if (!parsed.success) {
      return res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
    }

    const { email, password } = parsed.data;

    const user = await prisma.user.findUnique({
      where: { email },
      include: { outlets: { include: { outlet: true } } },
    });

    if (!user || !user.isActive) {
      return res.status(401).json({ error: 'Email atau password salah' });
    }

    const validPassword = await bcrypt.compare(password, user.password);
    if (!validPassword) {
      return res.status(401).json({ error: 'Email atau password salah' });
    }

    const token = jwt.sign(
      {
        userId: user.id,
        email: user.email,
        name: user.name,
        role: user.role,
        outlets: user.outlets.map((uo) => ({
          outletId: uo.outletId,
          slug: uo.outlet.slug,
          role: uo.role,
        })),
      },
      JWT_SECRET,
      { expiresIn: JWT_EXPIRES_IN }
    );

    res.json({
      token,
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
        phone: user.phone,
        role: user.role,
        outlets: user.outlets.map((uo) => ({
          outletId: uo.outletId,
          name: uo.outlet.name,
          slug: uo.outlet.slug,
          role: uo.role,
        })),
      },
    });
  } catch (err: any) {
    console.error('[AUTH_LOGIN]', err);
    res.status(500).json({ error: 'Login gagal', message: err.message });
  }
});

// @FLOW:     AUTH_REGISTER
// @CALLS:    DB:users INSERT, bcrypt hash, JWT sign
// @MUTATES:  DB:users (INSERT new customer)
authRouter.post('/register', async (req, res) => {
  try {
    const parsed = registerSchema.safeParse(req.body);
    if (!parsed.success) {
      return res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
    }

    const { name, email, phone, password } = parsed.data;

    // Check if email already exists
    const existingUser = await prisma.user.findUnique({ where: { email } });
    if (existingUser) {
      return res.status(409).json({ error: 'Email sudah terdaftar' });
    }

    const hashedPassword = await bcrypt.hash(password, 10);

    const user = await prisma.user.create({
      data: {
        email,
        name,
        phone,
        password: hashedPassword,
        role: 'CUSTOMER',
      },
    });

    const token = jwt.sign(
      {
        userId: user.id,
        email: user.email,
        name: user.name,
        role: user.role,
        outlets: [],
      },
      JWT_SECRET,
      { expiresIn: JWT_EXPIRES_IN }
    );

    res.status(201).json({
      token,
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
        phone: user.phone,
        role: user.role,
        outlets: [],
      },
    });
  } catch (err: any) {
    console.error('[AUTH_REGISTER]', err);
    res.status(500).json({ error: 'Registrasi gagal', message: err.message });
  }
});