package uk.ac.cam.spectra;
   
   import java.io.IOException;
   import java.text.ParseException;
   import java.util.Calendar;
   import java.util.Date;
   
   import nu.xom.Attribute;
   import nu.xom.Builder;
  import nu.xom.Element;
  import nu.xom.ParsingException;
  import nu.xom.ValidityException;
  
  import org.apache.log4j.Logger;
  
  import com.hp.hpl.jena.rdf.model.Model;
  import com.hp.hpl.jena.rdf.model.Resource;
  import com.hp.hpl.jena.rdf.model.Statement;
  
  /**
   * Configuration of embargo and method to combine a set of licensing preferences
   * with an embargo release mechanism and period (usually supplied by the user,
   * and in RDF) configuratio encode Spectra embargo metadata as XML.
   * 
   * @author Jim Downing
   * @todo Refactor me: Require clients to deal with querying the RDF before
   *       calling this object, passing in a start date, number of months and
   *       release boolean themselves.
   */
  public class EmbargoMetadataEncoder {
  	private static final Logger LOG = Logger
  			.getLogger(EmbargoMetadataEncoder.class);
  
  	private String closedLicenseURL;
  
  	private String closedLicenseDescription;
  
  	private String closedLicenseMachineReadable;
  
  	private String openLicenseURL;
  
  	private String openLicenseDescription;
  
  	private String openLicenseMachineReadable;
  
  	/**
  	 * Convert any embargo metadata in the model (in the form of
  	 * "automatic"/"manual" release and embargo period in months) and use the
  	 * configured open and closed license details to create a full XML
  	 * description of the embargo.
  	 * 
  	 * @param m
  	 * @param uri
  	 * @return
  	 */
  	public Element asXML(Model m, String uri) {
  		Resource r = m.createResource(uri);
  		Statement relStmt = r.getProperty(m
  				.createProperty(SpectraMetadata.embargo_release.toURIString()));
  		if (relStmt == null) {
  			return null;
  		}
  		String release = relStmt.getLiteral().getLexicalForm();
  		Statement perStmt = r.getProperty(m
  				.createProperty(SpectraMetadata.embargo_period.toURIString()));
  		if (perStmt == null) {
  			throw new RuntimeException(
  					"Problem with metadata encoding, expected to find embargo "
  							+ "period statement in metadata");
  		}
  		int period = perStmt.getLiteral().getInt();
  		if (period == 0) {
  			return null;
  		}
  		Statement startStmt = r.getProperty(m
  				.createProperty(SpectraMetadata.embargo_date.toURIString()));
  
  		Date startD = null;
  		String start = (startStmt != null) ? startStmt.getLiteral()
  				.getLexicalForm() : null;
  		try {
  			startD = start == null ? new Date()
  					: Constants.SIMPLE_ISO_DATE_FORMAT.parse(start);
  			if (start == null) {
  				start = Constants.SIMPLE_ISO_DATE_FORMAT.format(startD);
  			}
  		} catch (ParseException e) {
  			throw new RuntimeException("Metadata encoding problem, expected "
  					+ start + " to parse as a date: " + e.getMessage(), e);
  		}
  
  		Element embargo = new Element("embargo", Constants.SPECTRA_NS);
  		Element cLic = new Element("embargoLicense", Constants.SPECTRA_NS);
  		embargo.appendChild(cLic);
  		Element cLicUrl = new Element("url", Constants.SPECTRA_NS);
  		cLic.appendChild(cLicUrl);
  		cLicUrl.appendChild(closedLicenseURL);
  		Element cLicDesc = new Element("description", Constants.SPECTRA_NS);
  		cLic.appendChild(cLicDesc);
 		cLicDesc.appendChild(closedLicenseDescription);
 
 		Builder builder = new Builder();
 		if (closedLicenseMachineReadable != null) {
 			try {
 				Element cLicMachine = builder.build(
 						closedLicenseMachineReadable, Constants.SPECTRA_NS)
 						.getRootElement();
 				cLic.appendChild(cLicMachine);
 			} catch (ValidityException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			} catch (ParsingException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			} catch (IOException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			}
 		}
 
 		Element oLic = new Element("postEmbargoLicense", Constants.SPECTRA_NS);
 		embargo.appendChild(oLic);
 		Element oLicUrl = new Element("url", Constants.SPECTRA_NS);
 		oLic.appendChild(oLicUrl);
 		oLicUrl.appendChild(openLicenseURL);
 
 		Element oLicDesc = new Element("description", Constants.SPECTRA_NS);
 		oLic.appendChild(oLicDesc);
 		oLicDesc.appendChild(openLicenseDescription);
 
 		if (openLicenseMachineReadable != null) {
 			try {
 				Element cLicMachine = builder.build(openLicenseMachineReadable,
 						Constants.SPECTRA_NS).getRootElement();
 				oLic.appendChild(cLicMachine);
 			} catch (ValidityException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			} catch (ParsingException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			} catch (IOException e) {
 				LOG.warn(
 						"Could not parse configured machine readable license as XML: "
 								+ e.getMessage(), e);
 			}
 		}
 		Element embargoStart = new Element("start", Constants.SPECTRA_NS);
 		embargo.appendChild(embargoStart);
 		embargoStart.addAttribute(new Attribute("xsi:type", Constants.XSI_NS,
 				"xsd:date"));
 		embargoStart.appendChild(start);
 		Calendar c = Calendar.getInstance();
 		c.setTime(startD);
 		c.add(Calendar.MONTH, period);
 		String end = Constants.SIMPLE_ISO_DATE_FORMAT.format(c.getTime());
 		Element embargoEnd = new Element("end", Constants.SPECTRA_NS);
 		embargo.appendChild(embargoEnd);
 		embargoEnd.addAttribute(new Attribute("xsi:type", Constants.XSI_NS,
 				"xsd:date"));
 		embargoEnd.appendChild(end);
 
 		Element releaseEl = new Element("release", Constants.SPECTRA_NS);
 		embargo.appendChild(releaseEl);
 		releaseEl.appendChild(release);
 		return embargo;
 	}
 
 	public String getClosedLicenseDescription() {
 		return closedLicenseDescription;
 	}
 
 	public void setClosedLicenseDescription(String closedLicenseDescription) {
 		this.closedLicenseDescription = closedLicenseDescription;
 	}
 
 	public String getClosedLicenseMachineReadable() {
 		return closedLicenseMachineReadable;
 	}
 
 	public void setClosedLicenseMachineReadable(
 			String closedLicenseMachineReadable) {
 		this.closedLicenseMachineReadable = closedLicenseMachineReadable;
 	}
 
 	public String getClosedLicenseURL() {
 		return closedLicenseURL;
 	}
 
 	public void setClosedLicenseURL(String closedLicenseURL) {
 		this.closedLicenseURL = closedLicenseURL;
 	}
 
 	public String getOpenLicenseDescription() {
 		return openLicenseDescription;
 	}
 
 	public void setOpenLicenseDescription(String openLicenseDescription) {
 		this.openLicenseDescription = openLicenseDescription;
 	}
 
 	public String getOpenLicenseMachineReadable() {
 		return openLicenseMachineReadable;
 	}
 
 	public void setOpenLicenseMachineReadable(String openLicenseMachineReadable) {
 		this.openLicenseMachineReadable = openLicenseMachineReadable;
 	}
 
 	public String getOpenLicenseURL() {
 		return openLicenseURL;
 	}
 
 	public void setOpenLicenseURL(String openLicenseURL) {
 		this.openLicenseURL = openLicenseURL;
 	}
 
 }