/* Nutri Cloud — Firestore sync layer.
   Per-user data lives at:
     users/{uid}                           — profile fields (displayName, email, photoURL, createdAt, updatedAt)
     users/{uid}/data/macro                — { calories, protein_g, carbs_g, fat_g }
     users/{uid}/data/meals                — { entries: [...] }
     users/{uid}/data/finance              — { entries: [...] }
     users/{uid}/data/goals                — { goals: [...] }
     users/{uid}/data/diary                — { entries: [...] }
     users/{uid}/data/assistant            — { messages: [...] }
     users/{uid}/data/settings             — { theme, notes, weights, menu, ... }
     users/{uid}/backups/{ts}              — snapshot docs (optional manual backups)
*/
(function(){
  const DATA_DOCS = ['profile','settings','macro','meals','finance','goals','diary','assistant','local-library','movies'];

  function ts() { return new Date().toISOString(); }

  function rootRef(uid)       { return window.firebaseDB.collection('users').doc(uid); }
  function dataRef(uid, name) { return rootRef(uid).collection('data').doc(name); }
  function backupRef(uid)     { return rootRef(uid).collection('backups'); }

  async function ensureUserDoc(user) {
    const ref = rootRef(user.uid);
    const snap = await ref.get();
    if (!snap.exists) {
      await ref.set({
        uid: user.uid,
        email: user.email || '',
        displayName: user.displayName || (user.email ? user.email.split('@')[0] : 'Friend'),
        photoURL: user.photoURL || '',
        createdAt: ts(),
        updatedAt: ts(),
      });
    }
    return ref;
  }

  async function loadAll(uid) {
    const ref = rootRef(uid);
    const userSnap = await ref.get();
    const data = { profile: userSnap.exists ? userSnap.data() : null };
    const docs = await Promise.all([
      dataRef(uid, 'macro').get(),
      dataRef(uid, 'meals').get(),
      dataRef(uid, 'finance').get(),
      dataRef(uid, 'goals').get(),
      dataRef(uid, 'diary').get(),
      dataRef(uid, 'assistant').get(),
      dataRef(uid, 'settings').get(),
      dataRef(uid, 'local-library').get(),
      dataRef(uid, 'movies').get(),
    ]);
    const [macro, meals, finance, goals, diary, assistant, settings, localLib, movies] = docs.map(d => d.exists ? d.data() : null);
    return {
      profile: data.profile,
      macroGoals: macro || null,
      meals: (meals && Array.isArray(meals.entries))   ? meals.entries   : [],
      finance:(finance && Array.isArray(finance.entries)) ? finance.entries : [],
      goals:  (goals && Array.isArray(goals.goals))    ? goals.goals    : [],
      diary:  (diary && Array.isArray(diary.entries))  ? diary.entries  : [],
      assistantChat: (assistant && Array.isArray(assistant.messages)) ? assistant.messages : [],
      settings: settings || null,
      localLibrary: (localLib && Array.isArray(localLib.items)) ? localLib.items : [],
      movies: (movies && Array.isArray(movies.items)) ? movies.items : [],
    };
  }

  // ---- Per-collection writers (called by Store after a local mutation) ----
  async function writeMeals(uid, entries)     { return dataRef(uid, 'meals').set({ entries, updatedAt: ts() }); }
  async function writeFinance(uid, entries)   { return dataRef(uid, 'finance').set({ entries, updatedAt: ts() }); }
  async function writeGoals(uid, goals)       { return dataRef(uid, 'goals').set({ goals, updatedAt: ts() }); }
  async function writeDiary(uid, entries)     { return dataRef(uid, 'diary').set({ entries, updatedAt: ts() }); }
  async function writeMacro(uid, macroGoals)  { return dataRef(uid, 'macro').set({ ...macroGoals, updatedAt: ts() }); }
  async function writeAssistant(uid, messages){ return dataRef(uid, 'assistant').set({ messages, updatedAt: ts() }); }
  async function writeSettings(uid, settings)      { return dataRef(uid, 'settings').set({ ...settings, updatedAt: ts() }); }
  async function writeLocalLibrary(uid, items)     { return dataRef(uid, 'local-library').set({ items, updatedAt: ts() }); }
  async function writeMovies(uid, items)           { return dataRef(uid, 'movies').set({ items, updatedAt: ts() }); }
  async function writeProfile(uid, profile)   {
    await rootRef(uid).set({ ...profile, updatedAt: ts() }, { merge: true });
  }

  // ---- Backup snapshots (optional history) ----
  async function pushBackupSnapshot(uid, state) {
    const id = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
    await backupRef(uid).doc(id).set({ ...state, snappedAt: ts() });
    return id;
  }

  const Cloud = {
    rootRef, dataRef, backupRef,
    ensureUserDoc, loadAll,
    writeMeals, writeFinance, writeGoals, writeDiary,
    writeMacro, writeAssistant, writeSettings, writeProfile,
    writeLocalLibrary, writeMovies,
    pushBackupSnapshot,
  };
  window.Cloud = Cloud;
})();