Local Storage

const STORAGE_KEY = "cv-draft";
const BASE_KEY = "cv-draft-base"; // Key for base version (last synced state)

export interface DraftData {
  data: CVData;
  savedAt: string;
}

export interface BaseData {
  data: CVData;
  savedAt: string;
}

export function saveDraft(data: CVData): boolean {
  try {
    const draft: DraftData = {
      data,
      savedAt: new Date().toISOString(),
    };
    localStorage.setItem(STORAGE_KEY, JSON.stringify(draft));
    return true;
  } catch (error) {
    console.error("[CVDraft] Failed to save draft:", error);
    return false;
  }
}

export function loadDraft(): DraftData | null {
  try {
    const stored = localStorage.getItem(STORAGE_KEY);
    if (!stored) return null;

    const draft = JSON.parse(stored) as DraftData;

    // Validate the data structure
    const validatedData = validateCVData(draft.data);
    if (!validatedData) {
      console.warn("Draft data failed validation, clearing");
      clearDraft();
      return null;
    }

    return {
      data: validatedData,
      savedAt: draft.savedAt,
    };
  } catch (error) {
    console.error("Failed to load draft:", error);
    return null;
  }
}

export function hasDraft(): boolean {
  try {
    return localStorage.getItem(STORAGE_KEY) !== null;
  } catch (error) {
    console.error("[CVDraft] Failed to check draft existence:", error);
    return false;
  }
}

export function clearDraft(): boolean {
  try {
    localStorage.removeItem(STORAGE_KEY);
    return true;
  } catch (error) {
    console.error("[CVDraft] Failed to clear draft:", error);
    return false;
  }
}

export function saveBase(data: CVData): boolean {
  try {
    const base: BaseData = {
      data,
      savedAt: new Date().toISOString(),
    };
    localStorage.setItem(BASE_KEY, JSON.stringify(base));
    return true;
  } catch (error) {
    console.error("[CVDraft] Failed to save base:", error);
    return false;
  }
}

export function loadBase(): BaseData | null {
  try {
    const stored = localStorage.getItem(BASE_KEY);
    if (!stored) return null;

    const base = JSON.parse(stored) as BaseData;

    // Validate the data structure
    const validatedData = validateCVData(base.data);
    if (!validatedData) {
      console.warn("Base data failed validation, clearing");
      localStorage.removeItem(BASE_KEY);
      return null;
    }

    return {
      data: validatedData,
      savedAt: base.savedAt,
    };
  } catch (error) {
    console.error("[CVDraft] Failed to load base:", error);
    return null;
  }
}

export function updateBaseAfterSync(data: CVData): boolean {
  return saveBase(data);
}

export function hasMeaningfulContent(data: CVData): boolean {
  // Check personal info for non-empty string values
  const personalInfoFields = [
    data.personalInfo.fullName,
    data.personalInfo.email,
    data.personalInfo.phone,
    data.personalInfo.address,
    data.personalInfo.jobTitle,
    data.personalInfo.summary,
    data.personalInfo.website,
    data.personalInfo.linkedin,
    data.personalInfo.github,
    data.personalInfo.profileImageUrl,
  ];

  const hasPersonalInfo = personalInfoFields.some(
    (v) => typeof v === "string" && v.trim().length > 0
  );

  // Check for any array with items
  const hasArrayContent =
    data.experience.length > 0 ||
    data.education.length > 0 ||
    data.projects.length > 0 ||
    data.achievements.length > 0 ||
    data.languages.length > 0 ||
    data.skills.length > 0;

  // Check for non-default references
  const hasReferences = (data.references || "").trim().length > 0 &&
    data.references !== "Available upon request.";

  return hasPersonalInfo || hasArrayContent || hasReferences;
}

export function hasDataChanged(a: CVData, b: CVData): boolean {
  // Compare arrays by checking if they have different lengths or different items
  const arraysDiffer = <T extends { id: string }>(arrA: T[], arrB: T[]): boolean => {
    if (arrA.length !== arrB.length) return true;
    return JSON.stringify(arrA) !== JSON.stringify(arrB);
  };

  // Compare personal info
  const personalA = JSON.stringify(a.personalInfo);
  const personalB = JSON.stringify(b.personalInfo);
  if (personalA !== personalB) return true;

  // Compare arrays
  if (arraysDiffer(a.experience, b.experience)) return true;
  if (arraysDiffer(a.education, b.education)) return true;
  if (arraysDiffer(a.projects, b.projects)) return true;
  if (arraysDiffer(a.achievements, b.achievements)) return true;
  if (arraysDiffer(a.languages, b.languages)) return true;
  if (arraysDiffer(a.skills, b.skills)) return true;
  if (JSON.stringify(a.sectionOrder) !== JSON.stringify(b.sectionOrder)) return true;
  if (JSON.stringify(a.hiddenSections) !== JSON.stringify(b.hiddenSections)) return true;
  if ((a.references || "") !== (b.references || "")) return true;
  if ((a.template || "default") !== (b.template || "default")) return true;

  return false;
}