/* ======================================
    * Copyright (c) 2004-2005 Achim Nierbeck
    * All rights reserved.
    *
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *       http://www.gnu.org/licenses/lgpl.html
    *
   * 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.
   * ======================================
   */
  
  /*
   * $Revision: 1.4 $
   * Date 14.12.2005
   * 
   * $Author: nierbeck $ 
   * $Date: 2006/02/03 22:33:35 $  
   */
  
  package de.nierbeck.timeTrack;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.Calendar;
  import java.util.GregorianCalendar;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Observable;
  
  import javax.xml.bind.JAXBContext;
  import javax.xml.bind.JAXBException;
  import javax.xml.bind.Marshaller;
  import javax.xml.bind.Unmarshaller;
  import javax.xml.bind.ValidationException;
  import javax.xml.bind.Validator;
  
  import org.eclipse.jface.preference.IPreferenceStore;
  
  import de.nierbeck.timeTrack.model.Entries;
  import de.nierbeck.timeTrack.model.EntryType;
  import de.nierbeck.timeTrack.model.ObjectFactory;
  import de.nierbeck.timeTrack.preferences.PreferenceConstants;
  
  /***
   * Class TimeTrackEntriesManager is a wrapper class for the entries, since the
   * entries are generated class.
   * 
   * @author Achim
   * @see java.util.Observable
   * @see Entries
   */
  public class TimeTrackEntriesManager extends Observable implements Entries {
  
  	// singleton instance
  	private static TimeTrackEntriesManager instance;
  
  	private transient Entries entries;
  
  	private transient JAXBContext jaxbCtxt;
  
  	private transient File file;
  
  	private transient final ObjectFactory objFactory = new ObjectFactory();
  
  	/***
  	 * 
  	 * @return the instance
  	 * @deprecated
  	 */
  	public static TimeTrackEntriesManager getTimeTrackEntriesManager() {
  		if (instance == null) {
  			instance = new TimeTrackEntriesManager();
  		}
  		return instance;
  	}
  
  	/***
  	 * Constructor of the TimeTrackEntriesManager Class.
  	 * 
  	 */
  	TimeTrackEntriesManager() {
  		ClassLoader newloader = JAXBContext.class.getClassLoader();
  		ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
  		Thread.currentThread().setContextClassLoader(newloader);
  
  		try {
  			jaxbCtxt = JAXBContext.newInstance("de.nierbeck.timeTrack.model"); //$NON-NLS-1$
  			TimeTrackLog.logInfo("loading JAXBContext done");
  		} catch (JAXBException e) {
  			TimeTrackLog.logError("failed to create JAXBContext", e);
  		} finally {
 			Thread.currentThread().setContextClassLoader(oldLoader);
 		}
 	}
 
 	/***
 	 * delegates the call to the nested class
 	 * 
 	 * @see Entries
 	 * 
 	 * @return the selected EntryType
 	 */
 	public final EntryType getCurrentSelected() {
 		if (entries == null) {
 			createEntries();
 		}
 		return entries.getCurrentSelected();
 	}
 
 	/***
 	 * delegates the call to the nested class and notifies the Observers
 	 * 
 	 * @see Entries
 	 * @param value - the current Selected
 	 */
 	public final void setCurrentSelected(EntryType value) {
 		if (entries == null) {
 			createEntries();
 		}
 		entries.setCurrentSelected(value);
 		setChanged();
 		notifyObservers();
 	}
 
 	/***
 	 * delegates the call to the nested class
 	 * 
 	 * @see Entries
 	 * 
 	 * @return a list containing the entries
 	 */
 	public final List getEntry() {
 		if (entries == null) {
 			createEntries();
 		}
 		return entries.getEntry();
 	}
 
 	/***
 	 * delegates the call to the nested class
 	 * 
 	 * @see Entries
 	 */
 	public final void setChanged() {
 		super.setChanged();
 	}
 
 	private void createEntries() {
 		try {
 			setXMLFile();
 		} catch (JAXBException e) {
 			TimeTrackLog.logError(this + "createPartControl()", e);
 			if (entries == null) {
 				try {
 					createNewEntries();
 				} catch (JAXBException e1) {
 					TimeTrackLog.logError(this + "createPartControl()", e);
 				}
 			}
 		} catch (IOException e) {
 			TimeTrackLog.logError(this + "createPartControl()", e);
 		}
 	}
 
 	/***
 	 * @throws JAXBException
 	 */
 	private void createNewEntries() throws JAXBException {
 		entries = objFactory.createEntries();
 		createNewCurrentSelected();
 		// projects = new String[1];
 		// projects[0] = ""; //$NON-NLS-1$
 		// tasks = new String[1];
 		// tasks[0] = ""; //$NON-NLS-1$
 		// comments = new String[1];
 		// comments[0] = ""; //$NON-NLS-1$
 	}
 
 	private void setXMLFile() throws JAXBException, IOException {
 
 		IPreferenceStore store = TimeTrackPlugin.getDefault().getPreferenceStore();
 
 		String xmlFile = store.getString(PreferenceConstants.P_FILE);
 		if ("".equals(xmlFile)) { //$NON-NLS-1$
 			xmlFile = PreferenceConstants.P_FILE_DEFAULT;
 		}
 		String directory = store.getString(PreferenceConstants.P_PATH);
 		if ("${workspace_loc}".equals(directory)) { //$NON-NLS-1$
 			directory = ""; //$NON-NLS-1$
 		}
 
 		StringBuffer xFile = new StringBuffer();
 
 		if (directory != null && directory.length() > 0) {
 			xFile.append(directory); //$NON-NLS-1$
 			xFile.append("/");
 		}
 		if (xmlFile != null && xmlFile.length() > 0) {
 			xFile.append(xmlFile);
 
 			file = new File(xFile.toString());
 			boolean exists = file.exists();
 
 			if (exists) {
 				unmarshall(file);
 			} else {
 				createNewEntries();
 			}
 		}
 	}
 
 	/***
 	 * @param xFile
 	 * @throws JAXBException
 	 * @throws JAXBException
 	 */
 	private void unmarshall(File file) throws JAXBException {
 		if (jaxbCtxt == null) {
 			jaxbCtxt = JAXBContext.newInstance("de.nierbeck.timeTrack.model"); //$NON-NLS-1$
 		}
 		Unmarshaller unmarshaller = jaxbCtxt.createUnmarshaller();
 		Entries entries = null;
 		entries = (Entries) unmarshaller.unmarshal(file);
 		if (entries == null) {
 			entries = objFactory.createEntries();
 		} else {
 			this.entries = entries;
 		}
 
 		if (entries.getCurrentSelected() != null) {
 			entries.getEntry().add(entries.getCurrentSelected());
 			createNewCurrentSelected();
 		}
 
 		/*
 		 * Iterator iterator = entries.getEntry().iterator();
 		 * 
 		 * ArrayList project = new ArrayList(); String stringProject =
 		 * entries.getCurrentSelected().getProject(); if (stringProject != null &&
 		 * stringProject.length() > 0) project.add(stringProject); ArrayList
 		 * task = new ArrayList(); String stringTask =
 		 * entries.getCurrentSelected().getTask(); if (stringTask != null &&
 		 * stringTask.length() > 0) task.add(stringTask); ArrayList comment =
 		 * new ArrayList(); String stringComment =
 		 * entries.getCurrentSelected().getComment(); if (stringComment != null &&
 		 * stringComment.length() > 0) comment.add(stringComment);
 		 * 
 		 * while (iterator.hasNext()) { EntryType entry = (EntryType)
 		 * iterator.next(); stringProject = entry.getProject(); if
 		 * (stringProject != null && stringProject.length() > 0 &&
 		 * !project.contains(stringProject)) project.add(stringProject);
 		 * stringTask = entry.getTask(); if (stringTask != null &&
 		 * stringTask.length() > 0 && !task.contains(stringTask))
 		 * task.add(stringTask); stringComment = entry.getComment(); if
 		 * (stringComment != null && stringComment.length() > 0 &&
 		 * !comment.contains(stringComment)) comment.add(stringComment); } //
 		 * try { // projects = new String[project.size()]; //
 		 * fillArray(projects, project); // tasks = new String[task.size()]; //
 		 * fillArray(tasks, task); // comments = new String[comment.size()]; //
 		 * fillArray(comments, comment); // } catch (Exception e) { //
 		 * TimeTrackLog.logError("failed to create JAXBContext", e); // }
 		 */
 	}
 
 	private void marshall() throws JAXBException, FileNotFoundException {
 		final Marshaller marshaller = jaxbCtxt.createMarshaller();
 		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE );
 		final Validator validator = jaxbCtxt.createValidator();
 
 		boolean valid = false;
 		try {
 			valid = validator.validate(entries);
 		} catch (ValidationException e) {
 			TimeTrackLog.logError("XML not Valid", e);
 			return;
 		} 
 		if (!valid) {
 			TimeTrackLog.logError("XML not Valid", new ValidationException("Entries weren't validatet correctly"));
 			return; //can't save since the structure isn't valid
 		}
 		/*
 		if (!valid) {
 			throw new ValidationException("Entries weren't validatet correctly"); //$NON-NLS-1$
 		}*/
 
 		marshaller.marshal(entries, new FileOutputStream(file));
 	}
 
 	/***
 	 * @throws JAXBException
 	 */
 	private void createNewCurrentSelected() throws JAXBException {
 		EntryType entryType = objFactory.createEntryType();
 		Calendar calendar = GregorianCalendar.getInstance();
 		entryType.setStartTime(calendar);
 		entryType.setComment(""); //$NON-NLS-1$
 		entryType.setDuration(0);
 		entryType.setProject(""); //$NON-NLS-1$
 		entryType.setTask(""); //$NON-NLS-1$
 		entries.setCurrentSelected(entryType);
 	}
 
 	/***
 	 * 
 	 *
 	 */
 	public final void restoreState() {
 		createEntries();
 	}
 
 	/***
 	 * 
 	 *
 	 */
 	public final void saveState() {
 		try {
 			marshall();
 		} catch (FileNotFoundException e) {
 			TimeTrackLog.logError("File Not found while Storing", e);
 		} catch (JAXBException e) {
 			TimeTrackLog.logError("JAXB Exception while storing", e);
 		}
 	}
 
 	/***
 	 * 
 	 * @return a iterator over the entries
 	 */
 	public final Iterator getEntryIterator() {
 		return entries.getEntry().iterator();
 	}
 
 	/***
 	 * 
 	 *
 	 */
 	public final void reloadState() {
 		// first we store the old state!
 		saveState();
 		// now we try to build a new state
 		restoreState();
 		setChanged();
 		notifyObservers();
 	}
 }