"use client";

import type { ModeloDoCatalogo } from "@/lib/xbz/xbz.catalogo";
import type { PedidoXbzResumo } from "@/lib/xbz/xbz.pedido";

type RequestOptions = {
  method?: "GET" | "POST";
  body?: Record<string, unknown>;
};

function extractErrorMessage(payload: unknown): string | null {
  if (!payload || typeof payload !== "object") return null;
  const record = payload as Record<string, unknown>;
  const directCandidates = ["error", "message", "detail", "details", "mensagem"];
  for (const key of directCandidates) {
    const value = record[key];
    if (typeof value === "string" && value.trim()) return value.trim();
    if (Array.isArray(value)) {
      const firstText = value.find((entry) => typeof entry === "string" && entry.trim()) as string | undefined;
      if (firstText) return firstText.trim();
    }
    if (value && typeof value === "object") {
      const nested = value as Record<string, unknown>;
      if (typeof nested.message === "string" && nested.message.trim()) return nested.message.trim();
      if (typeof nested.error === "string" && nested.error.trim()) return nested.error.trim();
    }
  }
  return null;
}

export type SituacaoDoCatalogo = {
  atualizadoEm: string | null;
  itens: number;
  modelos: number;
  atualizando: boolean;
  erro: string | null;
  podeAtualizarEm: string | null;
};

export type XbzDashboardState = {
  credentials: {
    cnpj: string;
    tokenMasked: string;
    hasToken: boolean;
    active: boolean;
    updatedAt: string | null;
  };
  cache: {
    deliveryTypes: Array<Record<string, unknown>>;
    paymentTypes: Array<Record<string, unknown>>;
    transportadoras: Array<Record<string, unknown>>;
    gravacoes: Array<Record<string, unknown>>;
    lastProductSearch: {
      busca: string;
      items: Array<Record<string, unknown>>;
      syncedAt: string;
    } | null;
    lastOrdersSync: {
      params: Record<string, unknown>;
      items: Array<Record<string, unknown>>;
      syncedAt: string;
    } | null;
    orderHistory: Array<Record<string, unknown>>;
  };
  quota: {
    dailyLimit: number;
    used: number;
  };
  pedidosRecentes?: Array<{ id: string; numero: string; valorTotal: number | null; criadoEm: string | null; cliente: string | null }>;
  ultimaSincronizacao?: string | null;
  pedidos?: PedidoXbzResumo[];
  catalogo?: SituacaoDoCatalogo | null;
  margemDeVenda?: number | null;
};

export type ResultadoDaBusca = { modelos: ModeloDoCatalogo[]; catalogo: SituacaoDoCatalogo };

export type ResultadoDoCadastro = {
  jaExistia: boolean;
  id: string;
  nome: string;
  preco?: number;
  custo?: number | null;
  cores?: number;
  fotos?: number;
  naLoja?: boolean;
  avisos?: string[];
};

async function request<T>(url: string, options?: RequestOptions): Promise<T> {
  const response = await fetch(url, {
    method: options?.method || "GET",
    headers: { "Content-Type": "application/json" },
    body: options?.body ? JSON.stringify(options.body) : undefined,
  });
  const rawText = await response.text();
  let payload: Record<string, unknown> = {};
  if (rawText) {
    try {
      payload = JSON.parse(rawText) as Record<string, unknown>;
    } catch {
      payload = {};
    }
  }
  if (!response.ok) {
    const message = extractErrorMessage(payload) || `Falha na integração XBZ (HTTP ${response.status}).`;
    throw new Error(message);
  }
  return payload as T;
}

export function getXbzDashboardState() {
  return request<XbzDashboardState>("/api/fornecedores/xbz");
}

export function saveXbzCredentials(cnpj: string, token: string) {
  return request<Record<string, unknown>>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "saveCredentials", cnpj, token },
  });
}

export function testXbzConnection() {
  return request<Record<string, unknown>>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "testConnection" },
  });
}

export function syncXbzAuxiliary() {
  return request<Record<string, unknown>>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "syncAuxiliary" },
  });
}

export function searchXbzProducts(busca: string) {
  return request<ResultadoDaBusca>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "searchProducts", busca },
  });
}

export function xbzCatalogStatus() {
  return request<{ catalogo: SituacaoDoCatalogo }>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "catalogStatus" },
  });
}

export function refreshXbzCatalog() {
  return request<{ catalogo: SituacaoDoCatalogo; message?: string }>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "refreshCatalog" },
  });
}

export function importXbzModel(entrada: { modelo: string; cores: string[]; margem: number; nome: string }) {
  return request<{ product: ResultadoDoCadastro; message?: string }>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "importProduct", ...entrada },
  });
}

export function createXbzOrder(body: Record<string, unknown>) {
  return request<{ numero: string | null; guardado: boolean; pedido: PedidoXbzResumo | null; message?: string }>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "createOrder", ...body },
  });
}

export function listXbzOrders(body: Record<string, unknown>) {
  return request<{ pedidos: PedidoXbzResumo[]; orders: Array<Record<string, unknown>> }>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "listOrders", ...body },
  });
}

export function cancelXbzOrder(numero: string) {
  return request<Record<string, unknown>>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "cancelOrder", numero },
  });
}

export function runXbzSyncJob() {
  return request<Record<string, unknown>>("/api/fornecedores/xbz/sync", { method: "POST" });
}

export function migrateXbzLegacy() {
  return request<Record<string, unknown>>("/api/fornecedores/xbz", {
    method: "POST",
    body: { action: "migrateLegacyData" },
  });
}