/** The .tex to .lyx converter
    \author André Pönitz (2003)
 */

#include <config.h>

#include <algorithm>
#include <cctype>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using std::atoi;
using std::cout;
using std::cerr;
using std::endl;
using std::fill;
using std::getline;
using std::ios;
using std::istream;
using std::ostream;
using std::vector;


namespace {

char const OPEN = '<';
char const CLOSE = '>';

const char * known_languages[] = { "austrian", "babel", "bahasa",
"basque", "breton", "bulgarian", "catalan", "croatian", "czech", "danish",
"dutch", "english", "esperanto", "estonian", "finnish", "francais",
"frenchb", "galician", "germanb", "greek", "hebcal", "hebfont", "hebrew",
"hebrew_newcode", "hebrew_oldcode", "hebrew_p", "hyphen", "icelandic",
"irish", "italian", "latin", "lgrcmr", "lgrcmro", "lgrcmss", "lgrcmtt",
"lgrenc", "lgrlcmss", "lgrlcmtt", "lheclas", "lhecmr", "lhecmss",
"lhecmtt", "lhecrml", "lheenc", "lhefr", "lheredis", "lheshold",
"lheshscr", "lheshstk", "lsorbian", "magyar", "naustrian", "ngermanb",
"ngerman", "norsk", "polish", "portuges", "rlbabel", "romanian",
"russianb", "samin", "scottish", "serbian", "slovak", "slovene", "spanish",
"swedish", "turkish", "ukraineb", "usorbian", "welsh", 0};

const char * known_fontsizes[] = { "10pt", "11pt", "12pt", 0 };


// some ugly stuff
string h_preamble;
string h_textclass               = "FIXME";
string h_options                 = "FIXME";
string h_language                = "FIXME";
string h_inputencoding           = "FIXME";
string h_fontscheme              = "FIXME";
string h_graphics                = "default";
string h_paperfontsize           = "FIXME";
string h_spacing                 = "single";
string h_papersize               = "FIXME";
string h_paperpackage            = "FIXME";
string h_use_geometry            = "0";
string h_use_amsmath             = "0";
string h_use_natbib              = "0";
string h_use_numerical_citations = "0";
string h_paperorientation        = "portrait";
string h_secnumdepth             = "3";
string h_tocdepth                = "3";
string h_paragraph_separation    = "indent";
string h_defskip                 = "medskip";
string h_quotes_language         = "2";
string h_quotes_times            = "1";
string h_papercolumns            = "1";
string h_papersides              = "1";
string h_paperpagestyle          = "default";
string h_tracking_changes        = "0";

// indicates whether we are in the preamble
bool in_preamble = true;

// current stack of nested environments
stack<string> active_environments;



void split(string const & s, vector<string> & result, char delim)
{
	istringstream is(s);	
	string t;
	while (getline(is, t, delim))
		result.push_back(t);
}


string join(vector<string> const & input, char delim)
{
	ostringstream os;
	for (size_t i = 0; i != input.size(); ++i) {
		if (i)
			os << delim;	
		os << input[i]; 
	}
	return os.str();
}


void handle_opt(vector<string> & opts, char const ** what, string & target)
{
	for ( ; what; ++what) {
		vector<string>::iterator it = find(opts.begin(), opts.end(), *what);
		if (it != opts.end()) {
			//cerr << "### found option '" << *what << "'\n";
			target = *what;
			opts.erase(it);
			return;
		}
	}
}


void handle_ert(ostream & os, string const & s)
{
	os << "\n\\begin_inset ERT\nstatus Collapsed\n\n\\layout Standard\n\n";
	os << s;
	os << "\n\\end_inset\n";
}


string wrap(string const & cmd, string const & str)
{
	return OPEN + cmd + ' ' + str + CLOSE;
}


string wrap(string const & cmd, string const & str, string const & str2)
{
	return OPEN + cmd + ' ' + str + ' ' + str2 + CLOSE;
}


enum mode_type {UNDECIDED_MODE, TEXT_MODE, MATH_MODE};

mode_type asMode(mode_type oldmode, string const & str)
{
	if (str == "mathmode")
		return MATH_MODE;
	if (str == "textmode" || str == "forcetext")
		return TEXT_MODE;
	return oldmode;
}


bool stared(string const & s)
{
	string::size_type const n = s.size();
	return n && s[n - 1] == '*';
}


// These are TeX's catcodes
enum CatCode {
	catEscape,     // 0    backslash
	catBegin,      // 1    {
	catEnd,        // 2    }
	cat,       // 3    $
	catAlign,      // 4    &
	catNewline,    // 5    ^^M
	catParameter,  // 6    #
	catSuper,      // 7    ^
	catSub,        // 8    _
	catIgnore,     // 9
	catSpace,      // 10   space
	catLetter,     // 11   a-zA-Z
	catOther,      // 12   none of the above
	catActive,     // 13   ~
	catComment,    // 14   %
	catInvalid     // 15   <delete>
};

CatCode theCatcode[256];


inline CatCode catcode(unsigned char c)
{
	return theCatcode[c];
}


enum {
	FLAG_BRACE_LAST = 1 << 1,  //  last closing brace ends the parsing
	FLAG_RIGHT      = 1 << 2,  //  next \\right ends the parsing process
	FLAG_END        = 1 << 3,  //  next \\end ends the parsing process
	FLAG_BRACK_LAST = 1 << 4,  //  next closing bracket ends the parsing
	FLAG_TEXTMODE   = 1 << 5,  //  we are in a box
	FLAG_ITEM       = 1 << 6,  //  read a (possibly braced token)
	FLAG_LEAVE      = 1 << 7,  //  leave the loop at the end
	FLAG_SIMPLE     = 1 << 8,  //  next $ leaves the loop
	FLAG_EQUATION   = 1 << 9,  //  next \] leaves the loop
	FLAG_SIMPLE2    = 1 << 10, //  next \) leaves the loop
	FLAG_OPTION     = 1 << 11, //  read [...] style option
	FLAG_BRACED     = 1 << 12  //  read {...} style argument
};


void catInit()
{
	fill(theCatcode, theCatcode + 256, catOther);
	fill(theCatcode + 'a', theCatcode + 'z' + 1, catLetter);
	fill(theCatcode + 'A', theCatcode + 'Z' + 1, catLetter);

	theCatcode['\\'] = catEscape;
	theCatcode['{']  = catBegin;
	theCatcode['}']  = catEnd;
	theCatcode['$']  = cat;
	theCatcode['&']  = catAlign;
	theCatcode['\n'] = catNewline;
	theCatcode['#']  = catParameter;
	theCatcode['^']  = catSuper;
	theCatcode['_']  = catSub;
	theCatcode[''] = catIgnore;
	theCatcode[' ']  = catSpace;
	theCatcode['\t'] = catSpace;
	theCatcode['\r'] = catNewline;
	theCatcode['~']  = catActive;
	theCatcode['%']  = catComment;
}



//
// Helper class for parsing
//

class Token {
public:
	///
	Token() : cs_(), char_(0), cat_(catIgnore) {}
	///
	Token(char c, CatCode cat) : cs_(), char_(c), cat_(cat) {}
	///
	Token(string const & cs) : cs_(cs), char_(0), cat_(catIgnore) {}

	///
	string const & cs() const { return cs_; }
	///
	CatCode cat() const { return cat_; }
	///
	char character() const { return char_; }
	///
	string asString() const { return cs_.size() ? cs_ : string(1, char_); }

private:
	///
	string cs_;
	///
	char char_;
	///
	CatCode cat_;
};

ostream & operator<<(ostream & os, Token const & t)
{
	if (t.cs().size())
		os << '\\' << t.cs();
	else
		os << '[' << t.character() << ',' << t.cat() << ']';
	return os;
}


class Parser {

public:
	///
	Parser(istream & is);

	///
	string parse();
	///
	string parse(unsigned flags, mode_type mode);
	///
	int lineno() const { return lineno_; }
	///
	void putback();
	/// dump contents to screen
	void dump() const;

private:
	///
	string getArg(char left, char right);
	///
	char getChar();
	///
	void error(string const & msg);
	///
	void tokenize(istream & is);
	///
	void tokenize(string const & s);
	///
	void skipSpaceTokens(istream & is, char c);
	///
	void push_back(Token const & t);
	///
	void pop_back();
	///
	Token const & prevToken() const;
	///
	Token const & nextToken() const;
	///
	Token const & getToken();
	/// skips spaces if any
	void skipSpaces();
	///
	void lex(string const & s);
	///
	bool good() const;
	///
	string parse_verbatim_item();
	///
	string parse_verbatim_option();

	///
	int lineno_;
	///
	vector<Token> tokens_;
	///
	unsigned pos_;
};


Parser::Parser(istream & is)
	: lineno_(0), pos_(0)
{
	tokenize(is);
}


void Parser::push_back(Token const & t)
{
	tokens_.push_back(t);
}


void Parser::pop_back()
{
	tokens_.pop_back();
}


Token const & Parser::prevToken() const
{
	static const Token dummy;
	return pos_ > 0 ? tokens_[pos_ - 1] : dummy;
}


Token const & Parser::nextToken() const
{
	static const Token dummy;
	return good() ? tokens_[pos_] : dummy;
}


Token const & Parser::getToken()
{
	static const Token dummy;
	//cerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n';
	return good() ? tokens_[pos_++] : dummy;
}


void Parser::skipSpaces()
{
	while (nextToken().cat() == catSpace || nextToken().cat() == catNewline)
		getToken();
}


void Parser::putback()
{
	--pos_;
}


bool Parser::good() const
{
	return pos_ < tokens_.size();
}


char Parser::getChar()
{
	if (!good())
		error("The input stream is not well...");
	return tokens_[pos_++].character();
}


string Parser::getArg(char left, char right)
{
	skipSpaces();

	string result;
	char c = getChar();

	if (c != left)
		putback();
	else
		while ((c = getChar()) != right && good())
			result += c;

	return result;
}


void Parser::skipSpaceTokens(istream & is, char c)
{
	// skip trailing spaces
	while (catcode(c) == catSpace || catcode(c) == catNewline)
		if (!is.get(c))
			break;
	//cerr << "putting back: " << c << "\n";
	is.putback(c);
}


void Parser::tokenize(istream & is)
{
	// eat everything up to the next \end_inset or end of stream
	// and store it in s for further tokenization
	string s;
	char c;
	while (is.get(c)) {
		s += c;
		if (s.size() >= 10 && s.substr(s.size() - 10) == "\\end_inset") {
			s = s.substr(0, s.size() - 10);
			break;
		}
	}
	// Remove the space after \end_inset
	if (is.get(c) && c != ' ')
		is.unget();

	// tokenize buffer
	tokenize(s);
}


void Parser::tokenize(string const & buffer)
{
	static bool init_done = false;

	if (!init_done) {
		catInit();
		init_done = true;
	}

	istringstream is(buffer.c_str(), ios::in | ios::binary);

	char c;
	while (is.get(c)) {
		//cerr << "reading c: " << c << "\n";

		switch (catcode(c)) {
			case catNewline: {
				++lineno_;
				is.get(c);
				if (catcode(c) == catNewline)
					push_back(Token("par"));
				else {
					push_back(Token('\n', catNewline));
					is.putback(c);
				}
				break;
			}

/*
			case catComment: {
				while (is.get(c) && catcode(c) != catNewline)
					;
				++lineno_;
				break;
			}
*/

			case catEscape: {
				is.get(c);
				if (!is) {
					error("unexpected end of input");
				} else {
					string s(1, c);
					if (catcode(c) == catLetter) {
						// collect letters
						while (is.get(c) && catcode(c) == catLetter)
							s += c;
						skipSpaceTokens(is, c);
					}
					push_back(Token(s));
				}
				break;
			}

			case catSuper:
			case catSub: {
				push_back(Token(c, catcode(c)));
				is.get(c);
				skipSpaceTokens(is, c);
				break;
			}

			case catIgnore: {
				cerr << "ignoring a char: " << int(c) << "\n";
				break;
			}

			default:
				push_back(Token(c, catcode(c)));
		}
	}

#ifdef FILEDEBUG
	dump();
#endif
}


void Parser::dump() const
{
	cerr << "\nTokens: ";
	for (unsigned i = 0; i < tokens_.size(); ++i) {
		if (i == pos_)
			cerr << " <#> ";
		cerr << tokens_[i];
	}
	cerr << " pos: " << pos_ << "\n";
}


void Parser::error(string const & msg)
{
	cerr << "Line ~" << lineno_ << ":  parse error: " << msg << endl;
	dump();
	//exit(1);
}


string Parser::parse()
{
	skipSpaces();
	return parse(0, UNDECIDED_MODE);
}


string Parser::parse_verbatim_option()
{
	string res;
	if (nextToken().character() == '[') {
		Token t = getToken();
		for (Token t = getToken(); t.character() != ']' && good(); t = getToken()) {
			if (t.cat() == catBegin) {
				putback();
				res += '{' + parse_verbatim_item() + '}';
			} else
				res += t.asString();
		}
	}
	return res;
}


string Parser::parse_verbatim_item()
{
	string res;
	if (nextToken().cat() == catBegin) {
		Token t = getToken();
		for (Token t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
			if (t.cat() == catBegin) {
				putback();
				res += '{' + parse_verbatim_item() + '}';
			}
			else
				res += t.asString();
		}
	}
	return res;
}


string Parser::parse(unsigned flags, mode_type mode)
{
	//int limits = 0;

	ostringstream result;
	while (good()) {
		Token const & t = getToken();

#ifdef FILEDEBUG
		cerr << "t: " << t << " flags: " << flags << "\n";
		cell->dump();
		cerr << "\n";
#endif

		if (flags & FLAG_ITEM) {
			if (t.cat() == catSpace)
				continue;

			flags &= ~FLAG_ITEM;
			if (t.cat() == catBegin) {
				// skip the brace and collect everything to the next matching
				// closing brace
				flags |= FLAG_BRACE_LAST;
				continue;
			}

			// handle only this single token, leave the loop if done
			flags |= FLAG_LEAVE;
		}


		if (flags & FLAG_BRACED) {
			if (t.cat() == catSpace)
				continue;

			if (t.cat() != catBegin) {
				error("opening brace expected");
				return result.str();
			}

			// skip the brace and collect everything to the next matching
			// closing brace
			flags = FLAG_BRACE_LAST;
		}


		if (flags & FLAG_OPTION) {
			if (t.cat() == catOther && t.character() == '[') {
				result << parse(FLAG_BRACK_LAST, mode);
			} else {
				// no option found, put back token and we are done
				putback();
			}
			return result.str();
		}

		//
		// cat codes
		//
		if (t.cat() == cat) {
			if (mode != MATH_MODE) {
				// we are inside some text mode thingy, so opening new math is allowed
				Token const & n = getToken();
				if (n.cat() == cat) {
					// TeX's $$...$$ syntax for displayed math
					result << wrap("equation", parse(FLAG_SIMPLE, MATH_MODE));
					getToken(); // skip the second '$' token
				} else {
					// simple $...$  stuff
					putback();
					result << wrap("simple", parse(FLAG_SIMPLE, MATH_MODE));
				}
			}

			else if (flags & FLAG_SIMPLE) {
				// this is the end of the formula
				return result.str();
			}

			else {
				error("something strange in the parser\n");
				break;
			}
		}

		else if (t.cat() == catLetter)
			result << t.character();

		else if (t.cat() == catSpace && mode != MATH_MODE) {
			//if (result.empty() || result[result.size() - 1] != ' ')
				result << t.character();
		}

		else if (t.cat() == catNewline && mode != MATH_MODE)
			result << t.character();

		else if (t.cat() == catParameter) {
			Token const & n	= getToken();
			result << wrap("macroarg", string(1, n.character()));
		}

		else if (t.cat() == catActive)
			result << wrap("active", string(1, t.character()));

		else if (t.cat() == catBegin)
			result << wrap("braced", parse(FLAG_BRACE_LAST, mode));

		else if (t.cat() == catEnd) {
			if (flags & FLAG_BRACE_LAST)
				return result.str();
			error("found '}' unexpectedly");
			//lyx::Assert(0);
			//add(cell, '}', LM_TC_TEX);
		}

/*
		else if (t.cat() == catAlign) {
			++cellcol;
			//cerr << " column now " << cellcol << " max: " << grid.ncols() << "\n";
			if (cellcol == grid.ncols()) {
				//cerr << "adding column " << cellcol << "\n";
				grid.addCol(cellcol - 1);
			}
			cell = &grid.cell(grid.index(cellrow, cellcol));
		}
*/

		else if (t.character() == ']' && (flags & FLAG_BRACK_LAST)) {
			//cerr << "finished reading option\n";
			return result.str();
		}

		else if (t.cat() == catOther)
			result << string(1, t.character());

		else if (t.cat() == catComment) {
			string s;
			while (good()) {
				Token const & t = getToken();
				if (t.cat() == catNewline)
					break;
				s += t.asString();
			}
			//result << wrap("comment", s);
			skipSpaces();
		}

		//
		// control sequences
		//

		else if (t.cs() == "lyxlock") {
			// ignored;
		}

		else if (t.cs() == "newcommand" || t.cs() == "providecommand") {
			string const name = parse_verbatim_item();
			string const opts = getArg('[', ']');
			string const body = parse_verbatim_item();
			// only non-lyxspecific stuff
			if (name != "noun" && name != "tabularnewline") {
				h_preamble += "\\" + t.cs() + "{" + name + "}";
				if (opts.size()) 
					h_preamble += "[" + opts + "]";
				h_preamble += "{" + body + "}\n";
			}
		}

		else if (t.cs() == "(") 
			result << wrap("simple", parse(FLAG_SIMPLE2, MATH_MODE));

		else if (t.cs() == "[")
			result << wrap("equation", parse(FLAG_EQUATION, MATH_MODE));

		else if (t.cs() == "protect")
			// ignore \\protect, will hopefully be re-added during output
			;

		else if (t.cs() == "end") {
			if (flags & FLAG_END) {
				// eat environment name
				string const name = getArg('{', '}');
				if (name != active_environments.top())
					error("\\end{" + name + "} does not match \\begin{"
						+ active_environments.top() + "}");
				active_environments.pop();
				return result.str();
			}
			error("found 'end' unexpectedly");
		}

		else if (t.cs() == ")") {
			if (flags & FLAG_SIMPLE2)
				return result.str();
			error("found '\\)' unexpectedly");
		}

		else if (t.cs() == "]") {
			if (flags & FLAG_EQUATION)
				return result.str();
			error("found '\\]' unexpectedly");
		}

/*
		else if (t.cs() == "\\") {
			grid.vcrskip(LyXLength(getArg('[', ']')), cellrow);
			++cellrow;
			cellcol = 0;
			if (cellrow == grid.nrows())
				grid.addRow(cellrow - 1);
			if (grid.asHullstring())
				grid.asHullstring()->numbered(cellrow, numbered);
			cell = &grid.cell(grid.index(cellrow, cellcol));
		}
*/
		else if (t.cs() == "documentclass") {
			vector<string> opts;
			split(getArg('[', ']'), opts, ',');
			handle_opt(opts, known_languages, h_language); 
			handle_opt(opts, known_fontsizes, h_paperfontsize); 
			h_options = join(opts, ',');
			h_textclass = getArg('{', '}');
		}

		else if (t.cs() == "usepackage") {
			string const options = getArg('[', ']');
			string const name = getArg('{', '}');
			if (name == "a4wide") {
				h_papersize = "a4";
				h_paperpackage = "widemarginsa4";
			} else if (name == "ae") 
				h_fontscheme = "ae";
			else if (name == "aecompl") 
				h_fontscheme = "ae";
			else if (name == "amsmath") 
				h_use_amsmath = "1";
			else if (name == "amssymb") 
				h_use_amsmath = "1";
			else if (name == "babel") 
				; // ignore this
			else if (name == "fontenc") 
				; // ignore this
			else if (name == "inputenc") 
				h_inputencoding = options;
			else if (name == "makeidx") 
				; // ignore this
			else if (name == "verbatim") 
				; // ignore this
			else {
				if (options.size())
					h_preamble += "\\usepackage[" + options + "]{" + name + "}\n";
				else
					h_preamble += "\\usepackage{" + name + "}\n";
			}
		}

		else if (t.cs() == "newenvironment") {
			string const name = getArg('{', '}');
			skipSpaces();
			string const begin = parse_verbatim_item();
			skipSpaces();
			string const end = parse_verbatim_item();
			// ignore out mess
			if (name != "lyxcode") 
				result << wrap("newenvironment", begin + end); 
		}

		else if (t.cs() == "def") {
			string const name = getToken().cs();
			string res;
			while (nextToken().cat() != catBegin)
				res += getToken().asString();
			handle_ert(result, "\\def" + res + '{' + parse_verbatim_item() + '}');
		}

		else if (t.cs() == "setcounter") {
			string const name = getArg('{', '}');
			string const content = getArg('{', '}');
			if (name == "secnumdepth") 
				h_secnumdepth = content;
			else if (name == "tocdepth") 
				h_tocdepth = content;
			else
				h_preamble += "\\setcounter{" + name + "}{" + content + "}\n";
		}

		else if (t.cs() == "setlength") {
			string const name = getToken().cs();
			string const content = getArg('{', '}');
			if (name == "parskip")
				h_paragraph_separation = "skip";
			else if (name == "parindent")
				h_paragraph_separation = "skip";
			else
				h_preamble += "\\setcounter{" + name + "}{" + content + "}\n";
		}
	
		else if (t.cs() == "par") {
			if (!active_environments.empty()) 	
				result << "\n\\layout " << active_environments.top() << "\n\n";
		}

		else if (t.cs() == "title")
			result << "\\layout Title\n\n" + parse_verbatim_item();

		else if (t.cs() == "author")
			result << "\\layout Author\n\n" + parse_verbatim_item();

		else if (t.cs() == "abstract")
			result << "\\layout Abstract\n\n" + parse_verbatim_item();

		else if (t.cs() == "begin") {
			string const name = getArg('{', '}');
			active_environments.push(name);
			result << parse(FLAG_END, mode);
		}

		if (flags & FLAG_LEAVE) {
			flags &= ~FLAG_LEAVE;
			break;
		}
	}

	return result.str();
}


} // anonymous namespace


int main(int argc, char * argv[])
{
	if (argc <= 1) {
		cerr << "Usage: " << argv[0] << " <infile.tex>" << endl;
		return 2;
	}

	string t;
	ifstream is(argv[1]);
	Parser p(is);
	//p.dump();
	string s = p.parse();
	cout << "# tex2lyx 0.0.2 created this file\n"
	     << "\\lyxformat 222\n"
	     << "\\textclass " << h_textclass << "\n"
	     << "\\begin_preamble\n" << h_preamble << "\\end_preamble\n"
	     << "\\options " << h_options << "\n"
	     << "\\language " << h_language << "\n"
	     << "\\inputencoding " << h_inputencoding << "\n"
	     << "\\fontscheme " << h_fontscheme << "\n"
	     << "\\graphics " << h_graphics << "\n"
	     << "\\paperfontsize " << h_paperfontsize << "\n"
	     << "\\spacing " << h_spacing << "\n"
	     << "\\papersize " << h_papersize << "\n"
	     << "\\paperpackage " << h_paperpackage << "\n"
	     << "\\use_geometry " << h_use_geometry << "\n"
	     << "\\use_amsmath " << h_use_amsmath << "\n"
	     << "\\use_natbib " << h_use_natbib << "\n"
	     << "\\use_numerical_citations " << h_use_numerical_citations << "\n"
	     << "\\paperorientation " << h_paperorientation << "\n"
	     << "\\secnumdepth " << h_secnumdepth << "\n"
	     << "\\tocdepth " << h_tocdepth << "\n"
	     << "\\paragraph_separation " << h_paragraph_separation << "\n"
	     << "\\defskip " << h_defskip << "\n"
	     << "\\quotes_language " << h_quotes_language << "\n"
	     << "\\quotes_times " << h_quotes_times << "\n"
	     << "\\papercolumns " << h_papercolumns << "\n"
	     << "\\papersides " << h_papersides << "\n"
	     << "\\paperpagestyle " << h_paperpagestyle << "\n"
	     << "\\tracking_changes " << h_tracking_changes << "\n"
	     << s << "\n"
	     << "\\the_end";

	return 0;	
}