route.ts

import { NextRequest, NextResponse } from 'next/server';
import { Keypair, StrKey } from '@stellar/stellar-sdk';
import { getAndClearNonce } from '@/lib/auth-cache';
import { createSession, getSessionCookieHeader } from '@/lib/session';
import { prisma } from '@/lib/prisma';
import { auditLog, createAuditEvent, extractIp, AuditAction } from '@/lib/audit';

// Force dynamic rendering for this route
export const dynamic = 'force-dynamic';
export const runtime = 'nodejs';

/**
 * POST /api/auth/login
 * Verify a signature and authenticate user
 */
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const { address, message, signature } = body;

    if (!address || !message || !signature) {
      return NextResponse.json(
        { error: 'Missing required fields: address, message, signature' },
        { status: 400 }
      );
    }

    // Validate Stellar address format
    if (!StrKey.isValidEd25519PublicKey(address)) {
      return NextResponse.json(
        { error: 'Invalid Stellar address format' },
        { status: 400 }
      );
    }

    // Verify nonce exists and matches (atomic read + delete)
    const storedNonce = getAndClearNonce(address);
    if (!storedNonce || storedNonce !== message) {
      // Log failed login attempt
      await auditLog(
        createAuditEvent(AuditAction.LOGIN_FAIL, 'failure', {
          address,
          ip: extractIp(request),
          error: 'Invalid or expired nonce',
        })
      );
      
      return NextResponse.json(
        { error: 'Invalid or expired nonce' },
        { status: 401 }
      );
    }

    // Verify signature
    // The client signs Buffer.from(nonce, 'utf8') so we must decode the same way
    const keypair = Keypair.fromPublicKey(address);
    const messageBuffer = Buffer.from(message, 'utf8');
    const signatureBuffer = Buffer.from(signature, 'base64');

    const isValid = keypair.verify(messageBuffer, signatureBuffer);

    if (!isValid) {
      // Log failed login attempt
      await auditLog(
        createAuditEvent(AuditAction.LOGIN_FAIL, 'failure', {
          address,
          ip: extractIp(request),
          error: 'Invalid signature',
        })
      );
      
      return NextResponse.json(
        { error: 'Invalid signature' },
        { status: 401 }
      );
    }

    // Upsert user in database (best-effort — don't fail login if DB is unavailable)
    try {
      await prisma.user.upsert({
        where: { stellar_address: address },
        update: {},
        create: {
          stellar_address: address,
          preferences: {
            create: {},
          },
        },
      });
    } catch (dbErr) {
      console.warn('DB upsert skipped (non-fatal):', dbErr);
    }

    // Create encrypted session
    const sealed = await createSession(address);

    const response = NextResponse.json({
      success: true,
      address,
    });

    response.headers.set(
      'Set-Cookie',
      getSessionCookieHeader(sealed)
    );

    // Log successful login
    await auditLog(
      createAuditEvent(AuditAction.LOGIN_SUCCESS, 'success', {
        address,
        ip: extractIp(request),
      })
    );

    return response;

  } catch (error) {
    console.error('Login error:', error);
    
    // Log failed login due to internal error
    const body = await request.clone().json().catch(() => ({}));
    await auditLog(
      createAuditEvent(AuditAction.LOGIN_FAIL, 'failure', {
        address: body.address,
        ip: extractIp(request),
        error: 'Internal server error',
      })
    );
    
    return NextResponse.json(
      { error: 'Internal Server Error' },
      { status: 500 }
    );
  }
}