import { escapeHtml } from "./helpers";
import { AtLeast, Choose, End, Pattern, Regex, Sequence, Use } from "./peg";
import {
  Word as WordType,
  TextWord,
  EnchantedWord as EnchantedWordType,
  SimplifyWord,
} from "./words";

export type Command = WordType[];
export type Script = Command[];

const Comment = Regex(/#[^\n]*/y)
  .expects("#")
  .map(() => []);

const PreWordWhitespace = Regex(/[^\S\n;]+/y).expects("whitespace");

const EnchantedWord = Regex(/[^\]\[\}\{$\\";\s]+(?=[\s;]|$)/y)
  .map(([enchanted]) => ({ enchanted } as EnchantedWordType))
  .expects("ENCHANTED_WORD");

const BackslashEscape = Regex(/\\(.)/y)
  .expects("\\")
  .map(([, char]) => ({ text: char }));

const BareWord = Sequence(
  AtLeast(
    1,
    Choose(
      BackslashEscape,
      Regex(/[^\s\\;]+/y)
        .expects("CHAR")
        .map(([text]) => ({ text }))
    )
  )
).map(([pieces]) => SimplifyWord(pieces));

const QuotedWord = Sequence(
  Regex(/"/y).expects('"'),
  AtLeast(
    0,
    Choose(
      BackslashEscape,
      Regex(/[^"\\]+/y)
        .expects("CHAR")
        .map(([text]) => ({ text }))
    )
  ),
  Regex(/"/y).expects('"')
).map(([, pieces]) => SimplifyWord(pieces));

const Brace: Pattern<string> = Sequence(
  Regex(/\{/y).expects("{"),
  AtLeast(
    0,
    Choose(
      Use(() => Brace)
        .expects("{")
        .map((text) => `{${text}}`),
      Regex(/\\./y)
        .expects("\\")
        .map(([escape]) => escape),
      Regex(/[^\\{}]+/y)
        .expects("text")
        .map(([text]) => text)
    )
  ),
  Regex(/\}/y).expects("}")
).map(([, fragments]) => fragments.join(""));

const Word = Choose<WordType>(
  EnchantedWord,
  Brace.map((text) => ({ text } as TextWord)),
  QuotedWord,
  BareWord
);

const CommandTerminator = Regex(/[\n;]/y)
  .expects("NEWLINE | ;")
  .map(() => true);

const Command = Sequence(
  Word,
  AtLeast(
    0,
    Sequence(PreWordWhitespace, Word).map(([, word]) => word)
  ),
  AtLeast(0, PreWordWhitespace)
).map(([word, moreWords]) => [word].concat(moreWords));

const Script = Sequence(
  AtLeast(
    0,
    Choose(
      PreWordWhitespace.map(() => []),
      CommandTerminator.map(() => []),
      Sequence(Comment, Choose(CommandTerminator, End())).map(() => []),
      Sequence(Command, Choose(CommandTerminator, End())).map(
        ([words]) => words
      )
    )
  ),
  End()
).map(([commands]) => commands.filter((command) => command.length > 0));

const ERROR_CONTEXT = /(?<=([^\n]{0,50}))([^\n]{0,50})/y;

/**
 * Parse out a Notcl script into an easier-to-interpret representation.
 * No script is actually executed yet.
 *
 * @param - code to parse
 * @returns - parsed list of commands, or error message on failure
 */
export function parse(code: string): [true, Script] | [false, string] {
  /* Preprocess */
  // fold line endings
  code = code.replace(/(?<!\\)((\\\\)*)\\\n[ \t]*/g, "$1 ");

  /* Parse */
  const [commands, errorPos, expected] = Script(code, 0);

  if (commands) {
    return [true, commands[0]];
  } else {
    ERROR_CONTEXT.lastIndex = errorPos;
    const [, before, after] = ERROR_CONTEXT.exec(code)!;
    return [
      false,
      `<pre>Error at position ${errorPos}
${escapeHtml(before + "" + after)}
${"-".repeat(before.length)}^

Expected: ${escapeHtml(expected)}</pre>`,
    ];
  }
}