server.js

import express from 'express';
import path from 'path';
import { fileURLToPath } from 'url';
import process from 'node:process';
import cors from 'cors';
import { PrismaClient } from '@prisma/client';
import * as jose from 'jose';
import bcrypt from 'bcryptjs';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const prisma = new PrismaClient();
const PORT = process.env.PORT || 8080;
const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET || 'gemini-cms-secret-key-2025');

app.use(cors());
app.use(express.json({ limit: '50mb' }));

// --- MIDDLEWARES ---
const authMiddleware = async (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader) return res.status(401).json({ error: 'Token não fornecido' });
  const token = authHeader.split(' ')[1];
  try {
    const { payload } = await jose.jwtVerify(token, JWT_SECRET);
    req.user = payload;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Sessão expirada' });
  }
};

// --- SERVICES ---
const ArticleService = {
  async getAll() {
    return prisma.article.findMany({
      include: { author: { select: { name: true, avatarUrl: true, slug: true } }, category: true },
      orderBy: { createdAt: 'desc' }
    });
  },
  async getByIdentifier(idOrSlug) {
    const isUuid = idOrSlug.length === 36 || idOrSlug.includes('-');
    return prisma.article.findFirst({
      where: {
        OR: [
          { id: isUuid ? idOrSlug : undefined },
          { slug: idOrSlug },
          { exposedId: idOrSlug }
        ].filter(Boolean)
      },
      include: { author: true, category: true }
    });
  }
};

// --- CONTROLLERS ---
const DashboardController = {
  async init(req, res) {
    try {
      const [articlesCount, authors, activities, votes] = await Promise.all([
        prisma.article.count(),
        prisma.author.findMany({ select: { id: true, name: true, avatarUrl: true } }),
        prisma.activity.findMany({
          include: { author: { select: { name: true, avatarUrl: true } } },
          orderBy: { createdAt: 'desc' },
          take: 10
        }),
        prisma.vote.findMany({ where: { userId: req.user.id } })
      ]);

      res.json({
        stats: { articles: articlesCount, authors: authors.length },
        authors,
        activities,
        starredIds: votes.map(v => v.articleId)
      });
    } catch (e) {
      res.status(500).json({ error: e.message });
    }
  }
};

// --- ROUTES ---
app.post('/api/auth/login', async (req, res) => {
  const { email, pass } = req.body;
  const user = await prisma.user.findUnique({ where: { email }, include: { author: true } });
  if (!user || !(await bcrypt.compare(pass, user.password))) return res.status(401).json({ error: 'Credenciais inválidas' });
  const token = await new jose.SignJWT({ id: user.id, authorId: user.author?.id, role: user.role })
    .setProtectedHeader({ alg: 'HS256' }).setExpirationTime('24h').sign(JWT_SECRET);
  const { password, ...safeUser } = user;
  res.json({ user: safeUser, token });
});

app.get('/api/feed/init', authMiddleware, async (req, res) => {
  const [articles, categories, votes] = await Promise.all([
    ArticleService.getAll(),
    prisma.category.findMany(),
    prisma.vote.findMany({ where: { userId: req.user.id } })
  ]);
  res.json({ articles, categories, starredIds: votes.map(v => v.articleId) });
});

app.get('/api/dashboard/init', authMiddleware, DashboardController.init);

// ROTA DE DETALHE CONSOLIDADO (Corrige o erro do frontend)
app.get('/api/articles/detail/:id/:userId', authMiddleware, async (req, res) => {
  try {
    const { id, userId } = req.params;
    const art = await ArticleService.getByIdentifier(id);
    
    if (!art) return res.status(404).json({ error: 'Matéria não encontrada' });

    const authorIds = art.authorIds || (art.authorId ? [art.authorId] : []);
    const [authors, votes] = await Promise.all([
      prisma.author.findMany({ where: { id: { in: authorIds } } }),
      prisma.vote.findMany({ where: { articleId: art.id } })
    ]);

    res.json({
      article: art,
      authors,
      voteCount: votes.length,
      hasVoted: votes.some(v => v.userId === userId)
    });
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// ROTA PARA "LEIA MAIS"
app.get('/api/articles/published', authMiddleware, async (req, res) => {
  try {
    const articles = await prisma.article.findMany({
      where: { status: 'PUBLISHED' },
      take: 10,
      orderBy: { createdAt: 'desc' },
      include: { author: { select: { name: true } } }
    });
    res.json(articles);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

app.get('/api/articles/:identifier', authMiddleware, async (req, res) => {
  const art = await ArticleService.getByIdentifier(req.params.identifier);
  art ? res.json(art) : res.status(404).json({ error: 'Matéria não encontrada' });
});

app.get('/api/categories', authMiddleware, async (req, res) => res.json(await prisma.category.findMany()));

app.patch('/api/articles/:id', authMiddleware, async (req, res) => {
  const updated = await prisma.article.update({ where: { id: req.params.id }, data: req.body });
  res.json(updated);
});

app.use(express.static(path.join(__dirname, 'dist')));
app.get('*', (req, res) => res.sendFile(path.join(__dirname, 'dist', 'index.html')));

app.listen(PORT, () => console.log(`🚀 Redação Operacional em http://localhost:${PORT}`));