/**

 * 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, version 3 of the License.

 *

 * 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 cz.frantovo.alt2xml.in.Functions;

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;

import org.xml.sax.helpers.AttributesImpl;

/**

 * Reads INI files with sections and entries.

 * Example:

 * <pre>; this is comment

 *random=value outside of any groups

 *

 *[some_section]

 *

 *; simple entry:

 *key=value

 *

 *; entry starting/ending with whitespace

 *white="  spaces everywhere  " ; might have comment

 *alternative='  spaces everywhere  ' ; same

 *

 *; entries with subkeys:

 *key[subkey_a]=value

 *key[subkey_b]=value

 *

 *# alternative way to comment

 *

 *[another secion]

 *yes=there might be spaces in names

 *because=they are encoded before putting into XML element names

 * </pre>

 *

 * @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, ROOT_ELEMENT);

		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 String encodeXmlName(String originalName, int lineNumber) {

		String encodedName = Functions.encodeXmlName(originalName);

		if (!encodedName.equals(originalName)) {

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

		}

		return encodedName;

	}

	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 name = encodeXmlName(lc.matcher.group("name"), fc.lineNumber);

						fc.outputEndSection(fc.lastSection);

						fc.outputStartSection(name);

						fc.lastSection = name;

					}

				},

		ENTRY(

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

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

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

		) {

					@Override

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

						String key = encodeXmlName(lc.matcher.group("key"), fc.lineNumber);

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

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

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

						}

						AttributesImpl attributes = null;

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

						if (subkey != null) {

							attributes = new AttributesImpl();

							attributes.addAttribute(null, "sub", "sub", "xs:string", subkey);

						}

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

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

						fc.contentHandler.lineBreak();

					}

				},;

		/**

		 * @param patterns regular expression (or expressions) that describes this line type

		 */

		private LINE_TYPE(String... patterns) {

			for (String pattern : patterns) {

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

			}

		}

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

		/**

		 *

		 * @param currentLine input line to be parsed

		 * @param fc

		 * @return whether line matches and was thus processed

		 * @throws SAXException

		 */

		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;

	}

}