import yaml from 'yaml';
import {DATA_DIR, RUST_OUT_DIR} from './_common';
import {readFileSync, writeFileSync} from 'fs';
import {join} from 'path';
import {EOL} from 'os';
import {parsePattern, TrieBuilder} from './trie';

const dfa: { [node: string]: { [transition: string]: string } } = yaml.parse(readFileSync(join(DATA_DIR, 'dfa.yaml'), 'utf8'));
// These states must always exist; see lex/mod.rs for more details.
dfa['TextEntity'] = {};
dfa['AttrValueEntity'] = {};
dfa['Unknown'] = {};
dfa['EOF'] = {};

const nodes = Object.keys(dfa).sort();

const rsTransition = (val: string) => {
  const [_, flag, next] = /^([_<+?]?)(.*)$/.exec(val)!;
  const consumeMode = {
    '_': 'AccumulateLowerCase',
    '': 'Accumulate',
    '<': 'Current',
    '+': 'Next',
    '?': 'Reconsume',
  }[flag];
  return `Transition {
    to: State::${next},
    consume: ConsumeMode::${consumeMode},
  }`;
};

const output = `
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum State {
  ${nodes.map((n, i) => `${n} = ${i}`).join(`,${EOL}  `)}
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ConsumeMode {
  Current,
  Next,
  Reconsume,
  Accumulate,
  AccumulateLowerCase,
}

#[derive(Clone, Copy)]
pub struct Transition {
  // Make pub to allow destructuring.
  pub to: State,
  pub consume: ConsumeMode,
}

${nodes.map(n => {
  const trieBuilder = new TrieBuilder(n.toUpperCase(), 'Transition');
  for (const [pat, val] of Object.entries(dfa[n])) {
    if (pat == '') {
      continue;
    }
    trieBuilder.addPattern(parsePattern(pat), rsTransition(val));
  }
  if (dfa[n][''] !== undefined) {
    trieBuilder.fillRemaining(rsTransition(dfa[n]['']));
  }
  return trieBuilder.generate();
}).join(EOL + EOL)}

pub static TRANSITIONS: [&'static crate::pattern::TrieNode<Transition>; ${nodes.length}] = [${nodes.map(n => n.toUpperCase()).join(', ')}];
`;

writeFileSync(join(RUST_OUT_DIR, 'dfa.rs'), output);