/**
 * Copyright © Charles Kerr, Dave Perrett, Malcolm Jarvis and Bruno Bierbaumer
 *
 * This file is licensed under the GPLv2.
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 */

function Inspector(controller) {
  var data = {
      controller: null,
      elements: {},
      torrents: [],
    },
    needsExtraInfo = function (torrents) {
      return torrents.some((tor) => !tor.hasExtraInfo());
    },
    refreshTorrents = function (callback) {
      let fields,
        ids = $.map(data.torrents.slice(0), function (t) {
          return t.getId();
        });

      if (ids && ids.length) {
        fields = ['id'].concat(Torrent.Fields.StatsExtra);

        if (needsExtraInfo(data.torrents)) {
          $.merge(fields, Torrent.Fields.InfoExtra);
        }

        data.controller.updateTorrents(ids, fields, callback);
      }
    },
    onTabClicked = function (ev) {
      const tab = ev.currentTarget;

      if (isMobileDevice) {
        ev.stopPropagation();
      }

      // select this tab and deselect the others
      $(tab).addClass('selected').siblings().removeClass('selected');

      // show this tab and hide the others
      $('#' + tab.id.replace('tab', 'page'))
        .show()
        .siblings('.inspector-page')
        .hide();

      updateInspector();
    },
    updateInspector = function () {
      let e = data.elements,
        torrents = data.torrents,
        name;

      // update the name, which is shown on all the pages
      if (!torrents || !torrents.length) {
        name = 'No Selection';
      } else if (torrents.length === 1) {
        name = torrents[0].getName();
      } else {
        name = '' + torrents.length + ' Transfers Selected';
      }
      setTextContent(e.name_lb, name || na);

      // update the visible page
      if ($(e.info_page).is(':visible')) {
        updateInfoPage();
      } else if ($(e.peers_page).is(':visible')) {
        updatePeersPage();
      } else if ($(e.trackers_page).is(':visible')) {
        updateTrackersPage();
      } else if ($(e.files_page).is(':visible')) {
        updateFilesPage();
      }
    },
    /****
     *****  GENERAL INFO PAGE
     ****/

    updateInfoPage = function () {
      let torrents = data.torrents,
        e = data.elements,
        fmt = Transmission.fmt,
        none = 'None',
        mixed = 'Mixed',
        unknown = 'Unknown',
        isMixed,
        allPaused,
        allFinished,
        str,
        baseline,
        it,
        i,
        t,
        sizeWhenDone = 0,
        leftUntilDone = 0,
        available = 0,
        haveVerified = 0,
        haveUnverified = 0,
        verifiedPieces = 0,
        stateString,
        latest,
        pieces,
        size,
        pieceSize,
        creator,
        mixed_creator,
        date,
        mixed_date,
        v,
        u,
        f,
        d,
        now = Date.now();

      //
      //  state_lb
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        isMixed = false;
        allPaused = true;
        allFinished = true;

        baseline = torrents[0].getStatus();
        for (i = 0; (t = torrents[i]); ++i) {
          it = t.getStatus();
          if (it != baseline) {
            isMixed = true;
          }
          if (!t.isStopped()) {
            allPaused = allFinished = false;
          }
          if (!t.isFinished()) {
            allFinished = false;
          }
        }
        if (isMixed) {
          str = mixed;
        } else if (allFinished) {
          str = 'Finished';
        } else if (allPaused) {
          str = 'Paused';
        } else {
          str = torrents[0].getStateString();
        }
      }
      setTextContent(e.state_lb, str);
      stateString = str;

      //
      //  have_lb
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        baseline = torrents[0].getStatus();
        for (i = 0; (t = torrents[i]); ++i) {
          if (!t.needsMetaData()) {
            haveUnverified += t.getHaveUnchecked();
            v = t.getHaveValid();
            haveVerified += v;
            if (t.getPieceSize()) {
              verifiedPieces += v / t.getPieceSize();
            }
            sizeWhenDone += t.getSizeWhenDone();
            leftUntilDone += t.getLeftUntilDone();
            available += t.getHave() + t.getDesiredAvailable();
          }
        }

        d = 100.0 * (sizeWhenDone ? (sizeWhenDone - leftUntilDone) / sizeWhenDone : 1);
        str = fmt.percentString(d);

        if (!haveUnverified && !leftUntilDone) {
          str = fmt.size(haveVerified) + ' (100%)';
        } else if (!haveUnverified) {
          str = fmt.size(haveVerified) + ' of ' + fmt.size(sizeWhenDone) + ' (' + str + '%)';
        } else {
          str =
            fmt.size(haveVerified) +
            ' of ' +
            fmt.size(sizeWhenDone) +
            ' (' +
            str +
            '%), ' +
            fmt.size(haveUnverified) +
            ' Unverified';
        }
      }
      setTextContent(e.have_lb, str);

      //
      //  availability_lb
      //

      if (torrents.length < 1) {
        str = none;
      } else if (sizeWhenDone == 0) {
        str = none;
      } else {
        str = '' + fmt.percentString((100.0 * available) / sizeWhenDone) + '%';
      }
      setTextContent(e.availability_lb, str);

      //
      //  downloaded_lb
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        d = f = 0;
        for (i = 0; (t = torrents[i]); ++i) {
          d += t.getDownloadedEver();
          f += t.getFailedEver();
        }
        if (f) {
          str = fmt.size(d) + ' (' + fmt.size(f) + ' corrupt)';
        } else {
          str = fmt.size(d);
        }
      }
      setTextContent(e.downloaded_lb, str);

      //
      //  uploaded_lb
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        d = u = 0;
        if (torrents.length == 1) {
          d = torrents[0].getDownloadedEver();
          u = torrents[0].getUploadedEver();

          if (d == 0) {
            d = torrents[0].getHaveValid();
          }
        } else {
          for (i = 0; (t = torrents[i]); ++i) {
            d += t.getDownloadedEver();
            u += t.getUploadedEver();
          }
        }
        str = fmt.size(u) + ' (Ratio: ' + fmt.ratioString(Math.ratio(u, d)) + ')';
      }
      setTextContent(e.uploaded_lb, str);

      //
      // running time
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        allPaused = true;
        baseline = torrents[0].getStartDate();
        for (i = 0; (t = torrents[i]); ++i) {
          if (baseline != t.getStartDate()) {
            baseline = 0;
          }
          if (!t.isStopped()) {
            allPaused = false;
          }
        }
        if (allPaused) {
          str = stateString; // paused || finished}
        } else if (!baseline) {
          str = mixed;
        } else {
          str = fmt.timeInterval(now / 1000 - baseline);
        }
      }

      setTextContent(e.running_time_lb, str);

      //
      // remaining time
      //

      str = '';
      if (torrents.length < 1) {
        str = none;
      } else {
        baseline = torrents[0].getETA();
        for (i = 0; (t = torrents[i]); ++i) {
          if (baseline != t.getETA()) {
            str = mixed;
            break;
          }
        }
      }
      if (!str.length) {
        if (baseline < 0) {
          str = unknown;
        } else {
          str = fmt.timeInterval(baseline);
        }
      }
      setTextContent(e.remaining_time_lb, str);

      //
      // last activity
      //

      latest = -1;
      if (torrents.length < 1) {
        str = none;
      } else {
        for (i = 0; (t = torrents[i]); ++i) {
          d = t.getLastActivity();
          if (latest < d) {
            latest = d;
          }
        }
        d = now / 1000 - latest; // seconds since last activity
        if (d < 0) {
          str = none;
        } else if (d < 5) {
          str = 'Active now';
        } else {
          str = fmt.timeInterval(d) + ' ago';
        }
      }
      setTextContent(e.last_activity_lb, str);

      //
      // error
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        str = torrents[0].getErrorString();
        for (i = 0; (t = torrents[i]); ++i) {
          if (str != t.getErrorString()) {
            str = mixed;
            break;
          }
        }
      }
      setTextContent(e.error_lb, str || none);

      //
      // size
      //

      if (torrents.length < 1) {
        {
          str = none;
        }
      } else {
        pieces = 0;
        size = 0;
        pieceSize = torrents[0].getPieceSize();
        for (i = 0; (t = torrents[i]); ++i) {
          pieces += t.getPieceCount();
          size += t.getTotalSize();
          if (pieceSize != t.getPieceSize()) {
            pieceSize = 0;
          }
        }
        if (!size) {
          str = none;
        } else if (pieceSize > 0) {
          str =
            fmt.size(size) +
            ' (' +
            pieces.toStringWithCommas() +
            ' pieces @ ' +
            fmt.mem(pieceSize) +
            ')';
        } else {
          str = fmt.size(size) + ' (' + pieces.toStringWithCommas() + ' pieces)';
        }
      }
      setTextContent(e.size_lb, str);

      //
      //  hash
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        str = torrents[0].getHashString();
        for (i = 0; (t = torrents[i]); ++i) {
          if (str != t.getHashString()) {
            str = mixed;
            break;
          }
        }
      }
      setTextContent(e.hash_lb, str);

      //
      //  privacy
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        baseline = torrents[0].getPrivateFlag();
        str = baseline ? 'Private to this tracker -- DHT and PEX disabled' : 'Public torrent';
        for (i = 0; (t = torrents[i]); ++i) {
          if (baseline != t.getPrivateFlag()) {
            str = mixed;
            break;
          }
        }
      }
      setTextContent(e.privacy_lb, str);

      //
      //  comment
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        str = torrents[0].getComment();
        for (i = 0; (t = torrents[i]); ++i) {
          if (str != t.getComment()) {
            str = mixed;
            break;
          }
        }
      }
      if (!str) {
        str = none;
      }
      if (str.startsWith('https://') || str.startsWith('http://')) {
        str = encodeURI(str);
        setInnerHTML(e.comment_lb, '<a href="' + str + '" target="_blank" >' + str + '</a>');
      } else {
        setTextContent(e.comment_lb, str);
      }

      //
      //  origin
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        mixed_creator = false;
        mixed_date = false;
        creator = torrents[0].getCreator();
        date = torrents[0].getDateCreated();
        for (i = 0; (t = torrents[i]); ++i) {
          if (creator != t.getCreator()) {
            mixed_creator = true;
          }
          if (date != t.getDateCreated()) {
            mixed_date = true;
          }
        }
        const empty_creator = !creator || !creator.length;
        const empty_date = !date;
        if (mixed_creator || mixed_date) {
          str = mixed;
        } else if (empty_creator && empty_date) {
          str = unknown;
        } else if (empty_date && !empty_creator) {
          str = 'Created by ' + creator;
        } else if (empty_creator && !empty_date) {
          str = 'Created on ' + new Date(date * 1000).toDateString();
        } else {
          str = 'Created by ' + creator + ' on ' + new Date(date * 1000).toDateString();
        }
      }
      setTextContent(e.origin_lb, str);

      //
      //  foldername
      //

      if (torrents.length < 1) {
        str = none;
      } else {
        str = torrents[0].getDownloadDir();
        for (i = 0; (t = torrents[i]); ++i) {
          if (str != t.getDownloadDir()) {
            str = mixed;
            break;
          }
        }
      }
      setTextContent(e.foldername_lb, str);
    },
    /****
     *****  FILES PAGE
     ****/

    changeFileCommand = function (fileIndices, command) {
      const torrentId = data.file_torrent.getId();
      data.controller.changeFileCommand(torrentId, fileIndices, command);
    },
    onFileWantedToggled = function (ev, fileIndices, want) {
      changeFileCommand(fileIndices, want ? 'files-wanted' : 'files-unwanted');
    },
    onFilePriorityToggled = function (ev, fileIndices, priority) {
      let command;
      switch (priority) {
        case -1:
          command = 'priority-low';
          break;
        case 1:
          command = 'priority-high';
          break;
        default:
          command = 'priority-normal';
          break;
      }
      changeFileCommand(fileIndices, command);
    },
    onNameClicked = function (ev, fileRow, fileIndices) {
      $(fileRow.getElement()).siblings().slideToggle();
    },
    clearFileList = function () {
      $(data.elements.file_list).empty();
      delete data.file_torrent;
      delete data.file_torrent_n;
      delete data.file_rows;
    },
    createFileTreeModel = function (tor) {
      let i,
        j,
        n,
        name,
        tokens,
        walk,
        token,
        sub,
        leaves = [],
        tree = {
          children: {},
          file_indices: [],
        };

      n = tor.getFileCount();
      for (i = 0; i < n; ++i) {
        name = tor.getFile(i).name;
        tokens = name.split('/');
        walk = tree;
        for (j = 0; j < tokens.length; ++j) {
          token = tokens[j];
          sub = walk.children[token];
          if (!sub) {
            walk.children[token] = sub = {
              name: token,
              parent: walk,
              children: {},
              file_indices: [],
              depth: j,
            };
          }
          walk = sub;
        }
        walk.file_index = i;
        delete walk.children;
        leaves.push(walk);
      }

      for (i = 0; i < leaves.length; ++i) {
        walk = leaves[i];
        j = walk.file_index;
        do {
          walk.file_indices.push(j);
          walk = walk.parent;
        } while (walk);
      }

      return tree;
    },
    addNodeToView = function (tor, parent, sub, i) {
      let row;
      row = new FileRow(tor, sub.depth, sub.name, sub.file_indices, i % 2);
      data.file_rows.push(row);
      parent.appendChild(row.getElement());
      $(row).bind('wantedToggled', onFileWantedToggled);
      $(row).bind('priorityToggled', onFilePriorityToggled);
      $(row).bind('nameClicked', onNameClicked);
    },
    addSubtreeToView = function (tor, parent, sub, i) {
      let key, div;
      div = document.createElement('div');
      if (sub.parent) {
        addNodeToView(tor, div, sub, i++);
      }
      if (sub.children) {
        for (key in sub.children) {
          i = addSubtreeToView(tor, div, sub.children[key]);
        }
      }
      parent.appendChild(div);
      return i;
    },
    updateFilesPage = function () {
      let i,
        n,
        tor,
        fragment,
        tree,
        file_list = data.elements.file_list,
        torrents = data.torrents;

      // only show one torrent at a time
      if (torrents.length !== 1) {
        clearFileList();
        return;
      }

      tor = torrents[0];
      n = tor ? tor.getFileCount() : 0;
      if (tor != data.file_torrent || n != data.file_torrent_n) {
        // rebuild the file list...
        clearFileList();
        data.file_torrent = tor;
        data.file_torrent_n = n;
        data.file_rows = [];
        fragment = document.createDocumentFragment();
        tree = createFileTreeModel(tor);
        addSubtreeToView(tor, fragment, tree, 0);
        file_list.appendChild(fragment);
      } else {
        // ...refresh the already-existing file list
        for (i = 0, n = data.file_rows.length; i < n; ++i) {
          data.file_rows[i].refresh();
        }
      }
    },
    /****
     *****  PEERS PAGE
     ****/

    updatePeersPage = function () {
      let i,
        k,
        tor,
        peers,
        peer,
        parity,
        html = [],
        fmt = Transmission.fmt,
        peers_list = data.elements.peers_list,
        torrents = data.torrents;

      for (k = 0; (tor = torrents[k]); ++k) {
        peers = tor.getPeers();
        html.push('<div class="inspector_group">');
        if (torrents.length > 1) {
          html.push('<div class="inspector_torrent_label">', sanitizeText(tor.getName()), '</div>');
        }
        if (!peers || !peers.length) {
          html.push('<br></div>'); // firefox won't paint the top border if the div is empty
          continue;
        }
        html.push(
          '<table class="peer_list">',
          '<tr class="inspector_peer_entry even">',
          '<th class="encryptedCol"></th>',
          '<th class="upCol">Up</th>',
          '<th class="downCol">Down</th>',
          '<th class="percentCol">%</th>',
          '<th class="statusCol">Status</th>',
          '<th class="addressCol">Address</th>',
          '<th class="clientCol">Client</th>',
          '</tr>'
        );
        for (i = 0; (peer = peers[i]); ++i) {
          parity = i % 2 ? 'odd' : 'even';
          html.push(
            '<tr class="inspector_peer_entry ',
            parity,
            '">',
            '<td>',
            peer.isEncrypted
              ? '<div class="encrypted-peer-cell" title="Encrypted Connection">'
              : '<div class="unencrypted-peer-cell">',
            '</div>',
            '</td>',
            '<td>',
            peer.rateToPeer ? fmt.speedBps(peer.rateToPeer) : '',
            '</td>',
            '<td>',
            peer.rateToClient ? fmt.speedBps(peer.rateToClient) : '',
            '</td>',
            '<td class="percentCol">',
            Math.floor(peer.progress * 100),
            '%',
            '</td>',
            '<td>',
            fmt.peerStatus(peer.flagStr),
            '</td>',
            '<td>',
            sanitizeText(peer.address),
            '</td>',
            '<td class="clientCol">',
            sanitizeText(peer.clientName),
            '</td>',
            '</tr>'
          );
        }
        html.push('</table></div>');
      }

      setInnerHTML(peers_list, html.join(''));
    },
    /****
     *****  TRACKERS PAGE
     ****/

    getAnnounceState = function (tracker) {
      let timeUntilAnnounce,
        s = '';
      switch (tracker.announceState) {
        case Torrent._TrackerActive:
          s = 'Announce in progress';
          break;
        case Torrent._TrackerWaiting:
          timeUntilAnnounce = tracker.nextAnnounceTime - new Date().getTime() / 1000;
          if (timeUntilAnnounce < 0) {
            timeUntilAnnounce = 0;
          }
          s = 'Next announce in ' + Transmission.fmt.timeInterval(timeUntilAnnounce);
          break;
        case Torrent._TrackerQueued:
          s = 'Announce is queued';
          break;
        case Torrent._TrackerInactive:
          s = tracker.isBackup ? 'Tracker will be used as a backup' : 'Announce not scheduled';
          break;
        default:
          s = 'unknown announce state: ' + tracker.announceState;
      }
      return s;
    },
    lastAnnounceStatus = function (tracker) {
      let lastAnnounceLabel = 'Last Announce',
        lastAnnounce = ['N/A'],
        lastAnnounceTime;

      if (tracker.hasAnnounced) {
        lastAnnounceTime = Transmission.fmt.timestamp(tracker.lastAnnounceTime);
        if (tracker.lastAnnounceSucceeded) {
          lastAnnounce = [
            lastAnnounceTime,
            ' (got ',
            Transmission.fmt.countString('peer', 'peers', tracker.lastAnnouncePeerCount),
            ')',
          ];
        } else {
          lastAnnounceLabel = 'Announce error';
          lastAnnounce = [
            tracker.lastAnnounceResult ? tracker.lastAnnounceResult + ' - ' : '',
            lastAnnounceTime,
          ];
        }
      }
      return {
        label: lastAnnounceLabel,
        value: lastAnnounce.join(''),
      };
    },
    lastScrapeStatus = function (tracker) {
      let lastScrapeLabel = 'Last Scrape',
        lastScrape = 'N/A',
        lastScrapeTime;

      if (tracker.hasScraped) {
        lastScrapeTime = Transmission.fmt.timestamp(tracker.lastScrapeTime);
        if (tracker.lastScrapeSucceeded) {
          lastScrape = lastScrapeTime;
        } else {
          lastScrapeLabel = 'Scrape error';
          lastScrape =
            (tracker.lastScrapeResult ? tracker.lastScrapeResult + ' - ' : '') + lastScrapeTime;
        }
      }
      return {
        label: lastScrapeLabel,
        value: lastScrape,
      };
    },
    updateTrackersPage = function () {
      let i,
        j,
        tier,
        tracker,
        trackers,
        tor,
        html,
        parity,
        lastAnnounceStatusHash,
        announceState,
        lastScrapeStatusHash,
        na = 'N/A',
        trackers_list = data.elements.trackers_list,
        torrents = data.torrents;

      // By building up the HTML as as string, then have the browser
      // turn this into a DOM tree, this is a fast operation.
      html = [];
      for (i = 0; (tor = torrents[i]); ++i) {
        html.push('<div class="inspector_group">');

        if (torrents.length > 1) {
          html.push('<div class="inspector_torrent_label">', sanitizeText(tor.getName()), '</div>');
        }

        tier = -1;
        trackers = tor.getTrackers();
        for (j = 0; (tracker = trackers[j]); ++j) {
          if (tier != tracker.tier) {
            if (tier !== -1) {
              // close previous tier
              html.push('</ul></div>');
            }

            tier = tracker.tier;

            html.push(
              '<div class="inspector_group_label">',
              'Tier ',
              tier + 1,
              '</div>',
              '<ul class="tier_list">'
            );
          }

          // Display construction
          lastAnnounceStatusHash = lastAnnounceStatus(tracker);
          announceState = getAnnounceState(tracker);
          lastScrapeStatusHash = lastScrapeStatus(tracker);
          parity = j % 2 ? 'odd' : 'even';
          html.push(
            '<li class="inspector_tracker_entry ',
            parity,
            '"><div class="tracker_host" title="',
            sanitizeText(tracker.announce),
            '">',
            sanitizeText(tracker.host || tracker.announce),
            '</div>',
            '<div class="tracker_activity">',
            '<div>',
            lastAnnounceStatusHash['label'],
            ': ',
            sanitizeText(lastAnnounceStatusHash['value']),
            '</div>',
            '<div>',
            announceState,
            '</div>',
            '<div>',
            lastScrapeStatusHash['label'],
            ': ',
            sanitizeText(lastScrapeStatusHash['value']),
            '</div>',
            '</div><table class="tracker_stats">',
            '<tr><th>Seeders:</th><td>',
            tracker.seederCount > -1 ? tracker.seederCount : na,
            '</td></tr>',
            '<tr><th>Leechers:</th><td>',
            tracker.leecherCount > -1 ? tracker.leecherCount : na,
            '</td></tr>',
            '<tr><th>Downloads:</th><td>',
            tracker.downloadCount > -1 ? tracker.downloadCount : na,
            '</td></tr>',
            '</table></li>'
          );
        }
        if (tier !== -1) {
          // close last tier
          html.push('</ul></div>');
        }

        html.push('</div>'); // inspector_group
      }

      setInnerHTML(trackers_list, html.join(''));
    },
    initialize = function (controller) {
      data.controller = controller;

      $('.inspector-tab').click(onTabClicked);

      data.elements.info_page = $('#inspector-page-info')[0];
      data.elements.files_page = $('#inspector-page-files')[0];
      data.elements.peers_page = $('#inspector-page-peers')[0];
      data.elements.trackers_page = $('#inspector-page-trackers')[0];

      data.elements.file_list = $('#inspector_file_list')[0];
      data.elements.peers_list = $('#inspector_peers_list')[0];
      data.elements.trackers_list = $('#inspector_trackers_list')[0];

      data.elements.have_lb = $('#inspector-info-have')[0];
      data.elements.availability_lb = $('#inspector-info-availability')[0];
      data.elements.downloaded_lb = $('#inspector-info-downloaded')[0];
      data.elements.uploaded_lb = $('#inspector-info-uploaded')[0];
      data.elements.state_lb = $('#inspector-info-state')[0];
      data.elements.running_time_lb = $('#inspector-info-running-time')[0];
      data.elements.remaining_time_lb = $('#inspector-info-remaining-time')[0];
      data.elements.last_activity_lb = $('#inspector-info-last-activity')[0];
      data.elements.error_lb = $('#inspector-info-error')[0];
      data.elements.size_lb = $('#inspector-info-size')[0];
      data.elements.foldername_lb = $('#inspector-info-location')[0];
      data.elements.hash_lb = $('#inspector-info-hash')[0];
      data.elements.privacy_lb = $('#inspector-info-privacy')[0];
      data.elements.origin_lb = $('#inspector-info-origin')[0];
      data.elements.comment_lb = $('#inspector-info-comment')[0];
      data.elements.name_lb = $('#torrent_inspector_name')[0];

      // force initial 'N/A' updates on all the pages
      updateInspector();
      updateInfoPage();
      updatePeersPage();
      updateTrackersPage();
      updateFilesPage();
    };

  /****
   *****  PUBLIC FUNCTIONS
   ****/

  this.setTorrents = function (torrents) {
    const d = data;

    // update the inspector when a selected torrent's data changes.
    $(d.torrents).unbind('dataChanged.inspector');
    $(torrents).bind('dataChanged.inspector', $.proxy(updateInspector, this));
    d.torrents = torrents;

    // periodically ask for updates to the inspector's torrents
    clearTimeout(d.refreshTimeout);

    function callback() {
      refreshTorrents(rescheduleTimeout);
    }

    function rescheduleTimeout() {
      d.refreshTimeout = setTimeout(callback, 2000);
    }

    rescheduleTimeout();
    refreshTorrents();

    // refresh the inspector's UI
    updateInspector();
  };

  initialize(controller);
}