/**
 * @license
 * Copyright 2015 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @fileoverview Helper functions for generating PHP for blocks.
 * @suppress {checkTypes|globalThis}
 */

import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.PHP');

import * as stringUtils from '../../core/utils/string.js';
// import type {Block} from '../../core/block.js';
import {CodeGenerator} from '../../core/generator.js';
import {Names} from '../../core/names.js';
// import type {Workspace} from '../../core/workspace.js';
import {inputTypes} from '../../core/inputs/input_types.js';


/**
 * Order of operation ENUMs.
 * http://php.net/manual/en/language.operators.precedence.php
 * @enum {number}
 */
export const Order = {
  ATOMIC: 0,             // 0 "" ...
  CLONE: 1,              // clone
  NEW: 1,                // new
  MEMBER: 2.1,           // []
  FUNCTION_CALL: 2.2,    // ()
  POWER: 3,              // **
  INCREMENT: 4,          // ++
  DECREMENT: 4,          // --
  BITWISE_NOT: 4,        // ~
  CAST: 4,               // (int) (float) (string) (array) ...
  SUPPRESS_ERROR: 4,     // @
  INSTANCEOF: 5,         // instanceof
  LOGICAL_NOT: 6,        // !
  UNARY_PLUS: 7.1,       // +
  UNARY_NEGATION: 7.2,   // -
  MULTIPLICATION: 8.1,   // *
  DIVISION: 8.2,         // /
  MODULUS: 8.3,          // %
  ADDITION: 9.1,         // +
  SUBTRACTION: 9.2,      // -
  STRING_CONCAT: 9.3,    // .
  BITWISE_SHIFT: 10,     // << >>
  RELATIONAL: 11,        // < <= > >=
  EQUALITY: 12,          // == != === !== <> <=>
  REFERENCE: 13,         // &
  BITWISE_AND: 13,       // &
  BITWISE_XOR: 14,       // ^
  BITWISE_OR: 15,        // |
  LOGICAL_AND: 16,       // &&
  LOGICAL_OR: 17,        // ||
  IF_NULL: 18,           // ??
  CONDITIONAL: 19,       // ?:
  ASSIGNMENT: 20,        // = += -= *= /= %= <<= >>= ...
  LOGICAL_AND_WEAK: 21,  // and
  LOGICAL_XOR: 22,       // xor
  LOGICAL_OR_WEAK: 23,   // or
  NONE: 99,              // (...)
};

export class PhpGenerator extends CodeGenerator {
  /**
   * List of outer-inner pairings that do NOT require parentheses.
   * @type {!Array<!Array<number>>}
   */
  ORDER_OVERRIDES = [
    // (foo()).bar() -> foo().bar()
    // (foo())[0] -> foo()[0]
    [Order.MEMBER, Order.FUNCTION_CALL],
    // (foo[0])[1] -> foo[0][1]
    // (foo.bar).baz -> foo.bar.baz
    [Order.MEMBER, Order.MEMBER],
    // !(!foo) -> !!foo
    [Order.LOGICAL_NOT, Order.LOGICAL_NOT],
    // a * (b * c) -> a * b * c
    [Order.MULTIPLICATION, Order.MULTIPLICATION],
    // a + (b + c) -> a + b + c
    [Order.ADDITION, Order.ADDITION],
    // a && (b && c) -> a && b && c
    [Order.LOGICAL_AND, Order.LOGICAL_AND],
    // a || (b || c) -> a || b || c
    [Order.LOGICAL_OR, Order.LOGICAL_OR]
  ];

  constructor(name) {
    super(name ?? 'PHP');
    this.isInitialized = false;

    // Copy Order values onto instance for backwards compatibility
    // while ensuring they are not part of the publically-advertised
    // API.
    //
    // TODO(#7085): deprecate these in due course.  (Could initially
    // replace data properties with get accessors that call
    // deprecate.warn().)
    for (const key in Order) {
      this['ORDER_' + key] = Order[key];
    }

    // List of illegal variable names.  This is not intended to be a
    // security feature.  Blockly is 100% client-side, so bypassing
    // this list is trivial.  This is intended to prevent users from
    // accidentally clobbering a built-in object or function.
    this.addReservedWords(
      // http://php.net/manual/en/reserved.keywords.php
      '__halt_compiler,abstract,and,array,as,break,callable,case,catch,class,' +
      'clone,const,continue,declare,default,die,do,echo,else,elseif,empty,' +
      'enddeclare,endfor,endforeach,endif,endswitch,endwhile,eval,exit,' +
      'extends,final,for,foreach,function,global,goto,if,implements,include,' +
      'include_once,instanceof,insteadof,interface,isset,list,namespace,new,' +
      'or,print,private,protected,public,require,require_once,return,static,' +
      'switch,throw,trait,try,unset,use,var,while,xor,' +
      // http://php.net/manual/en/reserved.constants.php
      'PHP_VERSION,PHP_MAJOR_VERSION,PHP_MINOR_VERSION,PHP_RELEASE_VERSION,' +
      'PHP_VERSION_ID,PHP_EXTRA_VERSION,PHP_ZTS,PHP_DEBUG,PHP_MAXPATHLEN,' +
      'PHP_OS,PHP_SAPI,PHP_EOL,PHP_INT_MAX,PHP_INT_SIZE,DEFAULT_INCLUDE_PATH,' +
      'PEAR_INSTALL_DIR,PEAR_EXTENSION_DIR,PHP_EXTENSION_DIR,PHP_PREFIX,' +
      'PHP_BINDIR,PHP_BINARY,PHP_MANDIR,PHP_LIBDIR,PHP_DATADIR,' +
      'PHP_SYSCONFDIR,PHP_LOCALSTATEDIR,PHP_CONFIG_FILE_PATH,' +
      'PHP_CONFIG_FILE_SCAN_DIR,PHP_SHLIB_SUFFIX,E_ERROR,E_WARNING,E_PARSE,' +
      'E_NOTICE,E_CORE_ERROR,E_CORE_WARNING,E_COMPILE_ERROR,' +
      'E_COMPILE_WARNING,E_USER_ERROR,E_USER_WARNING,E_USER_NOTICE,' +
      'E_DEPRECATED,E_USER_DEPRECATED,E_ALL,E_STRICT,' +
      '__COMPILER_HALT_OFFSET__,TRUE,FALSE,NULL,__CLASS__,__DIR__,__FILE__,' +
      '__FUNCTION__,__LINE__,__METHOD__,__NAMESPACE__,__TRAIT__'
    );
  }

  /**
   * Initialise the database of variable names.
   * @param {!Workspace} workspace Workspace to generate code from.
   */
  init(workspace) {
    super.init(workspace);

    if (!this.nameDB_) {
      this.nameDB_ = new Names(this.RESERVED_WORDS_, '$');
    } else {
      this.nameDB_.reset();
    }

    this.nameDB_.setVariableMap(workspace.getVariableMap());
    this.nameDB_.populateVariables(workspace);
    this.nameDB_.populateProcedures(workspace);

    this.isInitialized = true;
  };

  /**
   * Prepend the generated code with the variable definitions.
   * @param {string} code Generated code.
   * @return {string} Completed code.
   */
  finish(code) {
    // Convert the definitions dictionary into a list.
    const definitions = Object.values(this.definitions_);
    // Call Blockly.CodeGenerator's finish.
    code = super.finish(code);
    this.isInitialized = false;

    this.nameDB_.reset();
    return definitions.join('\n\n') + '\n\n\n' + code;
  };

  /**
   * Naked values are top-level blocks with outputs that aren't plugged into
   * anything.  A trailing semicolon is needed to make this legal.
   * @param {string} line Line of generated code.
   * @return {string} Legal line of code.
   */
  scrubNakedValue(line) {
    return line + ';\n';
  };

  /**
   * Encode a string as a properly escaped PHP string, complete with
   * quotes.
   * @param {string} string Text to encode.
   * @return {string} PHP string.
   */
  quote_(string) {
    string = string.replace(/\\/g, '\\\\')
        .replace(/\n/g, '\\\n')
        .replace(/'/g, '\\\'');
    return '\'' + string + '\'';
  };

  /**
   * Encode a string as a properly escaped multiline PHP string, complete with
   * quotes.
   * @param {string} string Text to encode.
   * @return {string} PHP string.
   */
  multiline_quote_(string) {
    const lines = string.split(/\n/g).map(this.quote_);
    // Join with the following, plus a newline:
    // . "\n" .
    // Newline escaping only works in double-quoted strings.
    return lines.join(' . \"\\n\" .\n');
  };

  /**
   * Common tasks for generating PHP from blocks.
   * Handles comments for the specified block and any connected value blocks.
   * Calls any statements following this block.
   * @param {!Block} block The current block.
   * @param {string} code The PHP code created for this block.
   * @param {boolean=} opt_thisOnly True to generate code for only this
   *     statement.
   * @return {string} PHP code with comments and subsequent blocks added.
   * @protected
   */
  scrub_(block, code, opt_thisOnly) {
    let commentCode = '';
    // Only collect comments for blocks that aren't inline.
    if (!block.outputConnection || !block.outputConnection.targetConnection) {
      // Collect comment for this block.
      let comment = block.getCommentText();
      if (comment) {
        comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
        commentCode += this.prefixLines(comment, '// ') + '\n';
      }
      // Collect comments for all value arguments.
      // Don't collect comments for nested statements.
      for (let i = 0; i < block.inputList.length; i++) {
        if (block.inputList[i].type === inputTypes.VALUE) {
          const childBlock = block.inputList[i].connection.targetBlock();
          if (childBlock) {
            comment = this.allNestedComments(childBlock);
            if (comment) {
              commentCode += this.prefixLines(comment, '// ');
            }
          }
        }
      }
    }
    const nextBlock =
        block.nextConnection && block.nextConnection.targetBlock();
    const nextCode = opt_thisOnly ? '' : this.blockToCode(nextBlock);
    return commentCode + code + nextCode;
  };

  /**
   * Gets a property and adjusts the value while taking into account indexing.
   * @param {!Block} block The block.
   * @param {string} atId The property ID of the element to get.
   * @param {number=} opt_delta Value to add.
   * @param {boolean=} opt_negate Whether to negate the value.
   * @param {number=} opt_order The highest order acting on this value.
   * @return {string|number}
   */
  getAdjusted(block, atId, opt_delta, opt_negate, opt_order) {
    let delta = opt_delta || 0;
    let order = opt_order || this.ORDER_NONE;
    if (block.workspace.options.oneBasedIndex) {
      delta--;
    }
    let defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
    let outerOrder = order;
    let innerOrder;
    if (delta > 0) {
      outerOrder = this.ORDER_ADDITION;
      innerOrder = this.ORDER_ADDITION;
    } else if (delta < 0) {
      outerOrder = this.ORDER_SUBTRACTION;
      innerOrder = this.ORDER_SUBTRACTION;
    } else if (opt_negate) {
      outerOrder = this.ORDER_UNARY_NEGATION;
      innerOrder = this.ORDER_UNARY_NEGATION;
    }
    let at = this.valueToCode(block, atId, outerOrder) || defaultAtIndex;

    if (stringUtils.isNumber(at)) {
      // If the index is a naked number, adjust it right now.
      at = Number(at) + delta;
      if (opt_negate) {
        at = -at;
      }
    } else {
      // If the index is dynamic, adjust it in code.
      if (delta > 0) {
        at = at + ' + ' + delta;
      } else if (delta < 0) {
        at = at + ' - ' + -delta;
      }
      if (opt_negate) {
        if (delta) {
          at = '-(' + at + ')';
        } else {
          at = '-' + at;
        }
      }
      innerOrder = Math.floor(innerOrder);
      order = Math.floor(order);
      if (innerOrder && order >= innerOrder) {
        at = '(' + at + ')';
      }
    }
    return at;
  };
}