import { Capacitor } from "@capacitor/core";
import { POST_HOURS } from "../constants";
import { Postbode } from "./plugin";
import { log, gelogd } from "./log";

/*
 * Bericht als er post ligt — de JS-kant van de eigen Android-plugin (android/.../Postbode.java).
 *
 * De hele afspraak in één alinea: het toestel kijkt zelf, op een paar vaste momenten per dag die de
 * gebruiker instelt, of er post ligt, en zet daar een melding bij. Er wordt niets naar het toestel
 * gestuurd, dus er is ook niemand die daarvoor moet weten dat jij post krijgt: geen Firebase, geen
 * token bij Google, geen bericht dat onderweg langs een derde komt. De prijs is dat Android het
 * moment mag uitstellen — daarom "rond", en daarom is dit niet te gebruiken voor iets wat meteen
 * moet aankomen. Om diezelfde reden zijn de momenten hele uren en geen tijdstippen op de minuut.
 *
 * In de browser is er geen plugin om mee te praten en geeft alles hier `null` terug. Het scherm bij
 * Mijn profiel wordt daar gewoon getoond — de browser is de ontwikkelomgeving en er draait geen
 * webversie van de app, dus er is niemand om iets voor te verbergen; wel valt er dan niets te
 * schakelen.
 */
const API_URL = (import.meta.env.VITE_API_URL ?? "").replace(/\/$/, "");

/*
 * Alleen native, en alleen met een absolute API-URL: de achtergrondcontrole draait buiten de
 * webview om en heeft niets aan een pad dat door de dev-proxy heen moet. De plugin zelf komt uit
 * lib/plugin.js — het logboek gebruikt hem ook, en die twee horen niet van elkaar af te hangen.
 */
const bruikbaar = Postbode !== null && API_URL !== "";

/* Wat de app hier van zichzelf weet; staat één keer in het log, zodat de rest te plaatsen is */
log("postbode:", `bruikbaar=${bruikbaar}`, `platform=${Capacitor.getPlatform()}`, `apiUrl=${API_URL || "(leeg)"}`);

/*
 * Elke aanroep is omhuld: een toestel met een oudere app-versie kent de plugin niet, en dat mag
 * hooguit betekenen dat de instelling er niet is — nooit dat Mijn profiel wit blijft.
 *
 * Wat de aanroep teruggaf of waarop hij afketste gaat naar het log (zie lib/log.js).
 *
 * Een afwijzing komt terug als `{ fout: { code, message } }` en niet als uitzondering: de meeste
 * aanroepers hier zijn schermen die iets willen tonen, geen code die iets wil vangen. Vroeger werd
 * hij weggeslikt, en dan was een mislukking niet te onderscheiden van een knop die niets doet —
 * het vinkje sprong terug en verder gebeurde er niets.
 *
 * `stil` is voor de twee aanroepen waar niemand op wacht: de sessie volgen en kijken of de app door
 * een melding opkwam. Die horen bij een mislukking gewoon "niets" te zeggen, want er is geen scherm
 * dat erop staat te wachten en hun antwoord heeft een andere vorm. In het log staat het wel.
 */
const veilig = async (naam, invoer, fn, { terug = null, stil = false } = {}) => {
  if (!bruikbaar) {
    log(`- Postbode.${naam}: overgeslagen`, `plugin=${Postbode !== null}`, `apiUrl=${API_URL !== ""}`);
    return terug;
  }
  try {
    return await gelogd(`Postbode.${naam}`, invoer, fn);
  } catch (e) {
    return stil ? terug : { fout: { code: e?.code ?? null, message: e?.message ?? String(e) } };
  }
};

/*
 * { enabled, allowed, hours } — `allowed` is false als meldingen in de systeeminstellingen uit
 * staan, `hours` zijn de bezorgmomenten als hele uren, oplopend.
 */
export const postState = () => veilig("state", null, () => Postbode.state());

/*
 * Aanzetten. Eerst de toestemming (Android 13+ vraagt hem, daaronder staat hij al), dan pas de
 * bezorging — anders staat de schakelaar aan terwijl er nooit iets verschijnt. `since` is de
 * hoogste brief die de app al kent: de eerste melding gaat over post die dáárna komt, en niet over
 * wat er nu al in het postvak ligt.
 */
export const enablePost = ({ token, since = "0", hours = POST_HOURS.filter((u) => u !== null) }) =>
  veilig("enable", { apiUrl: API_URL, token, hours, since }, async () => {
    const perm = await gelogd("Postbode.requestPermissions", null, () => Postbode.requestPermissions());
    if (perm?.meldingen !== "granted") return { enabled: false, allowed: false, denied: true };
    return await Postbode.enable({ apiUrl: API_URL, token, hours, since });
  });

/*
 * De bezorgmomenten verzetten. Mag ook terwijl de melding uit staat: dan blijft de keuze bewaard
 * tot hij weer aangaat. Staat hij aan, dan geldt het nieuwe moment meteen.
 */
export const setPostHours = (hours) => veilig("hours", { hours }, () => Postbode.hours({ hours }));

export const disablePost = () => veilig("disable", null, () => Postbode.disable());

/*
 * Het sessietoken doorgeven aan de bezorging: bij inloggen het nieuwe, bij uitloggen niets (en dan
 * stopt het kijken ook). De instelling zelf blijft staan tot iemand hem uitzet.
 */
export const syncPostSession = (token) =>
  veilig("session", { token: token ?? "", apiUrl: API_URL }, () =>
    Postbode.session({ token: token ?? "", apiUrl: API_URL }), { stil: true });

/* Kwam de app op door een tik op de melding? Geeft "postvak" of null, en maar één keer */
export const takePostOpen = () =>
  veilig("takeOpen", null, async () => (await Postbode.takeOpen())?.open ?? null, { stil: true });