import { NextRequest, NextResponse } from 'next/server';

const API = process.env.NEXT_PUBLIC_API_URL ?? 'http://127.0.0.1:3000';

/**
 * Catch-all proxy: forwards ALL requests to the backend API.
 * This avoids CORS preflight issues since requests stay within the
 * same origin (localhost:3004 -> localhost:3004 proxy -> 127.0.0.1:3000 backend).
 *
 * More specific routes (e.g. /api/auth/login) take precedence in Next.js,
 * so they are NOT served by this handler.
 */
export async function GET(req: NextRequest) {
  const path = req.nextUrl.pathname.replace('/api/', '');
  const search = req.nextUrl.search;
  const cookies = req.headers.get('cookie') ?? '';
  try {
    const backendRes = await fetch(`${API}/${path}${search}`, {
      headers: { Cookie: cookies },
    });
    if (path === 'admin/logs/stream') {
      // Pipe SSE directly: Next.js App Router supports ReadableStream passthrough.
      // X-Accel-Buffering: no tells any intermediate proxy (nginx) not to buffer.
      const headers = new Headers();
      headers.set('Content-Type', backendRes.headers.get('content-type') ?? 'text/event-stream');
      headers.set('Cache-Control', 'no-cache, no-store, must-revalidate');
      headers.set('X-Accel-Buffering', 'no');
      // Do NOT set Connection: keep-alive — it is HTTP/1.1 default for persistent
      // connections and can confuse proxies that do not expect streaming.
      return new Response(backendRes.body, {
        status: backendRes.status,
        headers,
      });
    }
    const data = await backendRes.json().catch(() => null);
    const resp = NextResponse.json(data ?? { error: 'Bad response' }, { status: backendRes.status });
    return resp;
  } catch {
    return NextResponse.json({ error: 'Proxy error' }, { status: 502 });
  }
}

export async function POST(req: NextRequest) {
  const path = req.nextUrl.pathname.replace('/api/', '');
  const search = req.nextUrl.search;
  const cookies = req.headers.get('cookie') ?? '';
  const body = await req.text();
  try {
    const headers: Record<string, string> = { Cookie: cookies };
    if (body) headers['Content-Type'] = 'application/json';
    const backendRes = await fetch(`${API}/${path}${search}`, {
      method: 'POST',
      headers,
      ...(body ? { body } : {}),
    });
    const setCookie = backendRes.headers.get('set-cookie');
    const data = await backendRes.json().catch(() => null);
    const resp = NextResponse.json(data ?? { error: 'Bad response' }, { status: backendRes.status });
    if (setCookie) {
      resp.headers.set(
        'Set-Cookie',
        setCookie.replace(/;\s*Secure/gi, '').replace(/;\s*SameSite=Lax/gi, '').trim(),
      );
    }
    return resp;
  } catch {
    return NextResponse.json({ error: 'Proxy error' }, { status: 502 });
  }
}

export async function PATCH(req: NextRequest) {
  const path = req.nextUrl.pathname.replace('/api/', '');
  const search = req.nextUrl.search;
  const cookies = req.headers.get('cookie') ?? '';
  const body = await req.text();
  try {
    const backendRes = await fetch(`${API}/${path}${search}`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json', Cookie: cookies },
      body,
    });
    const data = await backendRes.json().catch(() => null);
    return NextResponse.json(data ?? { error: 'Bad response' }, { status: backendRes.status });
  } catch {
    return NextResponse.json({ error: 'Proxy error' }, { status: 502 });
  }
}

export async function PUT(req: NextRequest) {
  const path = req.nextUrl.pathname.replace('/api/', '');
  const search = req.nextUrl.search;
  const cookies = req.headers.get('cookie') ?? '';
  const body = await req.text();
  try {
    const backendRes = await fetch(`${API}/${path}${search}`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json', Cookie: cookies },
      body,
    });
    const data = await backendRes.json().catch(() => null);
    return NextResponse.json(data ?? { error: 'Bad response' }, { status: backendRes.status });
  } catch {
    return NextResponse.json({ error: 'Proxy error' }, { status: 502 });
  }
}

export async function DELETE(req: NextRequest) {
  const path = req.nextUrl.pathname.replace('/api/', '');
  const search = req.nextUrl.search;
  const cookies = req.headers.get('cookie') ?? '';
  try {
    const backendRes = await fetch(`${API}/${path}${search}`, {
      method: 'DELETE',
      headers: { Cookie: cookies },
    });
    // Reenviar la respuesta del backend tal cual: el backend puede devolver
    // 204 No Content (sin body) en borrados exitosos, y forzar un JSON con
    // status 204 es HTTP inválido (F-127).
    return new Response(backendRes.body, {
      status: backendRes.status,
      statusText: backendRes.statusText,
      headers: { 'Content-Length': backendRes.headers.get('content-length') ?? '0' },
    });
  } catch {
    return NextResponse.json({ error: 'Proxy error' }, { status: 502 });
  }
}
