// This file is part of AsmJit project <https://asmjit.com>
//
// See <asmjit/core.h> or LICENSE.md for license and copyright information
// SPDX-License-Identifier: Zlib

// C++ code generation helpers.
const commons = require("./generator-commons.js");
const FATAL = commons.FATAL;

// Utilities to convert primitives to C++ code.
class Utils {
  static toHexRaw(val, pad) {
    if (val < 0)
      val = 0xFFFFFFFF + val + 1;

    let s = val.toString(16);
    if (pad != null && s.length < pad)
      s = "0".repeat(pad - s.length) + s;

    return s.toUpperCase();
  }

  static toHex(val, pad) {
    return "0x" + Utils.toHexRaw(val, pad);
  }

  static capitalize(s) {
    s = String(s);
    return !s ? s : s[0].toUpperCase() + s.substr(1);
  }

  static camelCase(s) {
    if (s == null || s === "")
      return s;

    s = String(s);
    if (/^[A-Z]+$/.test(s))
      return s.toLowerCase();
    else
      return s[0].toLowerCase() + s.substr(1);
  }

  static normalizeSymbolName(s) {
    switch (s) {
      case "and":
      case "or":
      case "xor":
        return s + "_";
      default:
        return s;
    }
  }

  static indent(s, indentation) {
    if (typeof indentation === "number")
      indentation = " ".repeat(indentation);

    var lines = s.split(/\r?\n/g);
    if (indentation) {
      for (var i = 0; i < lines.length; i++) {
        var line = lines[i];
        if (line)
          lines[i] = indentation + line;
      }
    }

    return lines.join("\n");
  }
}
exports.Utils = Utils;

// A node that represents a C++ construct.
class Node {
  constructor(kind) {
    this.kind = kind;
  }
};
exports.Node = Node;

// A single line of C++ code that declares a variable with optional initialization.
class Var extends Node {
  constructor(type, name, init) {
    super("var");

    this.type = type;
    this.name = name;
    this.init = init || "";
  }

  toString() {
    let s = this.type + " " + this.name;
    if (this.init)
      s += " = " + this.init;
    return s + ";\n";
  }
};
exports.Var = Var;

// A single line of C++ code, which should not contain any branch or a variable declaration.
class Line extends Node {
  constructor(code) {
    super("line");

    this.code = code;
  }

  toString() {
    return String(this.code) + "\n";
  }
};
exports.Line = Line;

// A block containing an array of `Node` items (may contain nested blocks, etc...).
class Block extends Node {
  constructor(nodes) {
    super("block");

    this.nodes = nodes || [];
  }

  isEmpty() {
    return this.nodes.length === 0;
  }

  appendNode(node) {
    if (!(node instanceof Node))
      FATAL("Block.appendNode(): Node must be an instance of Node");

    this.nodes.push(node);
    return this;
  }

  prependNode(node) {
    if (!(node instanceof Node))
      FATAL("Block.prependNode(): Node must be an instance of Node");

    this.nodes.unshift(node);
    return this;
  }

  insertNode(index, node) {
    if (!(node instanceof Node))
      FATAL("Block.insertNode(): Node must be an instance of Node");

    if (index >= this.nodes.length)
      this.nodes.push(node);
    else
      this.nodes.splice(index, 0, node);

    return this;
  }

  addVarDecl(type, name, init) {
    let node = type;

    if (!(node instanceof Var))
      node = new Var(type, name, init);

    let i = 0;
    while (i < this.nodes.length) {
      const n = this.nodes[i];
      if (n.kind === "var" && n.name === node.name && n.init === node.init)
        return this;

      if (n.kind !== "var")
        break;

      i++;
    }

    this.insertNode(i, node);
    return this;
  }

  addLine(code) {
    if (typeof code !== "string")
      FATAL("Block.addLine(): Line must be string");

    this.nodes.push(new Line(code));
    return this;
  }

  prependEmptyLine() {
    if (!this.isEmpty())
      this.nodes.splice(0, 0, new Line(""));
    return this;
  }

  addEmptyLine() {
    if (!this.isEmpty())
      this.nodes.push(new Line(""));
    return this;
  }

  toString() {
    let s = "";
    for (let node of this.nodes)
      s += String(node);
    return s;
  }
}
exports.Block = Block;

// A C++ 'condition' (if statement) and its 'body' if it's taken.
class If extends Node {
  constructor(cond, body) {
    super("if");

    if (body == null)
      body = new Block();

    if (!(body instanceof Block))
      FATAL("If() - body must be a Block");

    this.cond = cond;
    this.body = body;
  }

  toString() {
    const cond = String(this.cond);
    const body = String(this.body);

    return `if (${cond}) {\n` + Utils.indent(body, 2) + `}\n`;
  }
}
exports.If = If;

//! A C++ switch statement.
class Case extends Node {
  constructor(cond, body) {
    super("case");

    this.cond = cond;
    this.body = body || new Block();
  }

  toString() {
    let s = "";
    for (let node of this.body.nodes)
      s += String(node)

    if (this.cond !== "default")
      return `case ${this.cond}: {\n` + Utils.indent(s, 2) + `}\n`;
    else
      return `default: {\n` + Utils.indent(s, 2) + `}\n`;
  }
};
exports.Case = Case;

class Switch extends Node {
  constructor(expression, cases) {
    super("switch");

    this.expression = expression;
    this.cases = cases || [];
  }

  addCase(cond, body) {
    this.cases.push(new Case(cond, body));
    return this;
  }

  toString() {
    let s = "";
    for (let c of this.cases) {
      if (s)
        s += "\n";
      s += String(c);
    }

    return `switch (${this.expression}) {\n` + Utils.indent(s, 2) + `}\n`;
  }
}
exports.Switch = Switch;
