/**
 * @file track-list.js
 */
import EventTarget from '../event-target' ;
import {isEvented} from '../mixins/evented' ;

/**
 * Fonctionnalité commune entre {@link TextTrackList}, {@link AudioTrackList}, et
 * {@link VideoTrackList}
 *
 * @extends EventTarget
 */
class TrackList extends EventTarget {
  /**
   * Créer une instance de cette classe
   *
   * @param {Track[]} tracks
   *        Une liste de pistes pour initialiser la liste.
   *
   * @abstract
   */
  constructor(tracks = []) {
    super() ;

    this.tracks_ = [] ;

    /**
     * @memberof TrackList
     * @member {number} length
     *         Le nombre actuel de `Track`s dans ce Trackist.
     * @instance
     */
    Object.defineProperty(this, 'length', {
      get() {
        return this.tracks_.length ;
      }
    }) ;

    for (let i = 0 ; i < tracks.length ; i++) {
      this.addTrack(tracks[i]) ;
    }
  }

  /**
   * Ajouter un {@link Track} à la `TrackList`
   *
   * @param {Track} track
   *        La piste audio, vidéo ou texte à ajouter à la liste.
   *
   * @fires TrackList#addtrack
   */
  addTrack(track) {
    const index = this.tracks_.length ;

    if ( !(' + index in this)) {
      Object.defineProperty(this, index, {
        get() {
          return this.tracks_[index] ;
        }
      }) ;
    }

    // Ne pas ajouter de pistes en double
    if (this.tracks_.indexOf(track) === -1) {
      this.tracks_.push(track) ;
      /**
       * Déclenché lorsqu'une piste est ajoutée à une liste de pistes.
       *
       * @event TrackList#addtrack
       * @type {EventTarget~Event}
       * @property {Track} track
       *           Une référence à la piste qui a été ajoutée.
       */
      this.trigger({
        la voie ferrée,
        type : "addtrack",
        cible : ceci
      }) ;
    }

    /**
     * Déclenché lorsqu'une étiquette de piste est modifiée.
     *
     * @event TrackList#addtrack
     * @type {EventTarget~Event}
     * @property {Track} track
     *           Une référence à la piste qui a été ajoutée.
     */
    track.labelchange_ = () => {
      this.trigger({
        la voie ferrée,
        type : "labelchange",
        cible : ceci
      }) ;
    };

    if (isEvented(track)) {
      track.addEventListener('labelchange', track.labelchange_) ;
    }
  }

  /**
   * Supprimer un {@link Track} de la `TrackList`
   *
   * @param {Track} rtrack
   *        La piste audio, vidéo ou texte à supprimer de la liste.
   *
   * @fires TrackList#removetrack
   */
  removeTrack(rtrack) {
    laisser la voie libre ;

    for (let i = 0, l = this.length ; i < l ; i++) {
      if (this[i] === rtrack) {
        track = this[i] ;
        if (track.off) {
          track.off() ;
        }

        this.tracks_.splice(i, 1) ;

        pause ;
      }
    }

    if (!track) {
      retour ;
    }

    /**
     * Déclenché lorsqu'une piste est supprimée de la liste des pistes.
     *
     * @event TrackList#removetrack
     * @type {EventTarget~Event}
     * @property {Track} track
     *           Une référence à la voie qui a été supprimée.
     */
    this.trigger({
      la voie ferrée,
      type : "removetrack",
      cible : ceci
    }) ;
  }

  /**
   * Obtenir une piste de la liste des pistes en fonction de l'identifiant de la piste
   *
   * @param {string} id - l'identifiant de la piste à obtenir
   * @method getTrackById
   * @return {Track}
   * @private
   */
  getTrackById(id) {
    let result = null ;

    for (let i = 0, l = this.length ; i < l ; i++) {
      const track = this[i] ;

      if (track.id === id) {
        résultat = piste ;
        pause ;
      }
    }

    retourner le résultat ;
  }
}

/**
 * Déclenché lorsqu'une piste différente est sélectionnée/activée.
 *
 * @event TrackList#change
 * @type {EventTarget~Event}
 */

/**
 * Événements pouvant être appelés avec on + eventName. Voir {@link EventHandler}.
 *
 * @property {Objet} TrackList#allowedEvents_ (liste de pistes)
 * @private
 */
TrackList.prototype.allowedEvents_ = {
  changement : "changement",
  addtrack : 'addtrack',
  removetrack : 'removetrack',
  changement d'étiquette : "changement d'étiquette
};

// émuler le support EventHandler de l'attribut pour permettre la détection des caractéristiques
for (const event in TrackList.prototype.allowedEvents_) {
  TrackList.prototype['on' + event] = null ;
}

exporter la liste des pistes par défaut ;