const { accountFor, buildLoginResponse, PEOPLE, RENAME } = require("../src/auth");

describe("accountFor", () => {
  it("maps usernames to person + name (case-insensitive)", () => {
    expect(accountFor("ayush")).toEqual({ person: "ayush", name: "Ayush" });
    expect(accountFor("saanu")).toEqual({ person: "simran", name: "Saanu" });
    expect(accountFor("SAANU")).toEqual({ person: "simran", name: "Saanu" });
  });
  it("returns null for unknown users", () => {
    expect(accountFor("bob")).toBeNull();
    expect(accountFor("")).toBeNull();
  });
});

describe("buildLoginResponse", () => {
  it("returns the exact success shape", () => {
    const acct = accountFor("saanu");
    expect(buildLoginResponse(acct, "TOK")).toEqual({
      ok: true, token: "TOK", person: "simran", name: "Saanu",
      people: { ayush: "Ayush", simran: "Saanu" },
      rename: { "Simran": "Saanu" }
    });
  });
  it("exposes the shared maps", () => {
    expect(PEOPLE).toEqual({ ayush: "Ayush", simran: "Saanu" });
    expect(RENAME).toEqual({ "Simran": "Saanu" });
  });
});

var ACCOUNTS = {
  ayush: { person: "ayush", name: "Ayush" },
  saanu: { person: "simran", name: "Saanu" }
};
var PEOPLE = { ayush: "Ayush", simran: "Saanu" };
var RENAME = { "Simran": "Saanu" };

function accountFor(username) {
  var key = String(username == null ? "" : username).toLowerCase();
  return Object.prototype.hasOwnProperty.call(ACCOUNTS, key) ? ACCOUNTS[key] : null;
}

function buildLoginResponse(account, token) {
  return {
    ok: true, token: token, person: account.person, name: account.name,
    people: PEOPLE, rename: RENAME
  };
}

if (typeof module !== "undefined" && module.exports) {
  module.exports = { ACCOUNTS, PEOPLE, RENAME, accountFor, buildLoginResponse };
}

// Server-side only (Code.gs is never served to the browser).
var SALT = "health-app-auth-v1::";

function hashPassword_(pw) {
  var bytes = Utilities.computeDigest(
    Utilities.DigestAlgorithm.SHA_256, SALT + String(pw), Utilities.Charset.UTF_8);
  return bytes.map(function (b) { return ("0" + (b & 0xff).toString(16)).slice(-2); }).join("");
}

// Run once per person in the editor: setUser("ayush", "their-password")
function setUser(username, password) {
  PropertiesService.getScriptProperties()
    .setProperty("USER_" + String(username).toLowerCase(), hashPassword_(password));
  Logger.log("Password set for " + username);
}

function doPost(e) {
  var payload;
  try {
    payload = JSON.parse((e && e.postData && e.postData.contents) || "{}");
  } catch (err) {
    return jsonOut_({ ok: false, error: "bad_json" });
  }

  if (payload.action === "login") {
    var uname = String(payload.username || "").toLowerCase();
    var acct = accountFor(uname);
    if (acct) {
      var stored = PropertiesService.getScriptProperties().getProperty("USER_" + uname);
      if (stored && stored === hashPassword_(String(payload.password || ""))) {
        return jsonOut_(buildLoginResponse(acct, scriptToken_()));
      }
    }
    return jsonOut_({ ok: false, error: "invalid" });
  }

  // Check-off (token required)
  if (!isAuthorized(payload.token, scriptToken_())) {
    return jsonOut_({ error: "unauthorized" });
  }
  logSheet_().appendRow([
    new Date().toISOString(),
    String(payload.date || ""),
    String(payload.person || ""),
    String(payload.itemId || ""),
    String(payload.itemLabel || ""),
    payload.done === true
  ]);
  return jsonOut_({ ok: true });
}

const { applyRename } = require("../../health/js/schedule.js");

describe("applyRename", () => {
  it("rewrites map keys across events, gym, and principles", () => {
    const data = {
      schedule: {
        office: { ayush: [{ activity: "Walk with Simran", details: "", notes: "see Simran - Diet tab" }],
                  simran: [{ activity: "Yoga", details: "Simran routine", notes: "" }] },
        wfh: { ayush: [], simran: [] }, saturday: { ayush: [], simran: [] }, sunday: { ayush: [], simran: [] }
      },
      gym: [{ day: "Monday", focusAyush: "Lower", focusSimran: "Simran lower", type: "Strength" }],
      principles: [{ topic: "Together Time", guideline: "Dinner with Simran" }]
    };
    const out = applyRename(data, { "Simran": "Saanu" });
    expect(out.schedule.office.ayush[0].activity).toBe("Walk with Saanu");
    expect(out.schedule.office.ayush[0].notes).toBe("see Saanu - Diet tab");
    expect(out.schedule.office.simran[0].details).toBe("Saanu routine");
    expect(out.gym[0].focusSimran).toBe("Saanu lower");
    expect(out.principles[0].guideline).toBe("Dinner with Saanu");
  });
  it("is a no-op for an empty map", () => {
    const data = { schedule: { office:{ayush:[{activity:"X",details:"",notes:""}],simran:[]}, wfh:{ayush:[],simran:[]}, saturday:{ayush:[],simran:[]}, sunday:{ayush:[],simran:[]} }, gym: [], principles: [] };
    expect(applyRename(data, {}).schedule.office.ayush[0].activity).toBe("X");
  });
});

function renameStr_(s, map) {
  var out = String(s == null ? "" : s);
  for (var k in map) { if (Object.prototype.hasOwnProperty.call(map, k)) out = out.split(k).join(map[k]); }
  return out;
}

function applyRename(data, map) {
  if (!data || !map) return data;
  var DAYS = ["office", "wfh", "saturday", "sunday"];
  for (var d = 0; d < DAYS.length; d++) {
    var block = data.schedule[DAYS[d]];
    ["ayush", "simran"].forEach(function (p) {
      (block[p] || []).forEach(function (e) {
        e.activity = renameStr_(e.activity, map);
        e.details = renameStr_(e.details, map);
        e.notes = renameStr_(e.notes, map);
      });
    });
  }
  (data.gym || []).forEach(function (g) {
    g.focusAyush = renameStr_(g.focusAyush, map);
    g.focusSimran = renameStr_(g.focusSimran, map);
  });
  (data.principles || []).forEach(function (x) {
    x.topic = renameStr_(x.topic, map);
    x.guideline = renameStr_(x.guideline, map);
  });
  return data;
}

  module.exports = { WEEKDAY_DAYTYPE, dayTypeForWeekday, nowNext, PROTEIN_TARGET, proteinTotal, calorieTotal, applyRename };

const { getSession, setSession, clearSession, login } = require("../../health/js/api.js");

describe("session", () => {
  beforeEach(() => { for (const k in store) delete store[k]; });
  it("round-trips and clears", () => {
    expect(getSession()).toBeNull();
    setSession({ token: "T", person: "ayush" });
    expect(getSession()).toEqual({ token: "T", person: "ayush" });
    clearSession();
    expect(getSession()).toBeNull();
  });
  it("returns null on corrupt session", () => {
    store["health.session"] = "{bad";
    expect(getSession()).toBeNull();
  });
});

describe("login", () => {
  it("posts text/plain with action:login and returns the parsed result", async () => {
    let captured = null;
    global.fetch = async (url, opts) => { captured = { url, opts }; return { ok: true, json: async () => ({ ok: true, token: "T", person: "simran" }) }; };
    const r = await login("saanu", "pw");
    expect(captured.url).toBe("https://exec.test/x");
    expect(captured.opts.headers["Content-Type"]).toBe("text/plain");
    expect(JSON.parse(captured.opts.body)).toEqual({ action: "login", username: "saanu", password: "pw" });
    expect(r.token).toBe("T");
  });
  it("returns {ok:false} when the network fails", async () => {
    global.fetch = async () => { throw new Error("offline"); };
    expect(await login("x", "y")).toEqual({ ok: false, error: "network" });
  });
});

describe("fetchSchedule uses the session token", () => {
  beforeEach(() => { for (const k in store) delete store[k]; });
  it("sends the session token, not CONFIG", async () => {
    setSession({ token: "SESS" });
    let url = null;
    global.fetch = async (u) => { url = u; return { ok: true, json: async () => ({ schedule: {} }) }; };
    await fetchSchedule();
    expect(url).toContain("token=SESS");
  });
});

var SESSION_KEY = "health.session";

function getSession() {
  try { var raw = localStorage.getItem(SESSION_KEY); return raw ? JSON.parse(raw) : null; }
  catch (e) { return null; }
}
function setSession(s) { try { localStorage.setItem(SESSION_KEY, JSON.stringify(s)); } catch (e) {} }
function clearSession() { try { localStorage.removeItem(SESSION_KEY); } catch (e) {} }

function sessionToken_() { var s = getSession(); return s && s.token ? s.token : ""; }

function login(username, password) {
  return fetch(CONFIG.EXEC_URL, {
    method: "POST",
    headers: { "Content-Type": "text/plain" },
    body: JSON.stringify({ action: "login", username: username, password: password })
  })
    .then(function (r) { return r.json(); })
    .catch(function () { return { ok: false, error: "network" }; });
}

  module.exports = { cacheGet, cacheSet, fetchSchedule, fetchLog, postCheckoff, getSession, setSession, clearSession, login };

// Only the backend URL is public. The token + names are issued by login.
window.CONFIG = {
  EXEC_URL: "https://script.google.com/macros/s/AKfycbxfTeey06yZCJ3I2xbj1YxkdOAqq6g49ZxCTvBAilNc349qWcpsNz6PQW3XnpoAJl2N/exec"
};

  // Identity comes from the login session. "You" = the logged-in person.
  function applySession(session) {
    state.me = session.person;
    state.person = session.person;
    state.name = session.name || "";
    state.rename = session.rename || {};
    var people = session.people || {};
    var other = session.person === "ayush" ? "simran" : "ayush";
    CONFIG.PERSON_LABELS = {};
    CONFIG.PERSON_LABELS[session.person] = "You";
    CONFIG.PERSON_LABELS[other] = people[other] || other;
    document.getElementById("personSwitch").innerHTML =
      '<button data-person="' + session.person + '" class="on">You</button>' +
      '<button data-person="' + other + '">' + esc(people[other] || other) + '</button>' +
      '<button data-person="both">Both</button>';
  }

  function logout() { clearSession(); location.reload(); }

  function renderLogin() {
    var ov = el("div", "overlay");
    ov.innerHTML = '<div class="picker"><h2>Sign in</h2>' +
      '<input id="lgUser" placeholder="Username" autocapitalize="none" autocomplete="username">' +
      '<input id="lgPass" type="password" placeholder="Password" autocomplete="current-password">' +
      '<div class="err" id="lgErr"></div>' +
      '<button id="lgGo">Log in</button></div>';
    document.body.appendChild(ov);
    function submit() {
      var u = ov.querySelector("#lgUser").value.trim();
      var p = ov.querySelector("#lgPass").value;
      ov.querySelector("#lgErr").textContent = "";
      login(u, p).then(function (r) {
        if (r && r.ok) {
          setSession(r);
          if (ov.parentNode) ov.parentNode.removeChild(ov);
          applySession(r); loadData();
        } else if (r && r.error === "network") {
          ov.querySelector("#lgErr").textContent = "Can’t reach server — check connection";
        } else {
          ov.querySelector("#lgErr").textContent = "Invalid username or password";
        }
      });
    }
    ov.querySelector("#lgGo").addEventListener("click", submit);
    ov.querySelector("#lgPass").addEventListener("keydown", function (e) { if (e.key === "Enter") submit(); });
  }

  function boot() {
    wire();
    var session = getSession();
    if (session && session.token) { applySession(session); loadData(); }
    else renderLogin();
  }

  function loadData() {
    fetchSchedule().then(function (res) {
      if (res.data && res.data.error === "unauthorized") { clearSession(); location.reload(); return; }
      if (!res.data || !res.data.schedule) { showBanner("No data — check connection"); return; }
      applyRename(res.data, state.rename || {});
      state.schedule = res.data.schedule; state.gym = res.data.gym || []; state.principles = res.data.principles || [];
      if (res.stale) showBanner("Showing saved copy (offline)");
      return fetchLog(todayISO()).then(function (rows) {
        rows.forEach(function (r) { if (r.done) state.log[r.itemId] = true; else delete state.log[r.itemId]; });
        renderActiveTab();
      });
    });
  }

    var who = el("div", "card");
    who.innerHTML = '<div class="det">Signed in as <b>' + esc(state.name || "—") + '</b>. ' +
      '<a href="#" id="logout" style="color:var(--accent)">Log out</a></div>';
    who.querySelector("#logout").addEventListener("click", function (e) { e.preventDefault(); logout(); });
    panel.appendChild(who);