import { getAuthHeaders } from "./api-client";
import {
  Contract,
  ContractFilterParams,
  ContractStats,
  CreateContractDTO,
  UpdateContractDTO,
} from "@/types/contract";

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

const DEFAULT_CLAUSES = `CLÁUSULA 1ª (DO OBJETO): O presente contrato tem por objeto a locação dos equipamentos discriminados no pedido de locação.
CLÁUSULA 2ª (DAS OBRIGAÇÕES DO LOCATÁRIO): O LOCATÁRIO obriga-se a operar os equipamentos com pessoal habilitado, zelar pela manutenção diária de níveis de óleo e combustível, e arcar com os custos de frete de mobilização/desmobilização.
CLÁUSULA 3ª (DA MANUTENÇÃO PREVENTIVA): As manutenções preventivas periósticas decorrentes de desgaste natural serão efetuadas pela LOCADORA sem custo adicional.
CLÁUSULA 4ª (DO INADIMPLEMENTO E MULTA): O atraso no pagamento sujeitará o LOCATÁRIO a multa moratória de 2% (dois por cento) e juros de 1% ao mês.`;

const INITIAL_MOCK_CONTRACTS: Contract[] = [];

let localContractStore: Contract[] = [...INITIAL_MOCK_CONTRACTS];

export async function getContracts(params?: ContractFilterParams): Promise<{
  items: Contract[];
  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?.customerId && params.customerId !== "ALL") queryParams.set("customerId", params.customerId);
    if (params?.page) queryParams.set("page", String(params.page));
    if (params?.limit) queryParams.set("limit", String(params.limit));

    const res = await fetch(`${API_BASE}/contracts?${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 = [...localContractStore];

  if (params?.search) {
    const term = params.search.toLowerCase();
    filtered = filtered.filter(
      (c) =>
        c.code.toLowerCase().includes(term) ||
        c.title.toLowerCase().includes(term) ||
        (c.customer && c.customer.name.toLowerCase().includes(term))
    );
  }

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

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

  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 getContractStats(): Promise<ContractStats> {
  try {
    const res = await fetch(`${API_BASE}/contracts/stats`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });
    if (res.ok) {
      const stats = await res.json();
      if (stats && (stats.total > 0 || stats.signed > 0)) {
        return stats;
      }
    }
  } catch {
    // fallback
  }

  const total = localContractStore.length;
  const signed = localContractStore.filter((c) => c.status === "SIGNED").length;
  const pendingSignature = localContractStore.filter((c) => c.status === "PENDING_SIGNATURE").length;
  const draft = localContractStore.filter((c) => c.status === "DRAFT").length;
  const totalContractedValue = localContractStore.reduce(
    (acc, c) => acc + (Number(c.value) || 0),
    0
  );

  return { total, signed, pendingSignature, draft, totalContractedValue };
}

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

  return localContractStore.find((c) => c.id === id) || null;
}

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

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

  const code = `CTR-2026-${String(localContractStore.length + 100).padStart(4, "0")}`;

  const newContract: Contract = {
    id: `ctr-${Date.now()}`,
    companyId: "comp-default",
    code,
    customerId: data.customerId,
    rentalId: data.rentalId || null,
    title: data.title,
    startDate: data.startDate,
    endDate: data.endDate,
    value: Number(data.value) || 0,
    clauses: data.clauses || DEFAULT_CLAUSES,
    notes: data.notes || null,
    status: data.status || "DRAFT",
    signedAt: data.status === "SIGNED" ? new Date().toISOString() : null,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    customer: {
      id: data.customerId,
      name: "Cliente Selecionado",
      document: "00.000.000/0001-00",
    },
    equipmentCount: 1,
  };

  localContractStore = [newContract, ...localContractStore];
  return newContract;
}

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

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

  const index = localContractStore.findIndex((c) => c.id === id);
  if (index === -1) {
    throw new Error("Contrato não encontrado.");
  }

  const updated: Contract = {
    ...localContractStore[index],
    ...data,
    signedAt: data.status === "SIGNED" ? new Date().toISOString() : localContractStore[index].signedAt,
    updatedAt: new Date().toISOString(),
  };

  localContractStore[index] = updated;
  return updated;
}

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

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

  localContractStore = localContractStore.filter((c) => c.id !== id);
  return true;
}