/* DataContext + DataProvider + useData → window. Usa window.db y window.auth. */
(function () {
  const { useState, useEffect, createContext, useContext } = React;
  const { useAuth, STORAGE_KEY } = window;

  const DataContext = createContext(null);

  async function migrateLocalStorageIfNeeded(uid) {
    try {
      const metaSnap = await window.db.ref(`users/${uid}/meta/migrated`).once("value");
      if (metaSnap.val() === true) return;

      const raw = localStorage.getItem(STORAGE_KEY);
      if (raw) {
        const arr = JSON.parse(raw);
        if (Array.isArray(arr) && arr.length > 0) {
          const updates = {};
          for (const r of arr) {
            if (!r.fecha) continue;
            const ingreso = Number(r.ingreso) || 0;
            const gasolina = Number(r.gasolina) || 0;
            const mantenimiento = Number(r.mantenimiento) || 0;
            updates[`users/${uid}/registros/${r.fecha}`] = {
              ingreso, gasolina, mantenimiento,
              nota: (r.nota || "").trim(),
              neto: ingreso - gasolina - mantenimiento,
              updatedAt: firebase.database.ServerValue.TIMESTAMP,
            };
          }
          await window.db.ref().update(updates);
        }
      }
      await window.db.ref(`users/${uid}/meta/migrated`).set(true);
      localStorage.removeItem(STORAGE_KEY);
    } catch (e) {
      console.warn("Migración localStorage → Firebase falló:", e);
    }
  }

  function DataProvider({ children }) {
    const { user } = useAuth();
    const [records, setRecords] = useState([]);
    const [syncStatus, setSyncStatus] = useState(
      typeof navigator !== "undefined" && navigator.onLine === false ? "offline" : "synced"
    );

    // Listeners online/offline
    useEffect(() => {
      const onOnline = () => setSyncStatus(s => (s === "offline" ? "synced" : s));
      const onOffline = () => setSyncStatus("offline");
      window.addEventListener("online", onOnline);
      window.addEventListener("offline", onOffline);
      return () => {
        window.removeEventListener("online", onOnline);
        window.removeEventListener("offline", onOffline);
      };
    }, []);

    useEffect(() => {
      if (!user) { setRecords([]); return; }

      migrateLocalStorageIfNeeded(user.uid);

      const ref = window.db.ref(`users/${user.uid}/registros`);
      const handler = ref.on("value", snap => {
        const val = snap.val() || {};
        const arr = Object.entries(val).map(([fecha, v]) => ({
          fecha,
          ingreso: Number(v.ingreso) || 0,
          gasolina: Number(v.gasolina) || 0,
          mantenimiento: Number(v.mantenimiento) || 0,
          nota: v.nota || "",
        }));
        setRecords(arr);
      }, err => {
        console.warn("RTDB read error:", err);
      });
      return () => ref.off("value", handler);
    }, [user]);

    const withSyncStatus = async (op) => {
      if (!navigator.onLine) {
        setSyncStatus("offline");
      } else {
        setSyncStatus("saving");
      }
      try {
        const r = await op();
        setSyncStatus(navigator.onLine ? "synced" : "offline");
        return r;
      } catch (e) {
        setSyncStatus("error");
        setTimeout(() => setSyncStatus(navigator.onLine ? "synced" : "offline"), 3000);
        throw e;
      }
    };

    const upsert = (rec) => {
      if (!user) return Promise.reject(new Error("no-user"));
      const ingreso = Number(rec.ingreso) || 0;
      const gasolina = Number(rec.gasolina) || 0;
      const mantenimiento = Number(rec.mantenimiento) || 0;
      return withSyncStatus(() =>
        window.db.ref(`users/${user.uid}/registros/${rec.fecha}`).set({
          ingreso, gasolina, mantenimiento,
          nota: (rec.nota || "").trim(),
          neto: ingreso - gasolina - mantenimiento,
          updatedAt: firebase.database.ServerValue.TIMESTAMP,
        })
      );
    };

    const remove = (fecha) => {
      if (!user) return Promise.reject(new Error("no-user"));
      return withSyncStatus(() => window.db.ref(`users/${user.uid}/registros/${fecha}`).remove());
    };

    return <DataContext.Provider value={{ records, upsert, remove, syncStatus }}>{children}</DataContext.Provider>;
  }

  const useData = () => useContext(DataContext);

  Object.assign(window, { DataContext, DataProvider, useData });
})();