'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var tslib_es6 = require('../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
var Scale = require('./Scale.js');
var number = require('../util/number.js');
var Interval = require('./Interval.js');
var helper = require('./helper.js');
var _break = require('./break.js');

var fixRound = number.round;
var mathFloor = Math.floor;
var mathCeil = Math.ceil;
var mathPow = Math.pow;
var mathLog = Math.log;
var LogScale = /** @class */function (_super) {
  tslib_es6.__extends(LogScale, _super);
  function LogScale() {
    var _this = _super !== null && _super.apply(this, arguments) || this;
    _this.type = 'log';
    _this.base = 10;
    _this._originalScale = new Interval.default();
    return _this;
  }
  /**
   * @param Whether expand the ticks to niced extent.
   */
  LogScale.prototype.getTicks = function (opt) {
    opt = opt || {};
    var extent = this._extent.slice();
    var originalExtent = this._originalScale.getExtent();
    var ticks = _super.prototype.getTicks.call(this, opt);
    var base = this.base;
    var originalBreaks = this._originalScale._innerGetBreaks();
    var scaleBreakHelper = _break.getScaleBreakHelper();
    return util.map(ticks, function (tick) {
      var val = tick.value;
      var roundingCriterion = null;
      var powVal = mathPow(base, val);
      // Fix #4158
      if (val === extent[0] && this._fixMin) {
        roundingCriterion = originalExtent[0];
      } else if (val === extent[1] && this._fixMax) {
        roundingCriterion = originalExtent[1];
      }
      var vBreak;
      if (scaleBreakHelper) {
        var transformed = scaleBreakHelper.getTicksLogTransformBreak(tick, base, originalBreaks, fixRoundingError);
        vBreak = transformed.vBreak;
        if (roundingCriterion == null) {
          roundingCriterion = transformed.brkRoundingCriterion;
        }
      }
      if (roundingCriterion != null) {
        powVal = fixRoundingError(powVal, roundingCriterion);
      }
      return {
        value: powVal,
        "break": vBreak
      };
    }, this);
  };
  LogScale.prototype._getNonTransBreaks = function () {
    return this._originalScale._innerGetBreaks();
  };
  LogScale.prototype.setExtent = function (start, end) {
    this._originalScale.setExtent(start, end);
    var loggedExtent = helper.logTransform(this.base, [start, end]);
    _super.prototype.setExtent.call(this, loggedExtent[0], loggedExtent[1]);
  };
  /**
   * @return {number} end
   */
  LogScale.prototype.getExtent = function () {
    var base = this.base;
    var extent = _super.prototype.getExtent.call(this);
    extent[0] = mathPow(base, extent[0]);
    extent[1] = mathPow(base, extent[1]);
    // Fix #4158
    var originalExtent = this._originalScale.getExtent();
    this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
    this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
    return extent;
  };
  LogScale.prototype.unionExtentFromData = function (data, dim) {
    this._originalScale.unionExtentFromData(data, dim);
    var loggedOther = helper.logTransform(this.base, data.getApproximateExtent(dim), true);
    this._innerUnionExtent(loggedOther);
  };
  /**
   * Update interval and extent of intervals for nice ticks
   * @param approxTickNum default 10 Given approx tick number
   */
  LogScale.prototype.calcNiceTicks = function (approxTickNum) {
    approxTickNum = approxTickNum || 10;
    var extent = this._extent.slice();
    var span = this._getExtentSpanWithBreaks();
    if (!isFinite(span) || span <= 0) {
      return;
    }
    var interval = number.quantity(span);
    var err = approxTickNum / span * interval;
    // Filter ticks to get closer to the desired count.
    if (err <= 0.5) {
      interval *= 10;
    }
    // Interval should be integer
    while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
      interval *= 10;
    }
    var niceExtent = [fixRound(mathCeil(extent[0] / interval) * interval), fixRound(mathFloor(extent[1] / interval) * interval)];
    this._interval = interval;
    this._intervalPrecision = helper.getIntervalPrecision(interval);
    this._niceExtent = niceExtent;
  };
  LogScale.prototype.calcNiceExtent = function (opt) {
    _super.prototype.calcNiceExtent.call(this, opt);
    this._fixMin = opt.fixMin;
    this._fixMax = opt.fixMax;
  };
  LogScale.prototype.contain = function (val) {
    val = mathLog(val) / mathLog(this.base);
    return _super.prototype.contain.call(this, val);
  };
  LogScale.prototype.normalize = function (val) {
    val = mathLog(val) / mathLog(this.base);
    return _super.prototype.normalize.call(this, val);
  };
  LogScale.prototype.scale = function (val) {
    val = _super.prototype.scale.call(this, val);
    return mathPow(this.base, val);
  };
  LogScale.prototype.setBreaksFromOption = function (breakOptionList) {
    var scaleBreakHelper = _break.getScaleBreakHelper();
    if (!scaleBreakHelper) {
      return;
    }
    var _a = scaleBreakHelper.logarithmicParseBreaksFromOption(breakOptionList, this.base, util.bind(this.parse, this)),
      parsedOriginal = _a.parsedOriginal,
      parsedLogged = _a.parsedLogged;
    this._originalScale._innerSetBreak(parsedOriginal);
    this._innerSetBreak(parsedLogged);
  };
  LogScale.type = 'log';
  return LogScale;
}(Interval.default);
function fixRoundingError(val, originalVal) {
  return fixRound(val, number.getPrecision(originalVal));
}
Scale.default.registerClass(LogScale);

exports.default = LogScale;
