import { getAuthHeaders } from "./api-client";
import {
  CreateServiceOrderDTO,
  MaintenanceFilters,
  ServiceOrder,
  ServiceOrderStats,
  UpdateServiceOrderDTO,
} from "@/types/maintenance";

const API_BASE = (process.env.NEXT_PUBLIC_API_URL || "http://localhost:3333").replace(/\/$/, "") + "/api";

const INITIAL_MOCK_SERVICE_ORDERS: ServiceOrder[] = [];

let localServiceOrderStore: ServiceOrder[] = [...INITIAL_MOCK_SERVICE_ORDERS];

export async function getServiceOrders(params?: MaintenanceFilters & { page?: number; limit?: number }): Promise<{
  items: ServiceOrder[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
}> {
  try {
    const queryParams = new URLSearchParams();
    if (params?.search) queryParams.set("search", params.search);
    if (params?.status && params.status !== "ALL") queryParams.set("status", params.status);
    if (params?.equipmentId && params.equipmentId !== "ALL") queryParams.set("equipmentId", params.equipmentId);
    if (params?.page) queryParams.set("page", String(params.page));
    if (params?.limit) queryParams.set("limit", String(params.limit));

    const res = await fetch(`${API_BASE}/maintenance?${queryParams.toString()}`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });

    if (res.ok) {
      const data = await res.json();
      if (data && Array.isArray(data.items)) {
        return data;
      }
      if (Array.isArray(data)) {
        return { items: data, total: data.length, page: 1, limit: 50, totalPages: 1 };
      }
    }
  } catch {
    // fallback
  }

  let filtered = [...localServiceOrderStore];

  if (params?.search) {
    const term = params.search.toLowerCase();
    filtered = filtered.filter(
      (s) =>
        s.code.toLowerCase().includes(term) ||
        s.title.toLowerCase().includes(term) ||
        (s.description && s.description.toLowerCase().includes(term)) ||
        (s.equipment && s.equipment.code.toLowerCase().includes(term)) ||
        (s.equipment && s.equipment.model.toLowerCase().includes(term))
    );
  }

  if (params?.status && params.status !== "ALL") {
    filtered = filtered.filter((s) => s.status === params.status);
  }

  if (params?.equipmentId && params.equipmentId !== "ALL") {
    filtered = filtered.filter((s) => s.equipmentId === params.equipmentId);
  }

  const page = params?.page || 1;
  const limit = params?.limit || 20;
  const total = filtered.length;
  const totalPages = Math.ceil(total / limit) || 1;
  const startIndex = (page - 1) * limit;
  const items = filtered.slice(startIndex, startIndex + limit);

  return { items, total, page, limit, totalPages };
}

export async function getServiceOrderStats(): Promise<ServiceOrderStats> {
  try {
    const res = await fetch(`${API_BASE}/maintenance/stats`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });
    if (res.ok) {
      const stats = await res.json();
      if (stats && (stats.total > 0 || stats.open > 0 || stats.inProgress > 0)) {
        return stats;
      }
    }
  } catch {
    // fallback
  }

  const total = localServiceOrderStore.length;
  const open = localServiceOrderStore.filter((s) => s.status === "OPEN").length;
  const inProgress = localServiceOrderStore.filter((s) => s.status === "IN_PROGRESS").length;
  const done = localServiceOrderStore.filter((s) => s.status === "DONE").length;
  const canceled = localServiceOrderStore.filter((s) => s.status === "CANCELED").length;
  const totalCost = localServiceOrderStore.reduce((acc, s) => acc + (Number(s.cost) || 0), 0);

  return { total, open, inProgress, done, canceled, totalCost };
}

export async function getServiceOrderById(id: string): Promise<ServiceOrder | null> {
  try {
    const res = await fetch(`${API_BASE}/maintenance/${id}`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  return localServiceOrderStore.find((s) => s.id === id) || null;
}

export async function createServiceOrder(data: CreateServiceOrderDTO): Promise<ServiceOrder> {
  try {
    const res = await fetch(`${API_BASE}/maintenance`, {
      method: "POST",
      headers: getAuthHeaders(),
      body: JSON.stringify(data),
    });

    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const code = `OS-2026-${String(localServiceOrderStore.length + 10).padStart(4, "0")}`;

  const newSo: ServiceOrder = {
    id: `so-${Date.now()}`,
    companyId: "comp-default",
    equipmentId: data.equipmentId,
    code,
    title: data.title,
    description: data.description || null,
    status: data.status || "OPEN",
    cost: Number(data.cost) || 0,
    openedAt: data.openedAt || new Date().toISOString(),
    closedAt: data.closedAt || null,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    equipment: {
      id: data.equipmentId,
      code: "EQ-100",
      assetTag: "PAT-100",
      brand: "Equipamento",
      model: "Industrial",
      status: data.status === "DONE" || data.status === "CANCELED" ? "AVAILABLE" : "MAINTENANCE",
    },
  };

  localServiceOrderStore = [newSo, ...localServiceOrderStore];
  return newSo;
}

export async function updateServiceOrder(
  id: string,
  data: UpdateServiceOrderDTO
): Promise<ServiceOrder> {
  try {
    const res = await fetch(`${API_BASE}/maintenance/${id}`, {
      method: "PATCH",
      headers: getAuthHeaders(),
      body: JSON.stringify(data),
    });

    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const index = localServiceOrderStore.findIndex((s) => s.id === id);
  if (index === -1) {
    throw new Error("Ordem de serviço não encontrada.");
  }

  const updated: ServiceOrder = {
    ...localServiceOrderStore[index],
    ...data,
    cost: data.cost !== undefined ? Number(data.cost) : localServiceOrderStore[index].cost,
    closedAt:
      data.status === "DONE" || data.status === "CANCELED"
        ? data.closedAt || new Date().toISOString()
        : data.closedAt !== undefined
        ? data.closedAt
        : localServiceOrderStore[index].closedAt,
    updatedAt: new Date().toISOString(),
  };

  localServiceOrderStore[index] = updated;
  return updated;
}

export async function deleteServiceOrder(id: string): Promise<boolean> {
  try {
    const res = await fetch(`${API_BASE}/maintenance/${id}`, {
      method: "DELETE",
      headers: getAuthHeaders(),
    });

    if (res.ok) {
      return true;
    }
  } catch {
    // fallback
  }

  localServiceOrderStore = localServiceOrderStore.filter((s) => s.id !== id);
  return true;
}