db.js

//pedidos tem tempo para expirar
require('dotenv').config();
const connection = process.env.CONNECTION_STRING; 

const mysql = require('mysql2/promise');
const client = mysql.createPool(connection);


/* FUNCOES DE PEDIDOS DE ACESSO */

async function tratarPedido(resposta, usuario_id) {
  const [result] = await client.query(
    "UPDATE pedidos_acesso SET status = ? WHERE usuario_id = ?",
    [resposta, usuario_id]
  );
  return result;
}

async function pedidoAcesso(condominioId) {
  const [result] = await client.query(
    "SELECT * FROM pedidos_acesso WHERE condominio_id = ?",
    [condominioId]
  );

  // Se não houver pedidos, retorna lista vazia
  if (!result.length) return [];

  // Para cada pedido, busca o usuário correspondente
  const pedidosComUsuarios = await Promise.all(
    result.map(async (pedido) => {
      const user = await getUser(pedido.usuario_id);
      return { ...pedido, user };
    })
  );

  return pedidosComUsuarios;
}


/* FUNCOES DE REGISTROS  */

async function registrosDetalhados(condominioId, ano, mes) {
  try {
    const [result] = await client.query(`
      SELECT 
        id, 
        descricao, 
        tipo, 
        valor, 
        DAY(data) AS dia, 
        data, 
        criado_em, 
        atualizado_em
      FROM prestacoes
      WHERE condominio_id = ? 
        AND YEAR(data) = ? 
        AND MONTH(data) = ?
      ORDER BY data ASC
    `, [condominioId, parseInt(ano), parseInt(mes)]);

    return result;
  } catch (err) {
    console.error("Erro ao buscar registros detalhados:", err);
    throw err;
  }
}


async function registros(condominioId) {
  try {
    const [result] = await client.query(`
      SELECT 
        YEAR(data) AS ano,
        MONTH(data) AS numero_mes,
        MONTHNAME(data) AS mes,
        SUM(CASE WHEN tipo = 'receita' THEN valor ELSE 0 END) AS receitas,
        SUM(CASE WHEN tipo = 'despesa' THEN valor ELSE 0 END) AS despesas
      FROM prestacoes
      WHERE condominio_id = ?
      GROUP BY ano, numero_mes, mes
      ORDER BY ano DESC, numero_mes DESC
    `, [condominioId]);

    return result;
  } catch (err) {
    console.error("Erro ao buscar registros:", err);
    throw err;
  }
}


/*FUNCOES DE PRESTACOES */

async function editarPrestacoes({ id, tipo, descricao, valor, data, userId, condominioId }) {
    try {
        const [result] = await client.query(
            `UPDATE prestacoes 
             SET tipo = ?, descricao = ?, valor = ?, data = ? 
             WHERE id = ? AND usuario_id = ? AND condominio_id = ?`,
            [tipo, descricao, valor, data, id, userId, condominioId]
        );

        return {
            message: "Prestação atualizada com sucesso!",
            affectedRows: result.affectedRows
        };
    } catch (err) {
        console.error("Erro ao atualizar prestação:", err);
        return { message: "Erro ao atualizar prestação", error: err };
    }
}


async function criarPrestacao({ tipo, descricao, valor, data, userId, condominioId }){
    try {
        const [result] = await client.query(
            'INSERT INTO prestacoes(tipo, descricao, valor, data, usuario_id, condominio_id) VALUES(?, ?, ?, ?, ?, ?)',
            [tipo, descricao, valor, data, userId, condominioId]
        );

        return { message: "Prestação registrada com sucesso!" , status: 201};
    } catch (err) {
        console.error("Erro ao registrar prestação:", err);

        switch (err.code) {
            case 'ER_BAD_FIELD_ERROR':
            return ({ message: "Erro de campo inválido na tabela.", status: 400 });
            case 'ER_BAD_NULL_ERROR':
            return ({ message: "Campo obrigatório não preenchido.", status: 400 });
            case 'ER_NO_REFERENCED_ROW_2':
            return ({ message: "Usuário ou condomínio inexistente.", status: 400 });
            case 'ER_DUP_ENTRY':
            return ({ message: "Registro duplicado.", status: 400 });
            case 'ECONNREFUSED':
            return ({ message: "Falha ao conectar ao banco de dados.", status: 503 });
            default:
            return ({ message: "Erro interno no servidor.", status: 500 });
        }
    }
}

/* FUNCOES DE GET */

async function getCondominioByCode(codigo) {
  const [rows] = await client.query(
    'SELECT * FROM condominios WHERE codigo_acesso = ?',
    [codigo]
  );

  if (rows.length === 0) {
    throw new Error("Código de condomínio inválido");
  }
  
  return {
    id: rows[0].id,
    nome: rows[0].nome,
    codigo: rows[0].codigo_acesso,
  };
}

async function getCondominio(id){
    const [ rows ] = await client.query('SELECT * FROM condominios WHERE id = ?', [id])
    const condominio = {
        id: rows[0].id,
        nome: rows[0].nome,
        codigo: rows[0].codigo_acesso
    }
    return condominio
}

async function getUser(id){
    const [ rows ] = await client.query('SELECT * FROM usuarios WHERE id = ?', [id])
    const user = {
        usuario_id: rows[0].usuario_id,
        nome: rows[0].nome,
        email: rows[0].email,
        status:rows[0].status
    }
    return user;
}

async function getUserStatus(email){    
    const user = await getUserByEmail(email)
    return user.status;
}

async function getUserByEmail(email){
  try{
    const [ rows ] = await client.query('SELECT * FROM usuarios WHERE email = ?', [email]);
    return rows[0];
  } catch(err){
    console.error("Erro ao buscar usuário:", err);
    throw err;
  }

}

/* FUNÇÕES DE CADASTRO DE USUARIOS */
function gerarCodigo(tamanho = 6) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    let codigo = '';
    for (let i = 0; i < tamanho; i++) {
        codigo += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return codigo;
}

async function criarPedidosAcesso(userId, codigoAcesso){
    try{
        //pega o codigo de acesso e busca no banco para pegar o id
        const [rows] = await client.query('SELECT id FROM condominios WHERE codigo_acesso = ?', [codigoAcesso]);
        
        if (rows.length === 0) { //se nao existir o codigo
            throw new Error('Código de condomínio inválido');
        }

        const condominioId = rows[0].id;

        const [result] = await client.query('INSERT INTO pedidos_acesso(usuario_id, condominio_id) VALUES (?, ?)', [userId, condominioId]);

        return { message: "o pedido de entrada foi solicitado ao síndico! aguarde.", type: 'success'};
    } catch(err){
        return{ message: `${err}`, type: 'error' };   
    }
}

async function cadastrarCondominio(nome, endereco, codigo){
    try {
        const [result] = await client.query(`INSERT INTO condominios(nome, endereco, codigo_acesso) VALUES (?, ?, ?)`, [nome, endereco, codigo])

        if (result && result.insertId) {
            return { id: result.insertId };
        } else {
            return null;
        }

    } catch(err) {
        console.error('erro ao cadastrar condominio:', err)
        throw err;
    }
}

async function cadastrarUsuario(user) {
  let codigoAcesso = null;
  let cadastroCond = null;

  try {
    const usuarioExiste = await getUserByEmail(user.email);
    if (usuarioExiste)
      return { message: "Usuário já existe", type: "error" };

    // caso 1: síndico cria condomínio
    if (user.tipo === 'sindico') {
      codigoAcesso = gerarCodigo(6);
      cadastroCond = await cadastrarCondominio(
        user.nomeCondominio,
        user.enderecoCondominio,
        codigoAcesso
      );
      user.status = cadastroCond ? 'ativo' : 'pendente';
    }

    // caso 2: morador tenta se cadastrar
    else {
      // valida código informado
      const condominio = await getCondominioByCode(user.codigoAcesso);
      if (!condominio) throw new Error("Código de condomínio inválido");

      user.status = 'pendente'; // aguardando aprovação
    }

    // o condominio_id só é preenchido se for síndico
    const [result] = await client.query(
      `INSERT INTO usuarios(nome, email, senha, tipo, condominio_id, status)
       VALUES (?, ?, ?, ?, ?, ?)`,
      [
        user.nome,
        user.email,
        user.senha,
        user.tipo,
        cadastroCond ? cadastroCond.id : null,
        user.status,
      ]
    );

    const userId = result.insertId;

    // se for morador, cria pedido de acesso
    if (user.tipo !== 'sindico') {
      const criarPedido = await criarPedidosAcesso(userId, user.codigoAcesso);
      return criarPedido;
    }

    return {
      message: "Condomínio criado com sucesso!",
      type: "success",
      codigoAcesso,
    };
  } catch (err) {
    return { message: err.message, type: "error" };
  }
}


module.exports = {cadastrarUsuario, getUserByEmail, getUserStatus, getUser, criarPrestacao, editarPrestacoes, registros, registrosDetalhados, pedidoAcesso, tratarPedido, getCondominio};