/* copy.js: a snippet's Copy button. First-party, dependency-free,
   CSP-clean and optional: delete it and its <script> tag and the code
   is still on the page to select by hand, because the button is hidden
   in the markup and only this file shows it. It is app-owned from the
   moment it is scaffolded.

   What it reads, in either spelling:
     [rst-snippet], .rst-snippet                  the box
     the box's <code>                             what is copied, as text
     [rst-snippet-copy], .rst-snippet__copy       the button, hidden
     [rst-snippet-status], .rst-snippet__status   a role="status" line
   On the button, both optional:
     data-rst-copy-done     the label, and the status, once it is copied
     data-rst-copy-failed   the status when the copy fails
   Each is looked up on the attribute, then in the page's table
   (self.fiestaStrings[lang], which i18n/<lang>.js fills), then the
   English written here, as select.js does.

   Where the browser has no clipboard API (an old engine, a page that is
   not a secure context) the file stops before it listens for anything
   and the buttons stay hidden: a button that does nothing is worse than
   no button.

   Each click is a request with a number, and only a button's latest
   request may change anything. A click puts the label back and empties
   the status at once, and cancels the button's two timers, before it
   writes. A write that worked shows the done string on the label for
   two seconds; one that failed (a rejected promise or a throw, a denied
   permission among them) leaves the label alone and selects the code,
   so it can be copied by hand. Either way the status gets its message
   100 ms after the write settles, never at once: a live region that is
   written the text it already holds has not changed, and a screen
   reader says nothing the second time. Clicks closer together than
   that, or a click while an earlier write is still pending, end in one
   announcement, the latest request's, and a request that settles after
   a newer one never writes at all. */
(function () {
  "use strict";

  if (window.fiestaCopy) return;
  window.fiestaCopy = true;

  // No clipboard API, no button: return before listening for anything,
  // so the buttons keep the hidden attribute the markup gave them.
  if (typeof navigator.clipboard?.writeText !== "function") return;

  var BOX = "[rst-snippet],.rst-snippet";
  var BUTTON = "[rst-snippet-copy],.rst-snippet__copy";
  var STATUS = "[rst-snippet-status],.rst-snippet__status";
  // Long enough to read the done string, short enough that the button
  // is the button again before anyone reaches for it twice.
  var SHOWN_MS = 2000;
  // The status is emptied at the click and written this long after the
  // write settles, so two messages in a row are two changes.
  var SPEAK_MS = 100;

  // The strings: the attribute, then the page's table, then the
  // fallback (the header says why). select.js carries the same two
  // functions, so this file stays one script tag;
  // check/scripts_test.go holds the copies identical.

  // The table for a tag: an exact match whatever its case, else the
  // first in its primary language (pt-BR reads pt-PT), else null.
  function fiestaPickLang(tag, registry) {
    var want = String(tag || "").toLowerCase();
    if (!want) return null;
    var keys = Object.keys(registry || {}), i;
    for (i = 0; i < keys.length; i++) {
      if (keys[i].toLowerCase() === want) return keys[i];
    }
    var primary = want.split("-")[0];
    for (i = 0; i < keys.length; i++) {
      if (keys[i].toLowerCase().split("-")[0] === primary) return keys[i];
    }
    return null;
  }

  function fiestaWord(el, key, fallback) {
    var v = el.getAttribute("data-rst-" + key);
    if (v !== null && v !== "") return v;
    var registry = (typeof self !== "undefined" && self.fiestaStrings) || {};
    var lang = fiestaPickLang(document.documentElement.lang, registry);
    var table = lang ? registry[lang] : null;
    return table && table[key] !== undefined && table[key] !== "" ? table[key] : fallback;
  }

  // Per button: the label it was given, the number of its latest
  // request, and its two timers. A WeakMap, so a button the page
  // removes takes its state with it.
  var buttons = new WeakMap();
  function state(button) {
    var s = buttons.get(button);
    if (!s) {
      s = { label: button.textContent, latest: 0, reset: 0, speak: 0 };
      buttons.set(button, s);
    }
    return s;
  }

  // Selecting the code is what a failed copy leaves the reader with:
  // the text is chosen, and their own copy takes it.
  function select(code) {
    var range = document.createRange(), selection = window.getSelection();
    range.selectNodeContents(code);
    selection.removeAllRanges();
    selection.addRange(range);
  }

  // The message goes in SPEAK_MS after a settlement, and only if the
  // request is still the button's latest when the timer fires: a click
  // in between has cancelled the timer already, and the number is the
  // check that holds if a callback runs anyway.
  function say(s, n, status, text) {
    if (!status) return;
    s.speak = setTimeout(function () {
      if (n === s.latest) status.textContent = text;
    }, SPEAK_MS);
  }

  function copy(button, box, code) {
    var s = state(button), n = ++s.latest, status = box.querySelector(STATUS), write;
    // Back to the start before this request writes, so nothing an
    // earlier one left survives it: not its label, not its message,
    // not a timer it has yet to fire.
    clearTimeout(s.reset);
    clearTimeout(s.speak);
    button.textContent = s.label;
    if (status) status.textContent = "";
    // A throw (a browser that refuses outright) fails like a rejection.
    try {
      write = Promise.resolve(navigator.clipboard.writeText(code.textContent));
    } catch (err) {
      write = Promise.reject(err);
    }
    write.then(function () {
      if (n !== s.latest) return;
      var done = fiestaWord(button, "copy-done", "Copied");
      button.textContent = done;
      s.reset = setTimeout(function () {
        if (n === s.latest) button.textContent = s.label;
      }, SHOWN_MS);
      say(s, n, status, done);
    }, function () {
      if (n !== s.latest) return;
      select(code);
      say(s, n, status, fiestaWord(button, "copy-failed", "Copy failed. Select the code and copy it yourself."));
    });
  }

  // Shown once the document is parsed, each remembering its label
  // first, while it still reads as the markup wrote it.
  function show() {
    document.querySelectorAll(BUTTON).forEach(function (button) {
      state(button);
      button.hidden = false;
    });
  }
  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", show);
  } else {
    show();
  }

  // One listener for every snippet on the page, however many.
  document.addEventListener("click", function (e) {
    var button = e.target && e.target.closest ? e.target.closest(BUTTON) : null;
    var box = button && button.closest(BOX);
    var code = box && box.querySelector("code");
    if (code) copy(button, box, code);
  });
})();