import { SaleRecord } from "@/types/sales";
import { formatBusinessDate } from "@/lib/reporting";

const STORAGE_KEY = "pos-sales";
const API_BASE = (import.meta.env.VITE_POS_API_BASE_URL || "/api").replace(
  /\/$/,
  "",
);

interface SerializableSaleRecord extends Omit<SaleRecord, "timestamp"> {
  timestamp: string;
}

function serializeSales(sales: SaleRecord[]): string {
  const payload: SerializableSaleRecord[] = sales.map((sale) => ({
    ...sale,
    timestamp: sale.timestamp.toISOString(),
  }));

  return JSON.stringify(payload);
}

function deserializeSales(raw: string | null): SaleRecord[] {
  if (!raw) return [];

  try {
    const parsed = JSON.parse(raw) as SerializableSaleRecord[];
    return parsed.map((sale) => ({
      ...sale,
      timestamp: new Date(sale.timestamp),
    }));
  } catch (error) {
    console.error("Failed to parse stored sales", error);
    return [];
  }
}

function supportsBrowserStorage(): boolean {
  return (
    typeof window !== "undefined" &&
    typeof window.localStorage !== "undefined"
  );
}

export function loadStoredSales(
  businessDate = formatBusinessDate(new Date()),
): SaleRecord[] {
  if (!supportsBrowserStorage()) return [];

  const sales = deserializeSales(window.localStorage.getItem(STORAGE_KEY));
  return sales.filter((sale) => sale.businessDate === businessDate);
}

export function saveStoredSales(sales: SaleRecord[]): void {
  if (!supportsBrowserStorage()) return;

  const allSales = deserializeSales(window.localStorage.getItem(STORAGE_KEY));
  const businessDates = new Set(sales.map((sale) => sale.businessDate));
  const remainingSales = allSales.filter(
    (sale) => !businessDates.has(sale.businessDate),
  );

  window.localStorage.setItem(
    STORAGE_KEY,
    serializeSales([...remainingSales, ...sales]),
  );
}

export function clearStoredSales(businessDate: string): void {
  if (!supportsBrowserStorage()) return;

  const allSales = deserializeSales(window.localStorage.getItem(STORAGE_KEY));
  const remainingSales = allSales.filter(
    (sale) => sale.businessDate !== businessDate,
  );
  window.localStorage.setItem(STORAGE_KEY, serializeSales(remainingSales));
}

export async function loadSalesFromServer(
  businessDate: string,
): Promise<SaleRecord[] | null> {
  try {
    const response = await fetch(
      `${API_BASE}/sales.php?date=${encodeURIComponent(businessDate)}`,
    );

    if (!response.ok) {
      return null;
    }

    const data = (await response.json()) as { sales?: SerializableSaleRecord[] };
    if (!data.sales) return [];

    return data.sales.map((sale) => ({
      ...sale,
      timestamp: new Date(sale.timestamp),
    }));
  } catch (error) {
    console.error("Failed to load sales from server", error);
    return null;
  }
}

export async function saveSaleToServer(sale: SaleRecord): Promise<boolean> {
  try {
    const response = await fetch(`${API_BASE}/sales.php`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ...sale,
        timestamp: sale.timestamp.toISOString(),
      }),
    });

    return response.ok;
  } catch (error) {
    console.error("Failed to save sale to server", error);
    return false;
  }
}

export async function clearSalesOnServer(
  businessDate: string,
): Promise<boolean> {
  try {
    const response = await fetch(`${API_BASE}/reset_day.php`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ businessDate }),
    });

    return response.ok;
  } catch (error) {
    console.error("Failed to clear sales on server", error);
    return false;
  }
}