import { NextResponse } from 'next/server';
import { execute } from '@/lib/db';
import crypto from 'crypto';

let schemaReady = false;

async function ensureSchema() {
  if (schemaReady) return;
  await execute(`
    CREATE TABLE IF NOT EXISTS analytics_events (
      id          INTEGER PRIMARY KEY AUTOINCREMENT,
      event_type  TEXT NOT NULL,
      page_url    TEXT,
      visitor_id  TEXT NOT NULL,
      session_id  TEXT NOT NULL,
      timestamp   DATETIME DEFAULT CURRENT_TIMESTAMP,
      metadata    TEXT
    )
  `).catch(() => {});
  await execute(`CREATE INDEX IF NOT EXISTS idx_analytics_event_type ON analytics_events(event_type)`).catch(() => {});
  await execute(`CREATE INDEX IF NOT EXISTS idx_analytics_visitor_id ON analytics_events(visitor_id)`).catch(() => {});
  await execute(`CREATE INDEX IF NOT EXISTS idx_analytics_session_id ON analytics_events(session_id)`).catch(() => {});
  await execute(`CREATE INDEX IF NOT EXISTS idx_analytics_timestamp ON analytics_events(timestamp)`).catch(() => {});
  schemaReady = true;
}

/**
 * POST /api/analytics/track
 *
 * Accepts analytics events from the client-side tracker.
 * Supports both the new analytics_events format and the legacy UserAction format.
 *
 * Body (new format):
 *   { event_type, page_url, visitor_id, session_id, metadata }
 *
 * Body (legacy format):
 *   { actionType, entityType, entityId, metadata, visitorId }
 */
export async function POST(request: Request) {
  try {
    await ensureSchema();

    const body = await request.json();

    // Detect format: new analytics_events format vs legacy UserAction format
    if (body.event_type) {
      // New analytics_events format
      const { event_type, page_url, visitor_id, session_id, metadata } = body;

      if (!event_type || !visitor_id || !session_id) {
        return NextResponse.json({ error: 'event_type, visitor_id, and session_id are required.' }, { status: 400 });
      }

      await execute(
        `INSERT INTO analytics_events (event_type, page_url, visitor_id, session_id, metadata)
         VALUES (?, ?, ?, ?, ?)`,
        [
          event_type,
          page_url || null,
          visitor_id,
          session_id,
          metadata || null,
        ]
      );

      return NextResponse.json({ success: true });
    } else {
      // Legacy UserAction format — maintain backward compatibility
      const { actionType, entityType, entityId, metadata, visitorId } = body;

      await execute(
        `INSERT INTO UserAction (id, userId, visitorId, actionType, entityType, entityId, metadata, createdAt)
         VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
        [
          crypto.randomUUID(),
          null, // userId — not provided in legacy format
          visitorId || null,
          actionType || null,
          entityType || null,
          entityId || null,
          metadata ? JSON.stringify(metadata) : null,
        ]
      );

      return NextResponse.json({ success: true });
    }
  } catch (error: any) {
    console.error('[analytics/track] POST error:', error?.message ?? error);
    return NextResponse.json({ error: error?.message ?? 'Failed to track event.' }, { status: 500 });
  }
}