var supportsES6 = (function() {
  try {
    new Function("(a = 0) => a"); // Not so evil eval?
    return true;
  }
  catch (err) {
    console.log("No ES6");
    return false;
  }
}());


// button click animation classes
var btn_clicked = (function () {

  "use strict";
  if (!supportsES6) {return}

  const buttons = document.querySelectorAll("button");
  for (const btn of buttons) {

    btn.addEventListener("click", _ => {

      btn.addEventListener("animationend", _ => {
        btn.classList.remove("-js-clicked");
      }, {once: true});

      btn.classList.add("-js-clicked");
    });

  }
}());


var useSessionStorage = (function () {
  try {
    var mod = new Date().valueOf() + "";
		localStorage.setItem(mod, mod);
		localStorage.removeItem(mod);
		return true;
  } catch (e) {
    console.log("No sessionStorage");
    return false;
  }
}());

var hasWebAudio = (function () {
  return window.AudioContext ? true : false;
}());


// Web Audio API - Fetch, store, play (volume, loop), stop - v1.1 MJF @ websemantics.uk
var Audio = (function () {

  "use strict";
  if (!supportsES6) {return}
  if (!hasWebAudio) {return}

  // Cannot be set prior to a user action due to Chrome's rule:
  // "The AudioContext was not allowed to start. It must be resumed (or created) after a user gesture on the page."
  let audioContext;

  const instantiateAudioContext = _ => {
    if (audioContext) return;
    audioContext = new AudioContext();
  };

  // // Test AudioContext availability
  // if (!window.AudioContext) {
  //   if (!window.webkitAudioContext) {
  //     console.log("Web Audio API is not supported");
  //     return;
  //   }
  //   window.AudioContext = window.webkitAudioContext;
  // }

  let TO; // a setTimeout used to stop a faded out sound. 

  // base64-arraybuffer - https://github.com/niklasvh/base64-arraybuffer - 2012 Niklas von Hertzen - Licensed under the MIT license.
  const b64_buffer = (function(){

    // Converts arraybuffer to base64 and vice-versa

    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    // Use a lookup table to find the index.
    const lookup = new Uint8Array(256);
    for (let i = 0; i < chars.length; i++) {
      lookup[chars.charCodeAt(i)] = i;
    }

    const encode = (arraybuffer) => {
      const bytes = new Uint8Array(arraybuffer);
      const len = bytes.length;
      let base64 = "";

      for (let i = 0; i < len; i += 3) {
        base64 += chars[bytes[i] >> 2];
        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
        base64 += chars[bytes[i + 2] & 63];
      }

      // Add padding
      if ((len % 3) === 2) {
        base64 = base64.substring(0, base64.length - 1) + "=";
      } else if (len % 3 === 1) {
        base64 = base64.substring(0, base64.length - 2) + "==";
      }

      return base64;
    };

    const decode =  (base64) => {
      const len = base64.length;
      let bufferLength = base64.length * 0.75;

      // Remove padding
      if (!base64[base64.length - 1] === "=") {
        bufferLength--;
        if (base64[base64.length - 2] === "=") {
          bufferLength--;
        }
      }

      const arraybuffer = new ArrayBuffer(bufferLength);
      const bytes = new Uint8Array(arraybuffer);

      let p = 0;

      for (let i = 0; i < len; i += 4) {
        const encoded1 = lookup[base64.charCodeAt(i)];
        const encoded2 = lookup[base64.charCodeAt(i + 1)];
        const encoded3 = lookup[base64.charCodeAt(i + 2)];
        const encoded4 = lookup[base64.charCodeAt(i + 3)];

        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
      }

      return arraybuffer;
    };

    return {
      encode: encode,
      decode: decode
    }

  }());



  function _populateAudioContext(track, buffer) {

    if (!track.audioSource) return;
    audioContext.decodeAudioData(buffer, decodedData => {
      track.audioSource.buffer = decodedData;
    });
  }

  function _fetchAudio(track) {

    fetch(track.path)
    .then(response => response.arrayBuffer())
    .then(buffer => {

      if (useSessionStorage) {

        // Convert to Base64 and stuff into sessionStorage for reuse.
        // No check made for available space! Keep samples small, or do a check.
        sessionStorage.setItem(track.path, b64_buffer.encode(buffer));
        console.log("Fetched & stored in sessionStorage: ", track.path);
      }

      return buffer;

    })
    .then(buffer => _populateAudioContext(track, buffer))
    .catch(err => console.log("Fetch " + err,  track.path));
  }

  function preloadAudio(track) {

    // instantiateAudioContext();

    if (useSessionStorage && !(track.path in sessionStorage)) {
      _fetchAudio(track);
    }
  }

  function stopAudio(track) {

    instantiateAudioContext();

    if (track.audioSource) {
      clearTimeout(TO);

      // Using disconnect() as replacement for stop() to try to support Safari
      // https://stackoverflow.com/questions/32563298/audiocontext-issue-with-safari
      // track.audioSource.stop();
      track.audioSource.disconnect();

    }
  }

  function fadeOutAudio(track) {

    instantiateAudioContext();

    if (track.canFade && track.fadeOut && track.fadeOut > 0) {

      track.gainNode.gain.setValueAtTime(track.volume, audioContext.currentTime);
      track.gainNode.gain.linearRampToValueAtTime(0, audioContext.currentTime + track.fadeOut);

      track.canFade = false;

      TO = setTimeout(() => {
        stopAudio(track);
      }, track.fadeOut * 1000);

    } else {
      stopAudio(track);
    }
  }

  function _buildTrack(track) {
    track.audioSource = audioContext.createBufferSource();
    track.audioSource.ended = function () {
      // stopAudio(track);
      console.log("Ended: ", track.path);
    };
    track.gainNode = audioContext.createGain();
    track.audioSource.connect(track.gainNode);
    track.gainNode.connect(audioContext.destination);
    track.canFade = true; // used to prevent fadeOut firing twice
  }

  function _getAudio(track) {

    if (useSessionStorage) {

      const b64 = sessionStorage.getItem(track.path);
      if (b64 !== null) {
        const buffer =  b64_buffer.decode(b64);
        console.log("From sessionStorage: ", track.path);
        _populateAudioContext(track, buffer);
        return;
      }
    }

    _fetchAudio(track);
  }

  function _setGain(track) {

    track.volume = (track.volume >= 0) ? track.volume : 0.5;

    if (track.fadeIn && track.fadeIn > 0) {

      track.gainNode.gain.setValueAtTime(0, audioContext.currentTime);
      track.gainNode.gain.linearRampToValueAtTime(track.volume, audioContext.currentTime + track.fadeIn);

    } else {
      track.gainNode.gain.value = track.volume;
    }
  }

  function playAudio(track) {

    instantiateAudioContext();

    stopAudio(track);
    _buildTrack(track);
    _getAudio(track);
    _setGain(track);
    track.audioSource.loop = (track.loop && track.loop == true) || false;
    track.audioSource.start(); // Possibly add sprite positions?
    // console.log("playing: ", track.audioSource);
  }


  // Expose functions:
  return {
    load : preloadAudio,
    play : playAudio,
    stop : stopAudio,
    fade : fadeOutAudio
  }

}());

// Note: Using cross-domain samples requires setting .htaccess to:
// Header set Access-Control-Allow-Origin "*"

var noise = {
  path: "https://websemantics.uk/audio/noise.6.wav",
  volume: 0.2, // 0 - 1
  loop: true,
  fadeIn: 0.5, // time in seconds
  fadeOut: 1.3 // time in seconds
}

// USAGES:

// Predefine track in JS
/*
var track1 = {
  path : "https://websemantics.uk/audio/speak-and-spell/alphabet/0.mp3"
};
if (supportsES6) {
  // requires user gesture
  Audio.play(track1);
}
*/

// Define track in play call, which may be reused
/*
if (supportsES6) {
  // requires user gesture
  Audio.play(track2 = {
    path : "https://websemantics.uk/audio/speak-and-spell/alphabet/1.mp3",
    volume : 0.125
  });
  setTimeout(() => {
    // requires user gesture
    Audio.play(track2);
  },1000);
}
*/

// Define track in play call, not reuseable
/*
if (supportsES6) {
  // requires user gesture
  Audio.play({
    path : "https://websemantics.uk/audio/speak-and-spell/alphabet/2.mp3",
    volume : 0.125,
    loop : false
  });
}
*/

// Predefine looping track

// var noise = {
//   path : "https://websemantics.uk/audio/noise.5.mp3",
//   volume : 0.125,
//   loop : true
// };


// Define track and pre-load audio to play later
var track4 = {
  path : "https://websemantics.uk/audio/speak-and-spell/alphabet/4.mp3",
  volume : 0.125
}
if (supportsES6) {
  // requires user gesture
  // Audio.load(track4);
  // Audio.play(track4);
}


// Speak & Spell audio samples - http://www.maximporges.com/2011/10/08/speak-and-spell-samples/

var alphabet = {
  zero : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/0.mp3",
    volume: 0.125
  },
  one : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/1.mp3",
    volume: 0.125
  },
  two : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/2.mp3",
    volume: 0.125
  },
  three : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/3.mp3",
    volume: 0.125
  },
  four : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/4.mp3",
    volume: 0.125
  },
  five : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/5.mp3",
    volume: 0.125
  },
  six : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/6.mp3",
    volume: 0.125
  },
  seven : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/7.mp3",
    volume: 0.125
  },
  eight : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/8.mp3",
    volume: 0.125
  },
  nine : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/9.mp3",
    volume: 0.125
  },
  ten : {
    path: "https://websemantics.uk/audio/speak-and-spell/alphabet/10.mp3",
    volume: 0.125
  }
}