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);