/**

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

 	}

 }