import { apiClient, isNetworkError } from "@/lib/api-client";
import type { AttendanceType } from "@/lib/types";

const DB_NAME = "absentic-hz-offline";
const DB_VERSION = 1;
const STORE_NAME = "pending-attendance";

export interface PendingAttendance {
  id: number;
  endpoint: Extract<AttendanceType, "check_in" | "check_out">;
  photo: Blob;
  latitude: number;
  longitude: number;
  accuracy_meters: number;
  mock_detected: boolean;
  client_timestamp: string;
  queued_at: string;
}

type NewPendingAttendance = Omit<PendingAttendance, "id" | "queued_at">;

function openDb(): Promise<IDBDatabase> {
  return new Promise((resolve, reject) => {
    const request = window.indexedDB.open(DB_NAME, DB_VERSION);
    request.onupgradeneeded = () => {
      request.result.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
    };
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
}

export async function enqueueAttendance(entry: NewPendingAttendance): Promise<void> {
  const db = await openDb();
  await new Promise<void>((resolve, reject) => {
    const tx = db.transaction(STORE_NAME, "readwrite");
    tx.objectStore(STORE_NAME).add({ ...entry, queued_at: new Date().toISOString() });
    tx.oncomplete = () => resolve();
    tx.onerror = () => reject(tx.error);
  });
  db.close();
}

export async function listPendingAttendance(): Promise<PendingAttendance[]> {
  const db = await openDb();
  const result = await new Promise<PendingAttendance[]>((resolve, reject) => {
    const tx = db.transaction(STORE_NAME, "readonly");
    const request = tx.objectStore(STORE_NAME).getAll();
    request.onsuccess = () => resolve(request.result as PendingAttendance[]);
    request.onerror = () => reject(request.error);
  });
  db.close();
  return result;
}

async function removePendingAttendance(id: number): Promise<void> {
  const db = await openDb();
  await new Promise<void>((resolve, reject) => {
    const tx = db.transaction(STORE_NAME, "readwrite");
    tx.objectStore(STORE_NAME).delete(id);
    tx.oncomplete = () => resolve();
    tx.onerror = () => reject(tx.error);
  });
  db.close();
}

export function buildAttendanceFormData(entry: {
  photo: Blob;
  latitude: number;
  longitude: number;
  accuracy_meters: number;
  mock_detected: boolean;
  client_timestamp: string;
}): FormData {
  const formData = new FormData();
  formData.append("photo", entry.photo, "attendance.jpg");
  formData.append("latitude", String(entry.latitude));
  formData.append("longitude", String(entry.longitude));
  formData.append("accuracy_meters", String(entry.accuracy_meters));
  formData.append("mock_detected", entry.mock_detected ? "1" : "0");
  formData.append("client_timestamp", entry.client_timestamp);
  return formData;
}

/**
 * Retries every queued check-in/out. Stops at the first network failure
 * (still offline) but drops entries the server rejects outright, since a
 * validation error (e.g. a sequence violation from a check-in submitted
 * later from another device) will never succeed by retrying unchanged.
 */
export async function flushPendingAttendance(
  token: string,
  onSettled?: (entry: PendingAttendance, ok: boolean) => void,
): Promise<void> {
  const pending = await listPendingAttendance();

  for (const entry of pending) {
    try {
      const formData = buildAttendanceFormData(entry);
      await apiClient.postForm(`/attendance/${entry.endpoint.replace("_", "-")}`, formData, token);
      await removePendingAttendance(entry.id);
      onSettled?.(entry, true);
    } catch (error) {
      if (isNetworkError(error)) {
        break;
      }
      await removePendingAttendance(entry.id);
      onSettled?.(entry, false);
    }
  }
}
