import type { NextApiRequest, NextApiResponse } from 'next';
import { createConnection } from 'mysql2/promise';
import { ORDER_TRACKING_TOKEN_PATTERN } from '@/lib/orderTracking';

async function createDatabaseConnection() {
  return createConnection({
    host: process.env.DB_HOST,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
  });
}

function getStatusPresentation(statusId: number, statusName: string) {
  const presentations: Record<number, {
    label: string;
    description: string;
    step: number;
    tone: 'pending' | 'active' | 'success' | 'danger';
  }> = {
    1: {
      label: 'Čeká na platbu',
      description: 'Objednávka je vytvořená a čeká na dokončení platby.',
      step: 0,
      tone: 'pending',
    },
    2: {
      label: 'Objednávka přijata',
      description: 'Platbu jsme přijali a objednávku zařadili ke zpracování.',
      step: 1,
      tone: 'active',
    },
    7: {
      label: 'Připravujeme objednávku',
      description: 'Vaši objednávku právě kompletujeme a připravujeme k odeslání.',
      step: 2,
      tone: 'active',
    },
    5: {
      label: 'Objednávka odeslána',
      description: 'Zásilka byla předána dopravci a je na cestě k vám.',
      step: 3,
      tone: 'active',
    },
    6: {
      label: 'Objednávka doručena',
      description: 'Zásilka byla označena jako doručená.',
      step: 4,
      tone: 'success',
    },
    3: {
      label: 'Objednávka zrušena',
      description: 'Objednávka nebo její platba byla zrušena.',
      step: 0,
      tone: 'danger',
    },
    4: {
      label: 'Chyba platby',
      description: 'Platbu se nepodařilo dokončit. Pokud potřebujete pomoc, kontaktujte nás.',
      step: 0,
      tone: 'danger',
    },
    8: {
      label: 'Objednávka vrácena',
      description: 'Objednávka byla vrácena zpět.',
      step: 4,
      tone: 'danger',
    },
    9: {
      label: 'Probíhá refundace',
      description: 'U objednávky právě zpracováváme vrácení platby.',
      step: 4,
      tone: 'pending',
    },
  };

  return presentations[statusId] || {
    label: statusName || 'Stav se aktualizuje',
    description: 'Aktuální informace o objednávce se právě aktualizují.',
    step: 0,
    tone: 'pending' as const,
  };
}

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  res.setHeader('Cache-Control', 'private, no-store, max-age=0');
  res.setHeader('X-Robots-Tag', 'noindex, nofollow, noarchive');

  if (req.method !== 'GET') {
    res.setHeader('Allow', 'GET');
    return res.status(405).json({ error: 'Metoda není povolena' });
  }

  const { id, h } = req.query;
  if (
    typeof id !== 'string' ||
    typeof h !== 'string' ||
    id.length < 1 ||
    id.length > 64 ||
    !/^[a-zA-Z0-9_-]+$/.test(id) ||
    !ORDER_TRACKING_TOKEN_PATTERN.test(h)
  ) {
    return res.status(404).json({ error: 'Objednávka nebyla nalezena' });
  }

  let connection: Awaited<ReturnType<typeof createDatabaseConnection>> | null = null;

  try {
    connection = await createDatabaseConnection();

    const [orderRows] = await connection.execute(
      `SELECT o.id, o.order_number, o.status_id, o.total_price, o.currency,
              o.created_at, o.updated_at, os.name AS status_name,
              sh.method_name, sh.tracking_number, sh.shipped_at
       FROM orders o
       JOIN order_statuses os ON os.id = o.status_id
       LEFT JOIN order_shipping sh ON sh.order_id = o.id
       WHERE o.order_number = ? AND o.tracking_token = ?
       LIMIT 1`,
      [id, h.toLowerCase()]
    );

    const orders = orderRows as any[];
    if (orders.length === 0) {
      return res.status(404).json({ error: 'Objednávka nebyla nalezena' });
    }

    const order = orders[0];
    const [itemRows] = await connection.execute(
      `SELECT oi.id, oi.product_id, oi.variant_id, oi.product_name, oi.brand, oi.quantity, oi.unit_price,
              oi.total_price, pv.volume_ml,
              (SELECT pi.url
               FROM product_images pi
               WHERE pi.product_id = oi.product_id AND pi.is_primary = 1
               LIMIT 1) AS image
       FROM order_items oi
       LEFT JOIN product_variants pv ON pv.id = oi.variant_id
       WHERE oi.order_id = ?
       ORDER BY oi.id`,
      [order.id]
    );

    const status = getStatusPresentation(Number(order.status_id), order.status_name);

    return res.status(200).json({
      order: {
        orderNumber: order.order_number,
        createdAt: order.created_at,
        updatedAt: order.updated_at,
        total: Number(order.total_price),
        currency: order.currency || 'CZK',
        status: {
          id: Number(order.status_id),
          adminName: order.status_name,
          ...status,
        },
        shipping: {
          method: order.method_name || null,
          trackingNumber: order.tracking_number || null,
          shippedAt: order.shipped_at || null,
        },
        items: (itemRows as any[]).map((item) => ({
          id: item.id,
          productId: item.product_id ? Number(item.product_id) : null,
          variantId: item.variant_id ? Number(item.variant_id) : null,
          name: item.product_name,
          brand: item.brand || '',
          quantity: Number(item.quantity),
          unitPrice: Number(item.unit_price),
          totalPrice: Number(item.total_price),
          volume: item.volume_ml ? `${item.volume_ml} ml` : null,
          image: item.image || null,
        })),
      },
    });
  } catch (error) {
    return res.status(500).json({ error: 'Stav objednávky se nepodařilo načíst' });
  } finally {
    if (connection) await connection.end();
  }
}