"use strict";

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

module.exports = function evaluate(path, {
  tdz = false
} = {}) {
  if (!tdz && !path.isReferencedIdentifier()) {
    return baseEvaluate(path);
  }

  if (path.isReferencedIdentifier()) {
    return evaluateIdentifier(path);
  }

  const state = {
    confident: true
  }; // prepare

  path.traverse({
    Scope(scopePath) {
      scopePath.skip();
    },

    ReferencedIdentifier(idPath) {
      const binding = idPath.scope.getBinding(idPath.node.name); // don't deopt globals
      // let babel take care of it

      if (!binding) return;
      const evalResult = evaluateIdentifier(idPath);

      if (!evalResult.confident) {
        state.confident = evalResult.confident;
        state.deoptPath = evalResult.deoptPath;
      }
    }

  });

  if (!state.confident) {
    return state;
  }

  return baseEvaluate(path);
};

function baseEvaluate(path) {
  try {
    return path.evaluate();
  } catch (e) {
    return {
      confident: false,
      error: e
    };
  }
} // Original Source:
// https://github.com/babel/babel/blob/master/packages/babel-traverse/src/path/evaluation.js
// modified for Babel-minify use


function evaluateIdentifier(path) {
  if (!path.isReferencedIdentifier()) {
    throw new Error(`Expected ReferencedIdentifier. Got ${path.type}`);
  }

  const node = path.node;
  const binding = path.scope.getBinding(node.name);

  if (!binding) {
    const name = node.name;

    if (!name) {
      return deopt(path);
    }

    switch (name) {
      case "undefined":
        return {
          confident: true,
          value: undefined
        };

      case "NaN":
        return {
          confident: true,
          value: NaN
        };

      case "Infinity":
        return {
          confident: true,
          value: Infinity
        };

      default:
        return deopt(path);
    }
  }

  if (binding.constantViolations.length > 0) {
    return deopt(binding.path);
  } // referenced in a different scope - deopt


  if (shouldDeoptBasedOnScope(binding, path)) {
    return deopt(path);
  } // let/var/const referenced before init
  // or "var" referenced in an outer scope


  const flowEvalResult = evaluateBasedOnControlFlow(binding, path);

  if (flowEvalResult.confident) {
    return flowEvalResult;
  }

  if (flowEvalResult.shouldDeopt) {
    return deopt(path);
  }

  return path.evaluate();
} // check if referenced in a different fn scope
// we can't determine if this function is called sync or async
// if the binding is in program scope
// all it's references inside a different function should be deopted


function shouldDeoptBasedOnScope(binding, refPath) {
  if (binding.scope.path.isProgram() && refPath.scope !== binding.scope) {
    return true;
  }

  return false;
}

function evaluateBasedOnControlFlow(binding, refPath) {
  if (binding.kind === "var") {
    // early-exit
    const declaration = binding.path.parentPath;

    if (declaration.parentPath) {
      /**
       * Handle when binding is created inside a parent block and
       * the corresponding parent is removed by other plugins
       * if (false) { var a } -> var a
       */
      if (declaration.parentPath.removed) {
        return {
          confident: true,
          value: void 0
        };
      }

      if (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase()) {
        return {
          shouldDeopt: true
        };
      }
    }

    const fnParent = (binding.path.scope.getFunctionParent() || binding.path.scope.getProgramParent()).path;
    let blockParentPath = binding.path.scope.getBlockParent().path;
    let blockParent = blockParentPath.node;

    if (blockParentPath === fnParent && !fnParent.isProgram()) {
      blockParent = blockParent.body;
    } // detect Usage Outside Init Scope


    const blockBody = blockParent.body;

    if (Array.isArray(blockBody) && !blockBody.some(stmt => isAncestor(stmt, refPath))) {
      return {
        shouldDeopt: true
      };
    } // Detect usage before init


    const stmts = fnParent.isProgram() ? fnParent.node.body : fnParent.node.body.body;
    const compareResult = compareBindingAndReference({
      binding,
      refPath,
      stmts
    });

    if (compareResult.reference && compareResult.binding) {
      if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
        return {
          confident: true,
          value: void 0
        };
      }
    }
  } else if (binding.kind === "let" || binding.kind === "const") {
    // binding.path is the declarator
    const declarator = binding.path;
    const declaration = declarator.parentPath;

    if (declaration.parentPath && (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase())) {
      return {
        shouldDeopt: true
      };
    }

    const scopePath = declarator.scope.path;
    let scopeNode = scopePath.node;

    if (scopePath.isFunction() || scopePath.isCatchClause()) {
      scopeNode = scopeNode.body;
    } // Detect Usage before Init


    let stmts = scopeNode.body;

    if (!Array.isArray(stmts)) {
      stmts = [stmts];
    }

    const compareResult = compareBindingAndReference({
      binding,
      refPath,
      stmts
    });

    if (compareResult.reference && compareResult.binding) {
      if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
        throw new Error(`ReferenceError: Used ${refPath.node.name}: ` + `${binding.kind} binding before declaration`);
      }

      if (compareResult.reference.scope === "other") {
        return {
          shouldDeopt: true
        };
      }
    }
  }

  return {
    confident: false,
    shouldDeopt: false
  };
}

function compareBindingAndReference({
  binding,
  refPath,
  stmts
}) {
  const state = {
    binding: null,
    reference: null
  };
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = stmts.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      const _step$value = _slicedToArray(_step.value, 2),
            idx = _step$value[0],
            stmt = _step$value[1];

      if (isAncestor(stmt, binding.path)) {
        state.binding = {
          idx
        };
      }

      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = binding.referencePaths[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          const ref = _step2.value;

          if (ref === refPath && isAncestor(stmt, ref)) {
            state.reference = {
              idx,
              scope: binding.path.scope === ref.scope ? "current" : "other"
            };
            break;
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return state;
}

function deopt(deoptPath) {
  return {
    confident: false,
    deoptPath
  };
}
/**
 * is nodeParent an ancestor of path
 */


function isAncestor(nodeParent, path) {
  return !!path.findParent(parent => parent.node === nodeParent);
}