{% extends "base.html" %}
{% block title %}Kahala — Jamgraf{% endblock %}
{% block content %}
  <div class="article-head"><h1>Kahala</h1></div>

  {% if ok %}<div class="banner ok">{{ ok }}</div>{% endif %}
  {% if error %}<div class="banner err">{{ error }}</div>{% endif %}

  <p class="muted">Kahala is the shared, server-side half of the same wiki. A
    local wiki can be linked to one there, then pushed up or pulled down. Only
    content travels — pages, their hierarchy, elements, templates and images.
    Search indexes are rebuilt on arrival rather than sent.</p>

  {# --- signing in ---------------------------------------------------- #}
  <section class="settings" id="kahala-account">
    <h2>Account</h2>
    {% if not status.secure_store %}
      <p class="banner err">{{ status.reason }}</p>
      <p class="muted note">Jamgraf will not keep a sign-in token in a plain
        file, so signing in is switched off here rather than done less safely.</p>
    {% elif not status.can_sign_in %}
      <p class="banner err">{{ status.reason }}</p>
    {% elif status.signed_in %}
      <p>Signed in to <code>{{ status.issuer }}</code>. The token is kept in your
        Keychain, never in a wiki file, so it is not included when you save or
        share a wiki.</p>
      <p class="muted note">One sign-in per install, not per wiki: every linked
        wiki uses this identity. If you need a Kahala on a different sign-in
        server, sign out and set <code>kahala_issuer</code> in
        <code>app_config.json</code> — a proper per-link setting is
        <a href="https://github.com/VerinFast/jamgraf/issues/95">tracked</a>.</p>
      <form method="post" action="/kahala/signout">
        <input type="hidden" name="wiki" value="{{ subject }}">
        <button class="btn" type="submit">Sign out</button>
      </form>
    {% else %}
      <p>You aren’t signed in to <code>{{ status.issuer }}</code> yet.</p>
      <a class="btn primary" id="kahala-signin"
         href="/kahala/signin?wiki={{ subject }}">Sign in to Kahala</a>
      <span class="muted" id="kahala-waiting" hidden>Waiting for the browser…</span>
      <p class="muted note">This opens Kahala’s own sign-in page in your web
        browser — not inside Jamgraf — so you get your usual session, your
        password manager and whatever second factor your organisation uses.
        Jamgraf never sees your password.</p>

      <script>
      (function () {
        var link = document.getElementById('kahala-signin');
        var waiting = document.getElementById('kahala-waiting');
        if (!link || !window.JAMGRAF_DESKTOP) return;   // a browser can just follow it

        // In the packaged app, following the link would navigate THIS window to
        // Keycloak — an embedded user-agent, which RFC 8252 §8.12 says a native
        // app must not use for OAuth. Hand the URL to the system browser
        // instead; the code still comes back to our own loopback port.
        link.addEventListener('click', function (e) {
          e.preventDefault();
          fetch(link.getAttribute('href') + '&shell=desktop')
            .then(function (r) { return r.json(); })
            .then(function (d) {
              if (!d.ok) { alert(d.error); return; }
              if (window.pywebview && window.pywebview.api &&
                  window.pywebview.api.open_url) {
                window.pywebview.api.open_url(d.url);
              } else {
                window.open(d.url, '_blank');
              }
              link.hidden = true;
              waiting.hidden = false;
              poll();
            })
            .catch(function () { alert('Could not start the sign-in.'); });
        });

        // The sign-in finishes in another application, so this window gets no
        // event. Ask, rather than leaving a stale "not signed in" on screen
        // until someone thinks to reload. Gives up after five minutes so a
        // window left open overnight is not polling all night.
        function poll() {
          var until = Date.now() + 5 * 60 * 1000;
          var timer = setInterval(function () {
            if (Date.now() > until) { clearInterval(timer); waiting.textContent =
              'Still not signed in — reload this page once you have finished.'; return; }
            fetch('/kahala/state?wiki={{ subject }}')
              .then(function (r) { return r.json(); })
              .then(function (d) { if (d.signed_in) { clearInterval(timer); resume(); } })
              .catch(function () { /* the app may be restarting; keep asking */ });
          }, 2000);
        }

        // Reload WITHOUT the flash parameters. `location.reload()` re-requests
        // the current URL, which still carries the `?error=` that sent the
        // person to the sign-in in the first place -- so the banner the sign-in
        // just resolved comes straight back, over a pane that now correctly
        // says they are signed in. `replace` rather than `assign` so Back does
        // not resurrect the stale banner either.
        function resume() {
          var url = new URL(window.location.href);
          url.searchParams.delete('error');
          url.searchParams.delete('ok');
          window.location.replace(url.toString());
        }
      })();
      </script>
    {% endif %}
  </section>

  {# --- this wiki's link ---------------------------------------------- #}
  <section class="settings" id="kahala-link">
    <h2>This wiki <span class="muted">({{ subject }})</span></h2>
    {% if status.linked %}
      <p>Linked to <strong>{{ status.remote }}</strong> on
        <code>{{ status.base_url }}</code>.</p>

      <div class="kahala-actions">
        <form method="post" action="/kahala/push" style="display:inline">
          <input type="hidden" name="wiki" value="{{ subject }}">
          <button class="btn primary" type="submit"
                  {{ 'disabled' if not status.signed_in }}>Push to Kahala</button>
        </form>
        <form method="post" action="/kahala/pull" style="display:inline">
          <input type="hidden" name="wiki" value="{{ subject }}">
          <button class="btn" type="submit"
                  {{ 'disabled' if not status.signed_in }}>Pull from Kahala</button>
        </form>
        <form method="post" action="/kahala/unlink" style="display:inline">
          <input type="hidden" name="wiki" value="{{ subject }}">
          <button class="btn" type="submit">Forget this link</button>
        </form>
        {# Opens in the browser where you are already signed in to Kahala.
           data-open-url is the app's existing "use the system browser" hook. #}
        <a class="btn" href="{{ status.manage_url }}"
           data-open-url="{{ status.manage_url }}"
           target="_blank" rel="noopener noreferrer">Open Kahala…</a>
      </div>

      <details class="muted note">
        <summary>Transfer the whole wiki instead</summary>
        <p>Push and pull normally send only what changed, which is a few
          kilobytes rather than the whole wiki. These send everything — slower,
          and worth reaching for if something looks out of step.</p>
        <form method="post" action="/kahala/push" style="display:inline">
          <input type="hidden" name="wiki" value="{{ subject }}">
          <input type="hidden" name="full" value="1">
          <button class="btn" type="submit"
                  {{ 'disabled' if not status.signed_in }}>Push everything</button>
        </form>
        <form method="post" action="/kahala/pull" style="display:inline">
          <input type="hidden" name="wiki" value="{{ subject }}">
          <input type="hidden" name="full" value="1">
          <button class="btn" type="submit"
                  {{ 'disabled' if not status.signed_in }}>Pull everything</button>
        </form>
      </details>

      {% if not status.signed_in %}
        <p class="muted note">Push and pull need you to be signed in.</p>
      {% endif %}

      {# The one thing people misread about a snapshot round-trip. Say it on the
         page, next to the buttons, not only in the docs. #}
      <p class="muted note"><strong>Both directions merge; neither deletes.</strong>
        A push adds and updates pages on Kahala and removes nothing there; a pull
        does the same here. So a page you deleted locally is still on Kahala, and
        a pull will bring it back.</p>
      <p class="muted note">Custom elements, templates and images travel with
        the pages, so a page never arrives referring to a definition that
        didn’t.</p>
      <p class="muted note"><strong>A push can’t create the wiki on Kahala.</strong>
        It has to exist there first — <em>Open Kahala…</em> goes to the page where
        you make one. Jamgraf can’t do it for you: creating a wiki there is a
        browser form tied to your Kahala session, and the token Jamgraf holds is
        only accepted on Kahala’s API.</p>
    {% else %}
      <p>This wiki isn’t linked yet.</p>
      <form method="post" action="/kahala/link" class="addmodel">
        <input type="hidden" name="wiki" value="{{ subject }}">
        <label>Kahala address
          <input type="url" name="base_url" required
                 value="{{ suggest.base_url }}"
                 placeholder="https://kahala.example.com"></label>
        <label>Wiki name there
          <input type="text" name="remote" required
                 value="{{ suggest.remote }}" placeholder="{{ subject }}"></label>
        <button class="btn primary" type="submit">Link</button>
      </form>
      <p class="muted note">Linking only records the address here on this
        machine. It is never written into the wiki itself, so it can’t travel to
        someone you share the wiki with.</p>
      <p class="muted note"><strong>The wiki has to already exist on Kahala.</strong>
        Create it there first (its <em>Wikis</em> page), then put the name it ends
        up with above — Kahala turns the name you type into the slug, so they can
        differ. Linking to something that isn’t there yet looks identical to
        linking to another tenant’s wiki, and the push will say so.</p>
    {% endif %}
  </section>

  {# --- clone --------------------------------------------------------- #}
  <section class="settings" id="kahala-clone">
    <h2>Clone a wiki from Kahala</h2>
    <form method="post" action="/kahala/clone" class="addmodel">
      <label>Kahala address
        <input type="url" name="base_url" required
               value="{{ suggest.base_url }}"
               placeholder="https://kahala.example.com"></label>
      <label>Wiki name there
        <input type="text" name="remote" required placeholder="beaconlight"></label>
      <label>Call it <span class="muted">(optional)</span>
        <input type="text" name="name" placeholder="same name"></label>
      <button class="btn primary" type="submit"
              {{ 'disabled' if not status.signed_in }}>Clone</button>
    </form>
    <p class="muted note">A clone always creates a <em>new</em> local wiki, so it
      can never write over one you already have.</p>
  </section>

  {# --- other linked wikis -------------------------------------------- #}
  {% set others = links.items() | selectattr('1') | list %}
  {% if others %}
  <section class="settings" id="kahala-all">
    <h2>All linked wikis</h2>
    <table class="modeltable"><tbody>
      {% for slug, lk in others %}
        <tr>
          <td><strong>{{ slug }}</strong>
            <div class="muted wikistats">{{ lk.remote }} on {{ lk.base_url }}</div></td>
          <td><a class="btn" href="/kahala?wiki={{ slug }}">Open</a></td>
        </tr>
      {% endfor %}
    </tbody></table>
  </section>
  {% endif %}
{% endblock %}