/*
      Copyright 2007 Ivo Limmen
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
  */
  package org.limmen.crs.storage.xml;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.List;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.TransformerFactoryConfigurationError;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.limmen.crs.exception.SectionNotFoundException;
  import org.limmen.crs.model.Configuration;
  import org.limmen.crs.model.Documentation;
  import org.limmen.crs.model.Section;
  import org.limmen.crs.model.Setting;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  public class ConfigurationXMLWriter {
  
  	public static void write(File aFile, Configuration aConfiguration) throws IOException {
  
  		FileOutputStream fileOutputStream = null;
  
  		try {
  
  			fileOutputStream = new FileOutputStream(aFile);
  
  			write(fileOutputStream, aConfiguration);
        }
  		finally {
  
           try {
  	         fileOutputStream.flush();
  	         fileOutputStream.close();
           }
           catch (Exception e) {
  
           	// ignore
           }
  		}
  	}
  
  	public static void write(OutputStream outputStream, Configuration aConfiguration) throws IOException {
  
  		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  		DocumentBuilder builder = null;
  
        try {
  
  	      builder = factory.newDocumentBuilder();
        }
        catch (ParserConfigurationException e) {
  
  	      throw new IOException(e);
        }
  
  		Document document = builder.newDocument();
  
  		Element configElement = document.createElement("configuration");
  
  		configElement.setAttribute("id", aConfiguration.getId());
  
  		if (aConfiguration.getBaseConfiguration() != null) {
  
  			if (!aConfiguration.getId().equals(aConfiguration.getBaseConfiguration().getId())) {
  
  				Element baseConfig = document.createElement("base");
  
  				baseConfig.appendChild(
  						document.createTextNode(
  								aConfiguration.getBaseConfiguration().getId()));
  
  				configElement.appendChild(baseConfig);
 			}
 			else {
 
 				// TODO: Add a warning for a circular configuration.
 			}
 		}
 
 		writeDocumentation(document, configElement, aConfiguration.getDocumentation());
 
       writeSections(document, configElement, aConfiguration);
 
 		document.appendChild(configElement);
 
 		document.normalize();
 
 		Transformer transformer = null;
 
       try {
 
       	transformer = TransformerFactory.newInstance().newTransformer();
       }
       catch (TransformerConfigurationException e) {
 
       	throw new IOException(e);
       }
       catch (TransformerFactoryConfigurationError e) {
 
       	throw new IOException(e);
       }
 
       transformer.setOutputProperty(OutputKeys.INDENT, "yes");
       transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
       transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 
 		//	initialise StreamResult with File object to save to file
 		StreamResult result = new StreamResult(outputStream);
 		DOMSource source = new DOMSource(document);
 
 		try {
 
 			transformer.transform(source, result);
       }
 		catch (TransformerException e) {
 
       	throw new IOException(e);
       }
 	}
 
 	public static void write(String aFile, Configuration aConfiguration) throws IOException {
 
 		write(new File(aFile), aConfiguration);
 	}
 
 	private static void writeDocumentation(Document document, Element root, List<Documentation> documentation) {
 
 		for (Documentation doc : documentation) {
 
 			Element docNode = document.createElement("documentation");
 
 			docNode.setAttribute("lang", doc.getLanguage());
 
 			docNode.appendChild(
 					document.createTextNode(doc.getText()));
 
 			root.appendChild(docNode);
 		}
 	}
 
 	private static void writeSections(Document document, Element root, Configuration aConfiguration) {
 
 		for (Section section : aConfiguration.getSections()) {
 
 			Element sectionNode = document.createElement("section");
 
 			sectionNode.setAttribute("id", section.getId());
 
 			try {
 
 				writeDocumentation(document, sectionNode, aConfiguration.getDocumentation(section.getId()));
          }
          catch (SectionNotFoundException e) {
 
 	         e.printStackTrace();
          }
 
 			writeSettings(document, sectionNode, aConfiguration, section.getId());
 
 			root.appendChild(sectionNode);
 		}
 	}
 
 	private static void writeSettings(Document document, Element root, Configuration aConfiguration, String aSectionId) {
 
 		try {
 
 	      for (Setting setting : aConfiguration.getSection(aSectionId).getSettings()) {
 
 	      	Element settingNode = document.createElement("setting");
 
 	      	settingNode.setAttribute("id", setting.getId());
 
 	      	try {
 
 	      		writeDocumentation(document, settingNode, aConfiguration.getDocumentation(aSectionId, setting.getId()));
 	         }
 	         catch (Exception e) {
 
 	            e.printStackTrace();
 	         }
 
 	      	Element valueNode = document.createElement("value");
 	      	valueNode.appendChild(document.createTextNode(setting.getValue()));
 
 	      	settingNode.appendChild(valueNode);
 
 	      	Element typeNode = document.createElement("type");
 	      	typeNode.appendChild(document.createTextNode(setting.getType().name()));
 
 	      	settingNode.appendChild(typeNode);
 
 	      	root.appendChild(settingNode);
 	      }
       }
       catch (Exception e) {
 
       	e.printStackTrace();
       }
 	}
 }