import { NextResponse } from "next/server";
import { canCompany, getCompanyContext } from "@/lib/company-context";
import { createAdminClient, createClient } from "@/lib/supabase-server";

export const runtime = "nodejs";
export const dynamic = "force-dynamic";
export const revalidate = 0;

async function resolveStorageUrl(admin: ReturnType<typeof createAdminClient>, rawValue: string | null | undefined) {
  const value = String(rawValue || "").trim();
  if (!value) return null;
  if (value.startsWith("data:")) return value;

  const parseStorageTarget = (input: string): { bucket: string; path: string } | null => {
    const normalized = input.replace(/^\/+/, "");

    if (/^https?:\/\//i.test(input)) {
      try {
        const parsed = new URL(input);
        const publicMarker = "/storage/v1/object/public/";
        const signMarker = "/storage/v1/object/sign/";
        const marker = parsed.pathname.includes(signMarker) ? signMarker : publicMarker;
        if (!parsed.pathname.includes(marker)) return null;
        const rest = parsed.pathname.slice(parsed.pathname.indexOf(marker) + marker.length);
        const [bucket, ...parts] = rest.split("/");
        return bucket && parts.length ? { bucket, path: parts.join("/") } : null;
      } catch {
        return null;
      }
    }

    const clean = normalized
      .replace(/^storage\/v1\/object\/public\//, "")
      .replace(/^storage\/v1\/object\/sign\//, "");
    const [bucket, ...parts] = clean.split("/");
    return bucket && parts.length ? { bucket, path: parts.join("/") } : null;
  };

  const target = parseStorageTarget(value);
  if (!target) return value;

  const { data: signedData, error: signedError } = await admin.storage
    .from(target.bucket)
    .createSignedUrl(target.path, 60 * 60 * 24 * 30);

  if (!signedError && signedData?.signedUrl) return signedData.signedUrl;

  const { data: publicData } = admin.storage.from(target.bucket).getPublicUrl(target.path);
  return publicData?.publicUrl || value;
}

type RawOrder = {
  id: string;
  number: number | null;
  user_id: string;
  status: "pending" | "approved" | "canceled" | null;
  /* order (pedido, como sempre) ou quote_request (pedido de orçamento feito
     pela loja: os preços gravados são os do cadastro, o cliente não os viu). */
  kind: string | null;
  customer_name: string | null;
  customer_whatsapp: string | null;
  total: number | null;
  approved_order_id: string | null;
  created_at: string | null;
  client_id: string | null;
  notes: string | null;
  payment_status: string | null;
  payment_method: string | null;
  payment_reference: string | null;
  paid_at: string | null;
  clients:
    | {
        id: string;
        name: string | null;
        company_name: string | null;
        avatar_url: string | null;
      }
    | {
        id: string;
        name: string | null;
        company_name: string | null;
        avatar_url: string | null;
      }[]
    | null;
  catalog_order_items:
    | {
        id: string;
        title: string | null;
        quantity: number | null;
        total_price: number | null;
      }[]
    | null;
};

export async function GET(req: Request) {
  const supabase = await createClient();
  const {
    data: { user },
  } = await supabase.auth.getUser();

  if (!user) {
    return NextResponse.json({ error: "Não autenticado." }, { status: 401 });
  }

  const ctx = await getCompanyContext(supabase, user);
  if (!canCompany(ctx, user.id, "catalog.read")) {
    return NextResponse.json({ error: "Sem permissão para visualizar pedidos do catálogo." }, { status: 403 });
  }

  try {
    const admin = createAdminClient();
    const { searchParams } = new URL(req.url);
    const orderId = String(searchParams.get("orderId") || "").trim();
    const statusParam = String(searchParams.get("status") || "").trim();
    const limitParam = Number(searchParams.get("limit") || 0);
    const safeLimit = Number.isFinite(limitParam) && limitParam > 0 ? Math.min(limitParam, 50) : null;
    const tenantIds = (ctx.tenantIds?.length ? ctx.tenantIds : [user.id]).filter(
      (id): id is string => typeof id === "string" && id.length > 0
    );

    let query = admin
      .from("catalog_orders")
      .select(
        "id,number,user_id,status,kind,customer_name,customer_whatsapp,total,approved_order_id,created_at,client_id,notes,payment_status,payment_method,payment_reference,paid_at,clients(id,name,company_name,avatar_url),catalog_order_items(id,title,quantity,total_price)"
      )
      .in("user_id", tenantIds)
      .order("created_at", { ascending: false });

    if (orderId) {
      query = query.eq("id", orderId).limit(1);
    }

    if (statusParam === "pending" || statusParam === "approved" || statusParam === "canceled") {
      query = query.eq("status", statusParam);
    }

    if (safeLimit) {
      query = query.limit(safeLimit);
    }

    const { data, error } = await query;

    if (error) {
      return NextResponse.json({ error: error.message }, { status: 400 });
    }

    const rows = Array.isArray(data) ? (data as RawOrder[]) : [];
    const mapped = await Promise.all(
      rows.map(async (order, index) => {
        const rawClient = Array.isArray(order.clients) ? order.clients[0] || null : order.clients;
        const items = Array.isArray(order.catalog_order_items) ? order.catalog_order_items : [];
        const itemCount = items.reduce((sum, item) => sum + Math.max(0, Number(item.quantity || 0)), 0);
        const itemPreview = items
          .map((item) => String(item.title || "").trim())
          .filter(Boolean)
          .slice(0, 3);

        return {
          id: order.id || `catalog-order-${index}`,
          number: Number(order.number || 0),
          user_id: order.user_id || "",
          status: order.status === "approved" || order.status === "canceled" ? order.status : "pending",
          kind: order.kind === "quote_request" ? "quote_request" : "order",
          customer_name: order.customer_name || null,
          customer_whatsapp: order.customer_whatsapp || null,
          total: Number.isFinite(Number(order.total)) ? Number(order.total) : 0,
          approved_order_id: order.approved_order_id || null,
          created_at: order.created_at || new Date().toISOString(),
          client_id: order.client_id || null,
          notes: order.notes || null,
          payment_status: order.payment_status || "unpaid",
          payment_method: order.payment_method || null,
          payment_reference: order.payment_reference || null,
          paid_at: order.paid_at || null,
          clients: rawClient
            ? {
                id: rawClient.id || "",
                name: rawClient.name || null,
                company_name: rawClient.company_name || null,
                avatar_url: await resolveStorageUrl(admin, rawClient.avatar_url),
              }
            : null,
          catalog_order_items: items.map((item) => ({
            id: item.id,
            title: item.title || "Item",
            quantity: Number(item.quantity || 0),
            total_price: Number(item.total_price || 0),
          })),
          item_count: itemCount,
          item_preview: itemPreview,
        };
      })
    );

    if (orderId) {
      return NextResponse.json({ ok: true, order: mapped[0] || null });
    }

    return NextResponse.json({ ok: true, orders: mapped });
  } catch {
    return NextResponse.json({ error: "Não foi possível carregar os pedidos do catálogo." }, { status: 500 });
  }
}