// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/**
 * @fileoverview
 * This is a component extension that implements a text-to-speech (TTS)
 * engine powered by Google's speech synthesis API.
 *
 * This is an "event page", so it's not loaded when the API isn't being used,
 * and doesn't waste resources. When a web page or web app makes a speech
 * request and the parameters match one of the voices in this extension's
 * manifest, it makes a request to Google's API using Chrome's private key
 * and plays the resulting speech using HTML5 audio.
 */

/**
 * The main class for this extension. Adds listeners to
 * chrome.ttsEngine.onSpeak and chrome.ttsEngine.onStop and implements
 * them using Google's speech synthesis API.
 * @constructor
 */
function TtsExtension() {}

TtsExtension.prototype = {
  /**
   * The url prefix of the speech server, including static query
   * parameters that don't change.
   * @type {string}
   * @const
   * @private
   */
  SPEECH_SERVER_URL_:
      'https://www.google.com/speech-api/v2/synthesize?' +
      'enc=mpeg&client=chromium',

  /**
   * A mapping from language and gender to voice name, hardcoded for now
   * until the speech synthesis server capabilities response provides this.
   * The key of this map is of the form '<lang>-<gender>'.
   * @type {Object<string>}
   * @private
   */
  LANG_AND_GENDER_TO_VOICE_NAME_: {
    'en-gb-male': 'rjs',
    'en-gb-female': 'fis',
  },

  /**
   * The arguments passed to the onSpeak event handler for the utterance
   * that's currently being spoken. Should be null when no object is
   * pending.
   *
   * @type {?{utterance: string, options: Object, callback: Function}}
   * @private
   */
  currentUtterance_: null,

  /**
   * The HTML5 audio element we use for playing the sound served by the
   * speech server.
   * @type {HTMLAudioElement}
   * @private
   */
  audioElement_: null,

  /**
   * A mapping from voice name to language and gender, derived from the
   * manifest file.  This is used in case the speech synthesis request
   * specifies a voice name but doesn't specify a language code or gender.
   * @type {Object<{lang: string, gender: string}>}
   * @private
   */
  voiceNameToLangAndGender_: {},

  /**
   * This is the main function called to initialize this extension.
   * Initializes data structures and adds event listeners.
   */
  init: function() {
    // Get voices from manifest.
    var voices = chrome.app.getDetails().tts_engine.voices;
    for (var i = 0; i < voices.length; i++) {
      this.voiceNameToLangAndGender_[voices[i].voice_name] = {
        lang: voices[i].lang,
        gender: voices[i].gender
      };
    }

    // Initialize the audio element and event listeners on it.
    this.audioElement_ = document.createElement('audio');
    document.body.appendChild(this.audioElement_);
    this.audioElement_.addEventListener(
        'ended', this.onStop_.bind(this), false);
    this.audioElement_.addEventListener(
        'canplaythrough', this.onStart_.bind(this), false);

    // Install event listeners for the ttsEngine API.
    chrome.ttsEngine.onSpeak.addListener(this.onSpeak_.bind(this));
    chrome.ttsEngine.onStop.addListener(this.onStop_.bind(this));
    chrome.ttsEngine.onPause.addListener(this.onPause_.bind(this));
    chrome.ttsEngine.onResume.addListener(this.onResume_.bind(this));
  },

  /**
   * Handler for the chrome.ttsEngine.onSpeak interface.
   * Gets Chrome's Google API key and then uses it to generate a request
   * url for the requested speech utterance. Sets that url as the source
   * of the HTML5 audio element.
   * @param {string} utterance The text to be spoken.
   * @param {Object} options Options to control the speech, as defined
   *     in the Chrome ttsEngine extension API.
   * @private
   */
  onSpeak_: function(utterance, options, callback) {
    // Truncate the utterance if it's too long. Both Chrome's tts
    // extension api and the web speech api specify 32k as the
    // maximum limit for an utterance.
    if (utterance.length > 32768)
      utterance = utterance.substr(0, 32768);

    try {
      // First, stop any pending audio.
      this.onStop_();

      this.currentUtterance_ = {
        utterance: utterance,
        options: options,
        callback: callback
      };

      var lang = options.lang;
      var gender = options.gender;
      if (options.voiceName) {
        lang = this.voiceNameToLangAndGender_[options.voiceName].lang;
        gender = this.voiceNameToLangAndGender_[options.voiceName].gender;
      }

      if (!lang)
        lang = navigator.language;

      // Look up the specific voice name for this language and gender.
      // If it's not in the map, it doesn't matter - the language will
      // be used directly. This is only used for languages where more
      // than one gender is actually available.
      var key = lang.toLowerCase() + '-' + gender;
      var voiceName = this.LANG_AND_GENDER_TO_VOICE_NAME_[key];

      var url = this.SPEECH_SERVER_URL_;
      chrome.systemPrivate.getApiKey((function(key) {
        url += '&key=' + key;
        url += '&text=' + encodeURIComponent(utterance);
        url += '&lang=' + lang.toLowerCase();

        if (voiceName)
          url += '&name=' + voiceName;

        if (options.rate) {
          // Input rate is between 0.1 and 10.0 with a default of 1.0.
          // Output speed is between 0.0 and 1.0 with a default of 0.5.
          url += '&speed=' + (options.rate / 2.0);
        }

        if (options.pitch) {
          // Input pitch is between 0.0 and 2.0 with a default of 1.0.
          // Output pitch is between 0.0 and 1.0 with a default of 0.5.
          url += '&pitch=' + (options.pitch / 2.0);
        }

        // This begins loading the audio but does not play it.
        // When enough of the audio has loaded to begin playback,
        // the 'canplaythrough' handler will call this.onStart_,
        // which sends a start event to the ttsEngine callback and
        // then begins playing audio.
        this.audioElement_.src = url;
      }).bind(this));
    } catch (err) {
      console.error(String(err));
      callback({
        'type': 'error',
        'errorMessage': String(err)
      });
      this.currentUtterance_ = null;
    }
  },

  /**
   * Handler for the chrome.ttsEngine.onStop interface.
   * Called either when the ttsEngine API requests us to stop, or when
   * we reach the end of the audio stream. Pause the audio element to
   * silence it, and send a callback to the ttsEngine API to let it know
   * that we've completed. Note that the ttsEngine API manages callback
   * messages and will automatically replace the 'end' event with a
   * more specific callback like 'interrupted' when sending it to the
   * TTS client.
   * @private
   */
  onStop_: function() {
    if (this.currentUtterance_) {
      this.audioElement_.pause();
      this.currentUtterance_.callback({
        'type': 'end',
        'charIndex': this.currentUtterance_.utterance.length
      });
    }
    this.currentUtterance_ = null;
  },

  /**
   * Handler for the canplaythrough event on the audio element.
   * Called when the audio element has buffered enough audio to begin
   * playback. Send the 'start' event to the ttsEngine callback and
   * then begin playing the audio element.
   * @private
   */
  onStart_: function() {
    if (this.currentUtterance_) {
      if (this.currentUtterance_.options.volume !== undefined) {
        // Both APIs use the same range for volume, between 0.0 and 1.0.
        this.audioElement_.volume = this.currentUtterance_.options.volume;
      }
      this.audioElement_.play();
      this.currentUtterance_.callback({
          'type': 'start',
          'charIndex': 0
      });
    }
  },

  /**
   * Handler for the chrome.ttsEngine.onPause interface.
   * Pauses audio if we're in the middle of an utterance.
   * @private
   */
  onPause_: function() {
    if (this.currentUtterance_) {
      this.audioElement_.pause();
    }
  },

  /**
   * Handler for the chrome.ttsEngine.onPause interface.
   * Resumes audio if we're in the middle of an utterance.
   * @private
   */
  onResume_: function() {
    if (this.currentUtterance_) {
      this.audioElement_.play();
    }
  }

};

(new TtsExtension()).init();