/**

 * Alt2XML

 * Copyright © 2014 František Kučera (frantovo.cz)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

package cz.frantovo.alt2xml.in.ini;

import cz.frantovo.alt2xml.AbstractAlt2XmlReader;

import cz.frantovo.alt2xml.in.Alt2ContentHandler;

import static cz.frantovo.alt2xml.in.Functions.encodeXmlName;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

/**

 *

 * @author Ing. František Kučera (frantovo.cz)

 */

public class Reader extends AbstractAlt2XmlReader {

	public static final String ROOT_ELEMENT = "ini";

	private static final Logger log = Logger.getLogger(Reader.class.getName());

	@Override

	public void parse(InputSource input) throws IOException, SAXException {

		outputStart();

		try (BufferedReader br = new BufferedReader(new InputStreamReader(input.getByteStream()))) {

			FileContext fc = new FileContext(contentHandler);

			for (String currentLine = br.readLine(); currentLine != null; currentLine = br.readLine()) {

				fc.lineNumber++;

				boolean lineProcessed = false;

				for (LINE_TYPE lineType : LINE_TYPE.values()) {

					lineProcessed = lineType.processLine(currentLine, fc);

					if (lineProcessed) {

						break;

					}

				}

				if (!lineProcessed) {

					log.log(Level.SEVERE, "Invalid line in INI file: {0}", currentLine);

				}

			}

			fc.outputEndSection(fc.lastSection);

		}

		outputEnd();

	}

	private void outputStart() throws SAXException {

		contentHandler.startDocument();

		contentHandler.lineBreak();

		contentHandler.startElement(null, null, ROOT_ELEMENT, null);

		contentHandler.lineBreak();

	}

	private void outputEnd() throws SAXException {

		contentHandler.endElement(null, null, "ini");

		contentHandler.lineBreak();

		contentHandler.endDocument();

	}

	private static class FileContext {

		private final Alt2ContentHandler contentHandler;

		private String lastSection;

		private int lineNumber;

		public FileContext(Alt2ContentHandler contentHandler) {

			this.contentHandler = contentHandler;

		}

		protected void outputStartSection(String name) throws SAXException {

			contentHandler.indentation(1);

			contentHandler.startElement(null, null, name, null);

			contentHandler.lineBreak();

		}

		protected void outputEndSection(String name) throws SAXException {

			if (name != null) {

				contentHandler.indentation(1);

				contentHandler.endElement(null, null, name);

				contentHandler.lineBreak();

			}

		}

	}

	private static class LineContext {

		private final Matcher matcher;

		public LineContext(Matcher matcher) {

			this.matcher = matcher;

		}

	}

	private enum LINE_TYPE {

		BLANK_LINE("\\s*") {

					@Override

					public void processLine(LineContext lc, FileContext fc) throws SAXException {

						log.log(Level.FINEST, "Line {0}: skipping blank line", fc.lineNumber);

					}

				},

		COMMENT("\\s*(;|#)\\s*(?<comment>.*)") {

					@Override

					public void processLine(LineContext lc, FileContext fc) throws SAXException {

						// TODO: comment → LexicalHandler

						log.log(Level.FINER, "Line {0}: comment: {1}", new Object[]{fc.lineNumber, lc.matcher.group("comment")});

					}

				},

		SECTION("\\s*\\[\\s*(?<name>[^\\]\\]]+)\\s*\\]\\s*") {

					@Override

					public void processLine(LineContext lc, FileContext fc) throws SAXException {

						String originalName = lc.matcher.group("name");

						String encodedName = encodeXmlName(originalName);

						if (!encodedName.equals(originalName)) {

							log.log(Level.FINE, "Line {0}: section name „{1} was encoded to „{2}““", new Object[]{fc.lineNumber, originalName, encodedName});

						}

						fc.outputEndSection(fc.lastSection);

						fc.outputStartSection(encodedName);

						fc.lastSection = encodedName;

					}

				},

		ENTRY(

				"\\s*(?<key>[^=\\s]+)\\s*=\\s*\"(?<value>[^']+)\"\\s*((;|#)\\s*(?<comment>.*)){0,1}", // quoted value → include spaces + might have comment

				"\\s*(?<key>[^=\\s]+)\\s*=\\s*'(?<value>[^']+)'\\s*((;|#)\\s*(?<comment>.*)){0,1}", // apostrophed value → include spaces + might have comment

				"\\s*(?<key>[^=\\s]+)\\s*=\\s*(?<value>.+)" // unquoted value → strip spaces + no comments

		) {

					@Override

					public void processLine(LineContext lc, FileContext fc) throws SAXException {

						String key = lc.matcher.group("key");

						String value = lc.matcher.group("value");

						if (lc.matcher.groupCount() > 2) {

							String comment = lc.matcher.group("comment");

							// TODO: comment → LexicalHandler

							log.log(Level.FINER, "Line {0}: comment for entry „{1}“ is: {2}", new Object[]{fc.lineNumber, key, comment});

						}

						fc.contentHandler.indentation(fc.lastSection == null ? 1 : 2);

						fc.contentHandler.textElement(value, null, null, key, null);

						fc.contentHandler.lineBreak();

					}

				},;

		private LINE_TYPE(String... patterns) {

			for (String pattern : patterns) {

				this.patterns.add(Pattern.compile(pattern));

			}

		}

		private final List<Pattern> patterns = new ArrayList<>();

		protected boolean processLine(String currentLine, FileContext fc) throws SAXException {

			for (Pattern pattern : patterns) {

				Matcher m = pattern.matcher(currentLine);

				if (m.matches()) {

					log.log(Level.FINEST, "Line {0}: pattern „{1}“ matches „{2}“", new Object[]{fc.lineNumber, pattern, currentLine});

					processLine(new LineContext(m), fc);

					return true;

				}

			}

			return false;

		}

		public abstract void processLine(LineContext lc, FileContext fc) throws SAXException;

	}

}