<?hh // strict
/**
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

abstract class BaseCodeBuilder implements ICodeBuilder {

  const string DELIMITER = "\t";

  private StrBuffer $code;
  private bool $isNewLine = true;
  private int $indentationLevel = 0;
  private bool $isInsideFunction = false;
  private bool $wasGetCodeCalled = false;

  final public function __construct(private IHackCodegenConfig $config) {
    $this->code = new StrBuffer();
  }

  final public function newLine(): this {
    $this->code->append("\n");
    $this->isNewLine = true;
    return $this;
  }

  /**
   * If the cursor is not in a new line, it will insert a line break.
   */
  final public function ensureNewLine(): this {
    if (!$this->isNewLine) {
      $this->newLine();
    }
    return $this;
  }

  /**
   * Ensures that the cursor is in a new line right after an empty line.
   */
  final public function ensureEmptyLine(): this {
    return $this->ensureNewLine()->newLine();
  }

  /**
   * Add the code to the buffer (sprintf style may be used).
   * It automatically deals with indentation.  The code may contain line breaks.
   * If code is null, nothing will be added
   */
  /* HH_FIXME[4033] variadic params with type constraints are not supported */
  final public function add(?string $code, ...$args): this {
    return $this->addv($code, $args);
  }

  final protected function addv(?string $code, array<mixed> $args): this {
    if ($code === null) {
      return $this;
    }

    if (count($args)) {
      $code = vsprintf($code, $args);
    }

    // break into lines and add one by one to handle indentation
    $lines = explode("\n", $code);
    $last_line = array_pop($lines);
    foreach ($lines as $line) {
      $this->addLine($line);
    }

    if (trim($last_line) === '') {
      return $this;
    }

    // if we're in a new line, insert indentation
    if ($this->isNewLine) {
      if ($this->indentationLevel !== 0) {
        $n = $this->config->getSpacesPerIndentation() * $this->indentationLevel;
        $this->code->append(str_repeat(' ', $n));
      }
      $this->isNewLine = false;
    }

    $this->code->append($last_line);

    return $this;
  }

  /**
   * If the condition evaluates to true, the code will be added to the buffer.
   */
  final public function addIf(bool $condition, string $code, ...): this {
    if ($condition) {
      $this->addv($code, array_slice(func_get_args(), 2));
    }
    return $this;
  }

  final protected function addLineImpl(
    ?string $code,
    array<mixed> $args,
  ): this {
    return $this->addv($code, $args)->newLine();
  }

  /**
   * If the condition evaluates to true, the code will be added to the buffer
   * with a new line.
   */
  final public function addLineIf(bool $condition, string $code, ...): this {
    if ($condition) {
      $this->addLineImpl($code, array_slice(func_get_args(), 2));
    }
    return $this;
  }

  /**
   * Add the code to the buffer followed by a new line.
   * If code is null, nothing will be added
   */
  /* HH_FIXME[4033] variadic params with type constraints are not supported */
  final public function addLine(?string $code, ...$args): this {
    return $this->addLineImpl($code, $args);
  }

  /**
   * Add each element of the vector as a new line
   */
  final public function addLines(ConstVector<string> $lines): this {
    foreach ($lines as $line) {
      $this->addLine($line);
    }
    return $this;
  }

  /**
   * Indicate that the code that will follow will be inside a function, so that
   * the indentation is taken into account for the max line length.
   */
  final public function setIsInsideFunction(): this {
    $this->isInsideFunction = true;
    return $this;
  }

  /**
   * Let's the user suggest linebreaks in the code string provided, marked by
   * the delimiter. The max length is calculated based on the current
   * indentation level.
   * If the code string exceeds the max length
   *        - Preferentially uses the delimiter to break the line
   *        - If some part is too big to fit, it lets it be.
   * If the code string or a part doesn't exceed the max length
   *        - Replaces the delimiter with space.
   *
   * @param delimiter e.g "\t" The function respects all other chars except
   *                  the delimiter which it always replaces
   *                  either with " " or "\n".
   */
  final public function addWithSuggestedLineBreaks(
    ?string $code,
    ...
  ): this {
    if ($code === null) {
      return $this;
    }

    // If there's more than 1 line, add them 1 by 1
    $lines = Str::explode("\n", $code);
    if ($lines->count() > 1) {
      // The last line shouldn't have a finishing end line,
      // so add it manually
      $last_line = $lines->pop();
      $this->addLinesWithSuggestedLineBreaks($lines);
      return $this->addWithSuggestedLineBreaks($last_line);
    }

    $args = array_slice(func_get_args(), 1);
    if (count($args)) {
      $code = vsprintf($code, $args);
    }
    // Subtracting two to allow space for indenting and/or opening braces.
    $max_length = $this->getMaxCodeLength() - 2;
    if ($this->isInsideFunction) {
      // Please note that this method is called both from inside a function or
      // stuff like class/func declaration.
      $max_length = $max_length - 2;
    }

    $lines_with_sugg_breaks = explode(self::DELIMITER, $code);
    $final_lines = Vector {};
    foreach ($lines_with_sugg_breaks as $line) {
      if (!$line) {
        // Continue if the line is empty
        continue;
      }
      invariant(is_string($line), 'For Hack');
      if ($final_lines->isEmpty()) {
        $final_lines->add($line);
      } else {
        $last_line = $final_lines->pop();
        $composite_line = $last_line . ' ' . $line;
        if (strlen($composite_line) > $max_length) {
          $final_lines->add($last_line)->add($line);
        } else {
          // Concatenate the line to the last line
          $final_lines->add($composite_line);
        }
      }
    }
    return $this->add(implode("\n  ", $final_lines->toArray()));
  }

  /**
   * Similar to addWithSuggestedLineBreaks but allows to add more than one
   * line at a time.  See that method for more information.
   */
  final public function addLinesWithSuggestedLineBreaks(
    Vector<string> $lines,
  ): this {
    foreach ($lines as $line) {
      $this->addWithSuggestedLineBreaks($line)->newLine();
    }
    return $this;
  }

  final protected function setIndentationLevel(int $level): void {
    $this->indentationLevel = $level;
  }

  final protected static function checkIfLineIsTooLong(
    string $code,
    int $max_length,
  ): bool {
    $line_too_long = false;
    foreach (explode("\n", $code) as $line) {
      if (strlen($line) > $max_length) {
        $line_too_long = true;
        break;
      }
    }
    return $line_too_long;
  }

  /**
   * Returns the maximum length of code based on the current identation level.
   */
  final protected function getMaxCodeLength(): int {
    return $this->config->getMaxLineLength() -
      $this->config->getSpacesPerIndentation() * $this->indentationLevel;
  }

  final public function indent(): this {
    $this->indentationLevel++;
    return $this;
  }

  final public function unindent(): this {
    invariant(
      $this->indentationLevel >= 1,
      'Indentation level cannot go below zero.',
    );
    $this->indentationLevel--;
    return $this;
  }

  /**
   * Get the code that was inserted in the buffer.
   */
  final public function getCode(): string {
    invariant(
      !$this->wasGetCodeCalled,
      "You may only call getCode() once on a given HackBuilder object.",
    );
    $this->wasGetCodeCalled = true;
    return $this->code->detach();
  }

  /**
   * clone() doesn't work as they end up sharing the same String Buffer, sharing
   * all the history (code already added to it).
   * So, if code is detached from the clone, it gets detached from original
   * builder as well.
   * This doesn't bother about the history, just copies the settings.
   */
  final protected function getClone(): this {
    $builder = new static($this->config);
    if ($this->isInsideFunction) {
      $builder->setIsInsideFunction();
    }
    $builder->setIndentationLevel($this->indentationLevel);
    return $builder;
  }

  /**
   * Add to the buffer the begin of a manual section with the specified id.
   */
  public function beginManualSection(string $id): this {
    return $this
      ->ensureNewLine()
      ->addLine(PartiallyGeneratedCode::getBeginManualSection($id));
  }

  /**
   * Add to the buffer the end of a manual section.
   */
  public function endManualSection(): this {
    return $this
      ->ensureNewLine()
      ->addLine(PartiallyGeneratedCode::getEndManualSection());
  }
}