// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import * as Acorn from '../../third_party/acorn/acorn.js';

import {AcornTokenizer, ECMA_VERSION, type TokenOrComment} from './AcornTokenizer.js';
import {ESTreeWalker} from './ESTreeWalker.js';
import type {FormattedContentBuilder} from './FormattedContentBuilder.js';

export class JavaScriptFormatter {
  readonly #builder: FormattedContentBuilder;
  #tokenizer!: AcornTokenizer;
  #content!: string;
  #fromOffset!: number;
  #lastLineNumber!: number;
  #toOffset?: number;
  constructor(builder: FormattedContentBuilder) {
    this.#builder = builder;
  }

  format(text: string, _lineEndings: number[], fromOffset: number, toOffset: number): void {
    this.#fromOffset = fromOffset;
    this.#toOffset = toOffset;
    this.#content = text.substring(this.#fromOffset, this.#toOffset);
    this.#lastLineNumber = 0;
    const tokens: Array<Acorn.Token|Acorn.Comment> = [];
    const ast = Acorn.parse(this.#content, {
      ranges: false,
      preserveParens: true,
      allowAwaitOutsideFunction: true,
      allowImportExportEverywhere: true,
      ecmaVersion: ECMA_VERSION,
      allowHashBang: true,
      onToken: tokens as Acorn.Token[],
      onComment: tokens as Acorn.Comment[],
    });
    this.#tokenizer = new AcornTokenizer(this.#content, tokens);
    const walker = new ESTreeWalker(this.#beforeVisit.bind(this), this.#afterVisit.bind(this));
    // @ts-expect-error Technically, the acorn Node type is a subclass of Acorn.ESTree.Node.
    // However, the acorn package currently exports its type without specifying
    // this relationship. So while this is allowed on runtime, we can't properly
    // typecheck it.
    walker.walk(ast);
  }

  #push(token: Acorn.Token|Acorn.Comment|null, format: string): void {
    for (let i = 0; i < format.length; ++i) {
      if (format[i] === 's') {
        this.#builder.addSoftSpace();
      } else if (format[i] === 'S') {
        this.#builder.addHardSpace();
      } else if (format[i] === 'n') {
        this.#builder.addNewLine();
      } else if (format[i] === '>') {
        this.#builder.increaseNestingLevel();
      } else if (format[i] === '<') {
        this.#builder.decreaseNestingLevel();
      } else if (format[i] === 't') {
        if (this.#tokenizer.tokenLineStart() - this.#lastLineNumber > 1) {
          this.#builder.addNewLine(true);
        }
        this.#lastLineNumber = this.#tokenizer.tokenLineEnd();
        if (token) {
          this.#builder.addToken(this.#content.substring(token.start, token.end), this.#fromOffset + token.start);
        }
      }
    }
  }

  #beforeVisit(node: Acorn.ESTree.Node): undefined {
    if (!node.parent) {
      return;
    }
    if (node.type === 'TemplateLiteral') {
      this.#builder.setEnforceSpaceBetweenWords(false);
    }
    let token;
    while ((token = this.#tokenizer.peekToken()) && token.start < node.start) {
      const token = (this.#tokenizer.nextToken() as TokenOrComment);
      // @ts-expect-error Same reason as above about Acorn types and ESTree types
      const format = this.#formatToken(node.parent, token);
      this.#push(token, format);
    }
  }

  #afterVisit(node: Acorn.ESTree.Node): void {
    // ${expressions} within a template literal need space enforced.
    const restore = this.#builder.setEnforceSpaceBetweenWords(node.type !== 'TemplateElement');
    let token;
    while ((token = this.#tokenizer.peekToken()) && token.start < node.end) {
      const token = (this.#tokenizer.nextToken() as TokenOrComment);
      const format = this.#formatToken(node, token);
      this.#push(token, format);
    }
    this.#push(null, this.#finishNode(node));
    this.#builder.setEnforceSpaceBetweenWords(restore || node.type === 'TemplateLiteral');
  }

  #inForLoopHeader(node: Acorn.ESTree.Node): boolean {
    const parent = node.parent;
    if (!parent) {
      return false;
    }
    if (parent.type === 'ForStatement') {
      const parentNode = (parent as Acorn.ESTree.ForStatement);
      return node === parentNode.init || node === parentNode.test || node === parentNode.update;
    }
    if (parent.type === 'ForInStatement' || parent.type === 'ForOfStatement') {
      const parentNode = (parent as Acorn.ESTree.ForInStatement | Acorn.ESTree.ForOfStatement);
      return node === parentNode.left || node === parentNode.right;
    }
    return false;
  }

  #formatToken(node: Acorn.ESTree.Node, tokenOrComment: TokenOrComment): string {
    const AT = AcornTokenizer;
    if (AT.lineComment(tokenOrComment)) {
      return 'tn';
    }
    if (AT.blockComment(tokenOrComment)) {
      return 'tn';
    }
    const token = (tokenOrComment as Acorn.Token);
    const nodeType = node.type;
    if (nodeType === 'ContinueStatement' || nodeType === 'BreakStatement') {
      return node.label && AT.keyword(token) ? 'ts' : 't';
    }
    if (nodeType === 'Identifier') {
      return 't';
    }
    if (nodeType === 'PrivateIdentifier') {
      return 't';
    }
    if (nodeType === 'ReturnStatement') {
      if (AT.punctuator(token, ';')) {
        return 't';
      }
      return node.argument ? 'ts' : 't';
    }
    if (nodeType === 'AwaitExpression') {
      if (AT.punctuator(token, ';')) {
        return 't';
      }
      return node.argument ? 'ts' : 't';
    }
    if (nodeType === 'Property') {
      if (AT.punctuator(token, ':')) {
        return 'ts';
      }
      return 't';
    }
    if (nodeType === 'ArrayExpression') {
      if (AT.punctuator(token, ',')) {
        return 'ts';
      }
      return 't';
    }
    if (nodeType === 'LabeledStatement') {
      if (AT.punctuator(token, ':')) {
        return 'ts';
      }
    } else if (
        nodeType === 'LogicalExpression' || nodeType === 'AssignmentExpression' || nodeType === 'BinaryExpression') {
      if (AT.punctuator(token) && !AT.punctuator(token, '()')) {
        return 'sts';
      }
    } else if (nodeType === 'ConditionalExpression') {
      if (AT.punctuator(token, '?:')) {
        return 'sts';
      }
    } else if (nodeType === 'VariableDeclarator') {
      if (AT.punctuator(token, '=')) {
        return 'sts';
      }
    } else if (nodeType === 'ObjectPattern') {
      if (node.parent?.type === 'VariableDeclarator' && AT.punctuator(token, '{')) {
        return 'st';
      }
      if (AT.punctuator(token, ',')) {
        return 'ts';
      }
    } else if (nodeType === 'FunctionDeclaration') {
      if (AT.punctuator(token, ',)')) {
        return 'ts';
      }
    } else if (nodeType === 'FunctionExpression') {
      if (AT.punctuator(token, ',)')) {
        return 'ts';
      }
      if (AT.keyword(token, 'function')) {
        return node.id ? 'ts' : 't';
      }
    } else if (nodeType === 'ArrowFunctionExpression') {
      if (AT.punctuator(token, ',)')) {
        return 'ts';
      }
      if (AT.punctuator(token, '(')) {
        return 'st';
      }
      if (AT.arrowIdentifier(token, '=>')) {
        return 'sts';
      }
    } else if (nodeType === 'WithStatement') {
      if (AT.punctuator(token, ')')) {
        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
      }
    } else if (nodeType === 'SwitchStatement') {
      if (AT.punctuator(token, '{')) {
        return 'tn>';
      }
      if (AT.punctuator(token, '}')) {
        return 'n<tn';
      }
      if (AT.punctuator(token, ')')) {
        return 'ts';
      }
    } else if (nodeType === 'SwitchCase') {
      if (AT.keyword(token, 'case')) {
        return 'n<ts';
      }
      if (AT.keyword(token, 'default')) {
        return 'n<t';
      }
      if (AT.punctuator(token, ':')) {
        return 'tn>';
      }
    } else if (nodeType === 'VariableDeclaration') {
      if (AT.punctuator(token, ',')) {
        let allVariablesInitialized = true;
        const declarations = (node.declarations as Acorn.ESTree.Node[]);
        for (let i = 0; i < declarations.length; ++i) {
          // @ts-expect-error We are doing a subtype check, without properly checking whether
          // it exists. We can't fix that, unless we use proper typechecking
          allVariablesInitialized = allVariablesInitialized && Boolean(declarations[i].init);
        }
        return !this.#inForLoopHeader(node) && allVariablesInitialized ? 'nSSts' : 'ts';
      }
    } else if (nodeType === 'PropertyDefinition') {
      if (AT.punctuator(token, '=')) {
        return 'sts';
      }
      if (AT.punctuator(token, ';')) {
        return 'tn';
      }
    } else if (nodeType === 'BlockStatement') {
      if (AT.punctuator(token, '{')) {
        return node.body.length ? 'tn>' : 't';
      }
      if (AT.punctuator(token, '}')) {
        return node.body.length ? 'n<t' : 't';
      }
    } else if (nodeType === 'CatchClause') {
      if (AT.punctuator(token, ')')) {
        return 'ts';
      }
    } else if (nodeType === 'ObjectExpression') {
      if (!node.properties.length) {
        return 't';
      }
      if (AT.punctuator(token, '{')) {
        return 'tn>';
      }
      if (AT.punctuator(token, '}')) {
        return 'n<t';
      }
      if (AT.punctuator(token, ',')) {
        return 'tn';
      }
    } else if (nodeType === 'IfStatement') {
      if (AT.punctuator(token, ')')) {
        return node.consequent?.type === 'BlockStatement' ? 'ts' : 'tn>';
      }

      if (AT.keyword(token, 'else')) {
        const preFormat = node.consequent?.type === 'BlockStatement' ? 'st' : 'n<t';
        let postFormat = 'n>';
        if (node.alternate && (node.alternate.type === 'BlockStatement' || node.alternate.type === 'IfStatement')) {
          postFormat = 's';
        }
        return preFormat + postFormat;
      }
    } else if (nodeType === 'CallExpression') {
      if (AT.punctuator(token, ',')) {
        return 'ts';
      }
    } else if (nodeType === 'SequenceExpression' && AT.punctuator(token, ',')) {
      return node.parent?.type === 'SwitchCase' ? 'ts' : 'tn';
    } else if (nodeType === 'ForStatement' || nodeType === 'ForOfStatement' || nodeType === 'ForInStatement') {
      if (AT.punctuator(token, ';')) {
        return 'ts';
      }
      if (AT.keyword(token, 'in') || AT.identifier(token, 'of')) {
        return 'sts';
      }

      if (AT.punctuator(token, ')')) {
        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
      }
    } else if (nodeType === 'WhileStatement') {
      if (AT.punctuator(token, ')')) {
        return node.body?.type === 'BlockStatement' ? 'ts' : 'tn>';
      }
    } else if (nodeType === 'DoWhileStatement') {
      const blockBody = node.body?.type === 'BlockStatement';
      if (AT.keyword(token, 'do')) {
        return blockBody ? 'ts' : 'tn>';
      }
      if (AT.keyword(token, 'while')) {
        return blockBody ? 'sts' : 'n<ts';
      }
      if (AT.punctuator(token, ';')) {
        return 'tn';
      }
    } else if (nodeType === 'ClassBody') {
      if (AT.punctuator(token, '{')) {
        return 'stn>';
      }
      if (AT.punctuator(token, '}')) {
        return '<ntn';
      }
      return 't';
    } else if (nodeType === 'YieldExpression') {
      return 't';
    } else if (nodeType === 'Super') {
      return 't';
    } else if (nodeType === 'ImportExpression') {
      return 't';
    } else if (nodeType === 'ExportAllDeclaration') {
      if (AT.punctuator(token, '*')) {
        return 'sts';
      }
      return 't';
    } else if (nodeType === 'ExportNamedDeclaration' || nodeType === 'ImportDeclaration') {
      if (AT.punctuator(token, '{')) {
        return 'st';
      }
      if (AT.punctuator(token, ',')) {
        return 'ts';
      }
      if (AT.punctuator(token, '}')) {
        return node.source ? 'ts' : 't';
      }
      if (AT.punctuator(token, '*')) {
        return 'sts';
      }
      return 't';
    } else if (nodeType === 'MemberExpression') {
      if (node.object.type === 'Literal' && typeof (node.object.value) === 'number') {
        return 'st';
      }
      return 't';
    }
    return AT.keyword(token) && !AT.keyword(token, 'this') ? 'ts' : 't';
  }

  #finishNode(node: Acorn.ESTree.Node): string {
    const nodeType = node.type;
    if (nodeType === 'WithStatement') {
      if (node.body && node.body.type !== 'BlockStatement') {
        return 'n<';
      }
    } else if (nodeType === 'VariableDeclaration') {
      if (!this.#inForLoopHeader(node)) {
        return 'n';
      }
    } else if (nodeType === 'ForStatement' || nodeType === 'ForOfStatement' || nodeType === 'ForInStatement') {
      if (node.body && node.body.type !== 'BlockStatement') {
        return 'n<';
      }
    } else if (nodeType === 'BlockStatement') {
      if (node.parent?.type === 'IfStatement') {
        const parentNode = (node.parent as Acorn.ESTree.IfStatement);
        if (parentNode.alternate && parentNode.consequent === node) {
          return '';
        }
      }
      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'Property') {
        return '';
      }
      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'VariableDeclarator') {
        return '';
      }
      if (node.parent?.type === 'FunctionExpression' && node.parent.parent?.type === 'CallExpression') {
        return '';
      }
      if (node.parent?.type === 'DoWhileStatement') {
        return '';
      }
      if (node.parent?.type === 'TryStatement') {
        const parentNode = (node.parent as Acorn.ESTree.TryStatement);
        if (parentNode.block === node) {
          return 's';
        }
      }
      if (node.parent?.type === 'CatchClause') {
        const parentNode = (node.parent as Acorn.ESTree.CatchClause);
        // @ts-expect-error We are doing a subtype check, without properly checking whether
        // it exists. We can't fix that, unless we use proper typechecking
        if (parentNode.parent?.finalizer) {
          return 's';
        }
      }
      return 'n';
    } else if (nodeType === 'WhileStatement') {
      if (node.body && node.body.type !== 'BlockStatement') {
        return 'n<';
      }
    } else if (nodeType === 'IfStatement') {
      if (node.alternate) {
        if (node.alternate.type !== 'BlockStatement' && node.alternate.type !== 'IfStatement') {
          return '<';
        }
      } else if (node.consequent) {
        if (node.consequent.type !== 'BlockStatement') {
          return '<';
        }
      }
    } else if (
        nodeType === 'BreakStatement' || nodeType === 'ContinueStatement' || nodeType === 'ThrowStatement' ||
        nodeType === 'ReturnStatement' || nodeType === 'ExpressionStatement') {
      return 'n';
    } else if (
        nodeType === 'ImportDeclaration' || nodeType === 'ExportAllDeclaration' ||
        nodeType === 'ExportDefaultDeclaration' || nodeType === 'ExportNamedDeclaration') {
      return 'n';
    }
    return '';
  }
}