/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

this.EXPORTED_SYMBOLS = [
  "Sntp",
];

const {classes: Cc, interfaces: Ci, utils: Cu} = Components;

// Set to true to see debug messages.
let DEBUG = false;

/**
 * Constructor of Sntp.
 *
 * @param dataAvailableCb
 *        Callback function gets called when SNTP offset available. Signature
 *        is function dataAvailableCb(offsetInMS).
 * @param maxRetryCount
 *        Maximum retry count when SNTP failed to connect to server; set to
 *        zero to disable the retry.
 * @param refreshPeriodInSecs
 *        Refresh period; set to zero to disable refresh.
 * @param timeoutInSecs
 *        Timeout value used for connection.
 * @param pools
 *        SNTP server lists separated by ';'.
 * @param port
 *        SNTP port.
 */
this.Sntp = function Sntp(dataAvailableCb, maxRetryCount, refreshPeriodInSecs,
                          timeoutInSecs, pools, port) {
  if (dataAvailableCb != null) {
    this._dataAvailableCb = dataAvailableCb;
  }
  if (maxRetryCount != null) {
    this._maxRetryCount = maxRetryCount;
  }
  if (refreshPeriodInSecs != null) {
    this._refreshPeriodInMS = refreshPeriodInSecs * 1000;
  }
  if (timeoutInSecs != null) {
    this._timeoutInMS = timeoutInSecs * 1000;
  }
  if (pools != null && Array.isArray(pools) && pools.length > 0) {
    this._pools = pools;
  }
  if (port != null) {
    this._port = port;
  }
}

Sntp.prototype = {
  isAvailable: function isAvailable() {
    return this._cachedOffset != null;
  },

  isExpired: function isExpired() {
    let valid = this._cachedOffset != null && this._cachedTimeInMS != null;
    if (this._refreshPeriodInMS > 0) {
      valid = valid && Date.now() < this._cachedTimeInMS +
                                    this._refreshPeriodInMS;
    }
    return !valid;
  },

  request: function request() {
    this._request();
  },

  getOffset: function getOffset() {
    return this._cachedOffset;
  },

  /**
   * Indicates the system clock has been changed by [offset]ms so we need to
   * adjust the stored value.
   */
  updateOffset: function updateOffset(offset) {
    if (this._cachedOffset != null) {
      this._cachedOffset -= offset;
    }
  },

  /**
   * Used to schedule a retry or periodic updates.
   */
  _schedule: function _schedule(timeInMS) {
    if (this._updateTimer == null) {
      this._updateTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
    }

    this._updateTimer.initWithCallback(this._request.bind(this),
                                       timeInMS,
                                       Ci.nsITimer.TYPE_ONE_SHOT);
    debug("Scheduled SNTP request in " + timeInMS + "ms");
  },

  /**
   * Handle the SNTP response.
   */
  _handleSntp: function _handleSntp(originateTimeInMS, receiveTimeInMS,
                                    transmitTimeInMS, respondTimeInMS) {
    let clockOffset = Math.floor(((receiveTimeInMS - originateTimeInMS) +
                                 (transmitTimeInMS - respondTimeInMS)) / 2);
    debug("Clock offset: " + clockOffset);

    // We've succeeded so clear the retry status.
    this._retryCount = 0;
    this._retryPeriodInMS = 0;

    // Cache the latest SNTP offset whenever receiving it.
    this._cachedOffset = clockOffset;
    this._cachedTimeInMS = respondTimeInMS;

    if (this._dataAvailableCb != null) {
      this._dataAvailableCb(clockOffset);
    }

    this._schedule(this._refreshPeriodInMS);
  },

  /**
   * Used for retry SNTP requests.
   */
  _retry: function _retry() {
    this._retryCount++;
    if (this._retryCount > this._maxRetryCount) {
      debug ("stop retrying SNTP");
      // Clear so we can start with clean status next time we have network.
      this._retryCount = 0;
      this._retryPeriodInMS = 0;
      return;
    }
    this._retryPeriodInMS = Math.max(1000, this._retryPeriodInMS * 2);

    this._schedule(this._retryPeriodInMS);
  },

  /**
   * Request SNTP.
   */
  _request: function _request() {
    function GetRequest() {
      let NTP_PACKET_SIZE = 48;
      let NTP_MODE_CLIENT = 3;
      let NTP_VERSION = 3;
      let TRANSMIT_TIME_OFFSET = 40;

      // Send the NTP request.
      let requestTimeInMS = Date.now();
      let s = requestTimeInMS / 1000;
      let ms = requestTimeInMS % 1000;
      // NTP time is relative to 1900.
      s += OFFSET_1900_TO_1970;
      let f = ms * 0x100000000 / 1000;
      s = Math.floor(s);
      f = Math.floor(f);

      let buffer = new ArrayBuffer(NTP_PACKET_SIZE);
      let data = new DataView(buffer);
      data.setUint8(0, NTP_MODE_CLIENT | (NTP_VERSION << 3));
      data.setUint32(TRANSMIT_TIME_OFFSET, s, false);
      data.setUint32(TRANSMIT_TIME_OFFSET + 4, f, false);

      return String.fromCharCode.apply(null, new Uint8Array(buffer));
    }

    function SNTPListener() {};
    SNTPListener.prototype = {
      onStartRequest: function onStartRequest(request, context) {
      },

      onStopRequest: function onStopRequest(request, context, status) {
        if (!Components.isSuccessCode(status)) {
          debug ("Connection failed");
          this._requesting = false;
          this._retry();
        }
      }.bind(this),

      onDataAvailable: function onDataAvailable(request, context, inputStream,
                                                offset, count) {
        function GetTimeStamp(binaryInputStream) {
          let s = binaryInputStream.read32();
          let f = binaryInputStream.read32();
          return Math.floor(
            ((s - OFFSET_1900_TO_1970) * 1000) + ((f * 1000) / 0x100000000)
          );
        }
        debug ("Data available: " + count + " bytes");

        try {
          let binaryInputStream = Cc["@mozilla.org/binaryinputstream;1"]
                                    .createInstance(Ci.nsIBinaryInputStream);
          binaryInputStream.setInputStream(inputStream);
          // We don't need first 24 bytes.
          for (let i = 0; i < 6; i++) {
            binaryInputStream.read32();
          }
          // Offset 24: originate time.
          let originateTimeInMS = GetTimeStamp(binaryInputStream);
          // Offset 32: receive time.
          let receiveTimeInMS = GetTimeStamp(binaryInputStream);
          // Offset 40: transmit time.
          let transmitTimeInMS = GetTimeStamp(binaryInputStream);
          let respondTimeInMS = Date.now();

          this._handleSntp(originateTimeInMS, receiveTimeInMS,
                           transmitTimeInMS, respondTimeInMS);
          this._requesting = false;
        } catch (e) {
          debug ("SNTPListener Error: " + e.message);
          this._requesting = false;
          this._retry();
        }
        inputStream.close();
      }.bind(this)
    };

    function SNTPRequester() {}
    SNTPRequester.prototype = {
      onOutputStreamReady: function(stream) {
        try {
          let data = GetRequest();
          let bytes_write = stream.write(data, data.length);
          debug ("SNTP: sent " + bytes_write + " bytes");
          stream.close();
        } catch (e) {
          debug ("SNTPRequester Error: " + e.message);
          this._requesting = false;
          this._retry();
        }
      }.bind(this)
    };

    // Number of seconds between Jan 1, 1900 and Jan 1, 1970.
    // 70 years plus 17 leap days.
    let OFFSET_1900_TO_1970 = ((365 * 70) + 17) * 24 * 60 * 60;

    if (this._requesting) {
      return;
    }
    if (this._pools.length < 1) {
      debug("No server defined");
      return;
    }
    if (this._updateTimer) {
      this._updateTimer.cancel();
    }

    debug ("Making request");
    this._requesting = true;

    let currentThread = Cc["@mozilla.org/thread-manager;1"]
                          .getService().currentThread;
    let socketTransportService =
      Cc["@mozilla.org/network/socket-transport-service;1"]
        .getService(Ci.nsISocketTransportService);
    let pump = Cc["@mozilla.org/network/input-stream-pump;1"]
                 .createInstance(Ci.nsIInputStreamPump);
    let transport = socketTransportService
      .createTransport(["udp"],
                       1,
                       this._pools[Math.floor(this._pools.length * Math.random())],
                       this._port,
                       null);

    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT, this._timeoutInMS);
    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_READ_WRITE, this._timeoutInMS);

    let outStream = transport.openOutputStream(0, 0, 0)
                             .QueryInterface(Ci.nsIAsyncOutputStream);
    let inStream = transport.openInputStream(0, 0, 0);

    pump.init(inStream, -1, -1, 0, 0, false);
    pump.asyncRead(new SNTPListener(), null);

    outStream.asyncWait(new SNTPRequester(), 0, 0, currentThread);
  },

  // Callback function.
  _dataAvailableCb: null,

  // Sntp servers.
  _pools: [
    "0.pool.ntp.org",
    "1.pool.ntp.org",
    "2.pool.ntp.org",
    "3.pool.ntp.org"
  ],

  // The SNTP port.
  _port: 123,

  // Maximum retry count allowed when request failed.
  _maxRetryCount: 0,

  // Refresh period.
  _refreshPeriodInMS: 0,

  // Timeout value used for connecting.
  _timeoutInMS: 30 * 1000,

  // Cached SNTP offset.
  _cachedOffset: null,

  // The time point when we cache the offset.
  _cachedTimeInMS: null,

  // Flag to avoid redundant requests.
  _requesting: false,

  // Retry counter.
  _retryCount: 0,

  // Retry time offset (in seconds).
  _retryPeriodInMS: 0,

  // Timer used for retries & daily updates.
  _updateTimer: null
};

let debug;
if (DEBUG) {
  debug = function (s) {
    dump("-*- Sntp: " + s + "\n");
  };
} else {
  debug = function (s) {};
}
