'use strict';

var acorn = require('acorn');
var escodegen = require('escodegen');
var vm = require('vm');
var fs = require('fs');
var path = require('path');

var PDFJS_PREPROCESSOR_NAME = 'PDFJSDev';
var ROOT_PREFIX = '$ROOT/';

function isLiteral(obj, value) {
  return obj.type === 'Literal' && obj.value === value;
}

function isPDFJSPreprocessor(obj) {
  return obj.type === 'Identifier' &&
         obj.name === PDFJS_PREPROCESSOR_NAME;
}

function evalWithDefines(code, defines, loc) {
  if (!code || !code.trim()) {
    throw new Error('No JavaScript expression given');
  }
  return vm.runInNewContext(code, defines, {displayErrors: false});
}

function handlePreprocessorAction(ctx, actionName, args, loc) {
  try {
    var arg;
    switch (actionName) {
      case 'test':
        arg = args[0];
        if (!arg || arg.type !== 'Literal' ||
            typeof arg.value !== 'string') {
          throw new Error('No code for testing is given');
        }
        var isTrue = !!evalWithDefines(arg.value, ctx.defines);
        return {type: 'Literal', value: isTrue, loc: loc};
      case 'eval':
        arg = args[0];
        if (!arg || arg.type !== 'Literal' ||
            typeof arg.value !== 'string') {
          throw new Error('No code for eval is given');
        }
        var result = evalWithDefines(arg.value, ctx.defines);
        if (typeof result === 'boolean' || typeof result === 'string' ||
            typeof result === 'number') {
          return {type: 'Literal', value: result, loc: loc};
        }
        if (typeof result === 'object') {
          var parsedObj = acorn.parse('(' + JSON.stringify(result) + ')');
          parsedObj.body[0].expression.loc = loc;
          return parsedObj.body[0].expression;
        }
        break;
      case 'json':
        arg = args[0];
        if (!arg || arg.type !== 'Literal' ||
            typeof arg.value !== 'string') {
          throw new Error('Path to JSON is not provided');
        }
        var jsonPath = arg.value;
        if (jsonPath.indexOf(ROOT_PREFIX) === 0) {
          jsonPath = path.join(ctx.rootPath,
                               jsonPath.substring(ROOT_PREFIX.length));
        }
        var jsonContent = fs.readFileSync(jsonPath).toString();
        var parsedJSON = acorn.parse('(' + jsonContent + ')');
        parsedJSON.body[0].expression.loc = loc;
        return parsedJSON.body[0].expression;
    }
    throw new Error('Unsupported action');
  } catch (e) {
    throw new Error('Could not process ' + PDFJS_PREPROCESSOR_NAME + '.' +
                    actionName + ' at ' + JSON.stringify(loc) + '\n' +
                    e.name + ': ' + e.message);
  }
}

function postprocessNode(ctx, node) {
  switch (node.type) {
    case 'IfStatement':
      if (isLiteral(node.test, true)) {
        // if (true) stmt1; => stmt1
        return node.consequent;
      } else if (isLiteral(node.test, false)) {
        // if (false) stmt1; else stmt2; => stmt2
        return node.alternate || {type: 'EmptyStatement', loc: node.loc};
      }
      break;
    case 'ConditionalExpression':
      if (isLiteral(node.test, true)) {
        // true ? stmt1 : stmt2 => stmt1
        return node.consequent;
      } else if (isLiteral(node.test, false)) {
        // false ? stmt1 : stmt2 => stmt2
        return node.alternate;
      }
      break;
    case 'UnaryExpression':
      if (node.operator === 'typeof' &&
          isPDFJSPreprocessor(node.argument)) {
        // typeof PDFJSDev => 'object'
        return {type: 'Literal', value: 'object', loc: node.loc};
      }
      if (node.operator === '!' &&
          node.argument.type === 'Literal' &&
          typeof node.argument.value === 'boolean') {
        // !true => false,  !false => true
        return {type: 'Literal', value: !node.argument.value, loc: node.loc};
      }
      break;
    case 'LogicalExpression':
      switch (node.operator) {
        case '&&':
          if (isLiteral(node.left, true)) {
            return node.right;
          }
          if (isLiteral(node.left, false)) {
            return node.left;
          }
          break;
        case '||':
          if (isLiteral(node.left, true)) {
            return node.left;
          }
          if (isLiteral(node.left, false)) {
            return node.right;
          }
          break;
      }
      break;
    case 'BinaryExpression':
      switch (node.operator) {
        case '==':
        case '===':
        case '!=':
        case '!==':
          if (node.left.type === 'Literal' &&
              node.right.type === 'Literal' &&
              typeof node.left.value === typeof node.right.value) {
             // folding two literals == and != check
             switch (typeof node.left.value) {
               case 'string':
               case 'boolean':
               case 'number':
                 var equal = node.left.value === node.right.value;
                 return {
                   type: 'Literal',
                   value: (node.operator[0] === '=') === equal,
                   loc: node.loc
                 };
             }
          }
          break;
      }
      break;
    case 'CallExpression':
      if (node.callee.type === 'MemberExpression' &&
          isPDFJSPreprocessor(node.callee.object) &&
          node.callee.property.type === 'Identifier') {
        // PDFJSDev.xxxx(arg1, arg2, ...) => tranform
        var action = node.callee.property.name;
        return handlePreprocessorAction(ctx, action,
                                        node.arguments, node.loc);
      }
      break;
    case 'BlockStatement':
      var subExpressionIndex = 0;
      while (subExpressionIndex < node.body.length) {
        switch (node.body[subExpressionIndex].type) {
          case 'EmptyStatement':
            // Removing empty statements from the blocks.
            node.body.splice(subExpressionIndex, 1);
            continue;
          case 'BlockStatement':
            // Block statements inside a block are moved to the parent one.
            var subChildren = node.body[subExpressionIndex].body;
            Array.prototype.splice.apply(node.body,
              [subExpressionIndex, 1].concat(subChildren));
            subExpressionIndex += Math.max(subChildren.length - 1, 0);
            continue;
          case 'ReturnStatement':
          case 'ThrowStatement':
            // Removing dead code after return or throw.
            node.body.splice(subExpressionIndex + 1,
                             node.body.length - subExpressionIndex - 1);
            break;
        }
        subExpressionIndex++;
      }
      break;
    case 'FunctionDeclaration':
    case 'FunctionExpression':
      var block = node.body;
      if (block.body.length > 0 &&
          block.body[block.body.length - 1].type === 'ReturnStatement' &&
          !block.body[block.body.length - 1].argument) {
        // Function body ends with return without arg -- removing it.
        block.body.pop();
      }
      break;
    case 'Program':
      // Checking for a function closure that looks like UMD header.
      node.body.some(function (item, index) {
        // Is it `(function (root, factory) { ? }(this, function (?) {?}));` ?
        if (item.type !== 'ExpressionStatement' ||
            item.expression.type !== 'CallExpression' ||
            item.expression.callee.type !== 'FunctionExpression' ||
            item.expression.callee.params.length !== 2 ||
            item.expression.arguments.length !== 2 ||
            item.expression.arguments[0].type !== 'ThisExpression' ||
            item.expression.arguments[1].type !== 'FunctionExpression') {
          return false;
        }
        var init = item.expression.callee;
        // Is init body looks like
        // `if (?) { ? } else if (typeof exports !== 'undefined') { ? } ...`?
        if (init.body.type !== 'BlockStatement' ||
            init.body.body.length !== 1 ||
            init.body.body[0].type !== 'IfStatement') {
          return false;
        }
        var initIf = init.body.body[0];
        if (initIf.alternate.type !== 'IfStatement' ||
            initIf.alternate.test.type !== 'BinaryExpression' ||
            initIf.alternate.test.operator !== '!==' ||
            initIf.alternate.test.left.type !== 'UnaryExpression' ||
            initIf.alternate.test.left.operator !== 'typeof' ||
            initIf.alternate.test.left.argument.type !== 'Identifier' ||
            initIf.alternate.test.left.argument.name !== 'exports' ||
            initIf.alternate.test.right.type !== 'Literal' ||
            initIf.alternate.test.right.value !== 'undefined' ||
            initIf.alternate.consequent.type !== 'BlockStatement') {
          return false;
        }
        var commonJsInit = initIf.alternate.consequent;
        // Is commonJsInit `factory(exports, ...)` ?
        if (commonJsInit.body.length !== 1 ||
            commonJsInit.body[0].type !== 'ExpressionStatement' ||
            commonJsInit.body[0].expression.type !== 'CallExpression' ||
            commonJsInit.body[0].expression.callee.type !== 'Identifier') {
          return false;
        }
        var commonJsInitArgs = commonJsInit.body[0].expression.arguments;
        if (commonJsInitArgs.length === 0 ||
            commonJsInitArgs[0].type !== 'Identifier' ||
            commonJsInitArgs[0].name !== 'exports') {
          return false;
        }
        var factory = item.expression.arguments[1];
        // Is factory `function (exports, ....) { ? }` ?
        if (factory.params.length === 0 ||
            factory.params[0].type !== 'Identifier' ||
            factory.params[0].name !== 'exports' ||
            factory.body.type !== 'BlockStatement') {
          return true;
        }
        var factoryParams = factory.params;
        var factoryBody = factory.body;

        // Remove closure and function and replacing parameters with vars.
        node.body.splice(index, 1);
        for (var i = 1, ii = factoryParams.length; i < ii; i++) {
          var varNode = {
            type: 'VariableDeclaration',
            'declarations': [{
                type: 'VariableDeclarator',
                id: factoryParams[i],
                init: commonJsInitArgs[i] || null,
                loc: factoryParams[i].loc
            }],
            kind: 'var'
          };
          node.body.splice(index++, 0, varNode);
        }
        factoryBody.body.forEach(function (item) {
          node.body.splice(index++, 0, item);
        });
        return true;
      });
      break;
  }
  return node;
}

function fixComments(ctx, node) {
  if (!ctx.saveComments) {
    return;
  }
  // Fixes double comments in the escodegen output.
  delete node.trailingComments;
  // Removes ESLint and other service comments.
  if (node.leadingComments) {
    var CopyrightRegExp = /\bcopyright\b/i;
    var BlockCommentRegExp = /^\s*(globals|eslint|falls through)\b/;
    var LineCommentRegExp = /^\s*eslint\b/;

    var i = 0;
    while (i < node.leadingComments.length) {
      var type = node.leadingComments[i].type;
      var value = node.leadingComments[i].value;

      if (ctx.saveComments === 'copyright') {
        // Remove all comments, except Copyright notices and License headers.
        if (!(type === 'Block' && CopyrightRegExp.test(value))) {
          node.leadingComments.splice(i, 1);
          continue;
        }
      } else if ((type === 'Block' && BlockCommentRegExp.test(value)) ||
                 (type === 'Line' && LineCommentRegExp.test(value))) {
        node.leadingComments.splice(i, 1);
        continue;
      }
      i++;
    }
  }
}

function traverseTree(ctx, node) {
  // generic node processing
  for (var i in node) {
    var child = node[i];
    if (typeof child === 'object' && child !== null && child.type) {
      var result = traverseTree(ctx, child);
      if (result !== child) {
        node[i] = result;
      }
    } else if (Array.isArray(child)) {
      child.forEach(function (childItem, index) {
        if (typeof childItem === 'object' && childItem !== null &&
            childItem.type) {
          var result = traverseTree(ctx, childItem);
          if (result !== childItem) {
            child[index] = result;
          }
        }
      });
    }
  }

  node = postprocessNode(ctx, node) || node;

  fixComments(ctx, node);
  return node;
}

function preprocessPDFJSCode(ctx, code) {
  var saveComments = !!ctx.saveComments;
  var format = ctx.format || {
    indent: {
      style: ' ',
      adjustMultilineComment: saveComments,
    }
  };
  var comments;
  var parseComment = {
    locations: true,
    onComments: saveComments || (comments = []),
    sourceType: 'module',
  };
  var codegenOptions = {
    format: format,
    comment: saveComments,
    parse: acorn.parse,
  };
  var syntax = acorn.parse(code, parseComment);
  if (saveComments) {
    escodegen.attachComments(syntax, comments);
  }
  traverseTree(ctx, syntax);
  return escodegen.generate(syntax, codegenOptions);
}

exports.preprocessPDFJSCode = preprocessPDFJSCode;