import { Request, Response } from 'express';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import User from '../models/User.js';
import { v4 as uuidv4 } from 'uuid';

const JWT_SECRET = process.env.JWT_SECRET || 'fallback_secret_key_change_in_prod';

export const register = async (req: Request, res: Response): Promise<void> => {
    try {
        const { name, email, password } = req.body;

        if (!name || !email || !password) {
            res.status(400).json({ error: 'Todos os campos são obrigatórios' });
            return;
        }

        const existingUser = await User.findOne({ email });
        if (existingUser) {
            res.status(400).json({ error: 'Email já cadastrado' });
            return;
        }

        const salt = await bcrypt.genSalt(10);
        const passwordHash = await bcrypt.hash(password, salt);

        // Gere um externalId falso apenas para manter retrocompatibilidade no banco
        const fakeAuthId = `user_${uuidv4().replace(/-/g, '')}`;

        const newUser = new User({
            name,
            email,
            passwordHash,
            externalId: fakeAuthId,
            role: 'member',
            isBanned: false
        });

        await newUser.save();

        const token = jwt.sign(
            { userId: newUser._id.toString(), externalId: newUser.externalId, role: newUser.role, organizationId: newUser.organizationId },
            JWT_SECRET,
            { expiresIn: '7d' }
        );

        res.status(201).json({
            message: 'Usuário criado com sucesso',
            token,
            user: { id: newUser._id, name: newUser.name, email: newUser.email, role: newUser.role, externalId: newUser.externalId }
        });
    } catch (error) {
        console.error('Register Error:', error);
        res.status(500).json({ error: 'Erro no servidor' });
    }
};

export const login = async (req: Request, res: Response): Promise<void> => {
    try {
        const { email, password } = req.body;

        if (!email || !password) {
            res.status(400).json({ error: 'Email e senha são obrigatórios' });
            return;
        }

        const user = await User.findOne({ email });
        if (!user) {
            res.status(400).json({ error: 'Usuário não encontrado' });
            return;
        }

        if (!user.passwordHash) {
            res.status(400).json({ error: 'Usuário do sistema antigo. Por favor, solicite a redefinição de senha ou recrie sua conta se possível.' });
            return;
        }

        const isMatch = await bcrypt.compare(password, user.passwordHash);
        if (!isMatch) {
            res.status(400).json({ error: 'Credenciais inválidas' });
            return;
        }

        const token = jwt.sign(
            { userId: user._id.toString(), externalId: user.externalId, role: user.role, organizationId: user.organizationId },
            JWT_SECRET,
            { expiresIn: '7d' }
        );

        res.status(200).json({
            message: 'Login realizado com sucesso',
            token,
            user: { id: user._id, name: user.name, email: user.email, role: user.role, externalId: user.externalId }
        });
    } catch (error) {
        console.error('Login Error:', error);
        res.status(500).json({ error: 'Erro no servidor' });
    }
};
