/*
    * Copyright (c) 2005 Regents of the University of California (Regents). Created
    * by TELS, Graduate School of Education, University of California at Berkeley.
    *
    * This software is distributed under the GNU Lesser General Public License, v2.
    *
    * Permission is hereby granted, without written agreement and without license
    * or royalty fees, to use, copy, modify, and distribute this software and its
    * documentation for any purpose, provided that the above copyright notice and
   * the following two paragraphs appear in all copies of this software.
   *
   * REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE. THE SOFTWAREAND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
   * HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
   * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
   *
   * IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
   * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
   * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
   * REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.sail.core.curnit;
  
  import java.beans.XMLDecoder;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URL;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.jar.Attributes;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import net.sf.sail.common.apps.PreviewCurnit;
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.beans.assembly.PodRegistry;
  import net.sf.sail.core.util.MarshallUtils;
  import net.sf.sail.core.uuid.PodUuid;
  
  /**
   * Represents a Curnit archive file. Provides methods for loading and rebuilding
   * the Curnit.
   * 
   * @see net.sf.sail.test.beans.Curnit
   * @author turadg
   * AUDIT07-
   */
  public class CurnitFile extends JarFile {
  
  	/**
  	 * Registry of pods to use for this curnit file
  	 */
  	private static final PodRegistry REGISTRY = PodRegistry
  			.getDefaultRegistry();
  	public static final String WITHINCURNIT_PROTOCOL = "withincurnit:";
  	public static final String WITHINCURNIT_BASEPATH = "withincurnit";
  
  	public static final Attributes.Name CURNIT_TITLE_ATTR = new Attributes.Name(
  			"Curnit-Title");
  
  	public static final Attributes.Name CURNIT_FORMAT_ATTR = new Attributes.Name(
  			"Curnit-Format");
  
  	public static final Attributes.Name MAIN_CLASS_ATTR = new Attributes.Name(
  			"Main-Class");
  
  	public static final Class<PreviewCurnit> MAIN_CLASS = PreviewCurnit.class;
  
  	Curnit curnitLoaded;
  
  	public static final String CURNITXML_NAME = "curnit.xml";
  
  	public static final String PODSREFERENCED_NAME = "podsReferenced.properties";
  
  	private String _title;
  
  	private Map<PodUuid, String> referencedPodsMap = new HashMap<PodUuid, String>();
  
  	public CurnitFile(File file) throws IOException {
  		super(file);
  		net.sf.sail.core.net.podar.Handler.registerProtocol();
  		net.sf.sail.core.net.curnitarchive.Handler.registerProtocol();
  	}
  
  	public String getCurnitTitle() throws IOException {
  		if (_title == null) {
  			Manifest mf = getManifest();
  			if (mf == null)
  				throw new IOException("no manifest");
  			Attributes attrs = mf.getMainAttributes();
  			_title = (String) attrs.get(CURNIT_TITLE_ATTR);
  		}
  
 		return _title;
 	}
 
 	public Curnit getCurnit() throws IOException {
 		if (curnitLoaded != null)
 			return curnitLoaded;
 
 		InputStream in;
 
 		JarEntry curnitEntry = getJarEntry(CURNITXML_NAME);
 		in = getInputStream(curnitEntry);
 		Curnit curnit = MarshallUtils.readCurnit(in);
 
 		loadPods(curnit);
 
 		return curnit;
 	}
 
 	/**
 	 * Load the content of the pods in the curnit. Linking the url of its podarchive(resources are stored) to the podid.
 	 * 
 	 * @param curnit
 	 * @throws IOException
 	 */
 	private void loadPods(Curnit curnit) throws IOException {
 		loadReferencedPodMap();
 
 		for (Map.Entry<PodUuid, String> entry : referencedPodsMap.entrySet()) {
 			PodUuid podId = entry.getKey();
 			String urlString = entry.getValue();
 			// load pod's archive
 			if (urlString.length() > 0) {
 				URL podurl;
 				if (urlString.startsWith(WITHINCURNIT_PROTOCOL)) {
 					// pod archive is stored in curnit archive
 					int offset = WITHINCURNIT_PROTOCOL.length();
 					String path = urlString.substring(offset);
 					podurl = CurnitArchiveResolver.withinCurnitArchive(curnit
 							.getCurnitId(), path);
 				} else {
 					// pod archive is out on the internet
 					podurl = new URL(urlString);
 				}
 				PodArchiveResolver.getSystemResolver().put(podId, podurl);
 			}
 
 			// then load pod's xml and unmarshall
 			loadPod(podId);
 		}
 	}
 
 	/**
 	 * Specifies the pods and its dependecy. Doesn't load in any of the jar files. creates mapping of pods.
 	 * 
 	 * @throws IOException
 	 */
 	private void loadReferencedPodMap() throws IOException {
 		InputStream in;
 		JarEntry depsEntry = getJarEntry(PODSREFERENCED_NAME);
 		in = getInputStream(depsEntry);
 		Properties deps = new Properties();
 		deps.load(in);
 		Enumeration<?> en = deps.propertyNames();
 		while (en.hasMoreElements()) {
 			String podIdStr = (String) en.nextElement();
 			PodUuid podId = new PodUuid(podIdStr);
 			String urlString = deps.getProperty(podId.toString());
 			referencedPodsMap.put(podId, urlString);
 		}
 	}
 
 	/**
 	 * @return Returns an unmodifiable version of the referencedPodsMap.
 	 */
 	public Map<PodUuid, String> getReferencedPodsMap() {
 		if (referencedPodsMap == null)
 			try {
 				loadReferencedPodMap();
 			} catch (IOException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		return Collections.unmodifiableMap(referencedPodsMap);
 	}
 
 	/**
 	 * Loads the contents of the pod and registers to a map.
 	 * 
 	 * @param podId - the podId of the pod to load
 	 * @throws IOException
 	 */
 	private void loadPod(PodUuid podId) throws IOException {
 		JarEntry podEntry = entryFor(podId);
 		InputStream in = getInputStream(podEntry);
 		XMLDecoder dec = new XMLDecoder(in);
 		dec.setExceptionListener(SAILXMLEncoder.haltingExceptionListener);
 		Pod pod = (Pod) dec.readObject();
 		REGISTRY.register(pod);
 	}
 
 	/**
 	 * Contructs a filename out of the podId
 	 * 
 	 * @param podId - podId
 	 * @return a jar entry 
 	 */
 	public static JarEntry entryFor(PodUuid podId) {
 		String filename = "POD_" + podId + ".xml";
 		return new JarEntry(filename);
 	}
 
 }