package uk.ac.cam.spectra.spectrasub;
   
   import java.io.File;
   import java.io.IOException;
   
   import nu.xom.Builder;
   import nu.xom.Document;
   import nu.xom.Nodes;
   import nu.xom.ParsingException;
  import nu.xom.ValidityException;
  
  import org.apache.log4j.Logger;
  import org.restlet.Client;
  import org.restlet.data.ChallengeResponse;
  import org.restlet.data.ChallengeScheme;
  import org.restlet.data.MediaType;
  import org.restlet.data.Method;
  import org.restlet.data.Protocol;
  import org.restlet.data.Reference;
  import org.restlet.data.Request;
  import org.restlet.data.Response;
  import org.restlet.resource.FileRepresentation;
  import org.restlet.util.Series;
  
  import uk.ac.cam.spectra.Constants;
  import uk.ac.cam.spectra.Zipper;
  
  /**
   * Implements package deposition using the restlet.org API.
   * 
   * @author ojd20
   * @todo Which of the depositor and the packager create the archive file needs
   *       to be cleaned up.
   */
  public class LNIRestletDepositor implements Depositor {
  
  	private static final Logger LOG = Logger
  			.getLogger(LNIRestletDepositor.class);
  
  	private String collectionHandle;
  
  	private DataPackageDAO dataPackageDAO;
  
  	private String lniUrl;
  
  	private String authEmail;
  
  	private String authPass;
  
  	public String getCollectionHandle() {
  		return collectionHandle;
  	}
  
  	public void setCollectionHandle(String collectionHandle) {
  		this.collectionHandle = collectionHandle;
  	}
  
  	public DataPackageDAO getDataPackageDAO() {
  		return dataPackageDAO;
  	}
  
  	public void setDataPackageDAO(DataPackageDAO dataPackageDAO) {
  		this.dataPackageDAO = dataPackageDAO;
  	}
  
  	/**
  	 * Deposits an internal package into an external LNI repository and returns
  	 * the assigned Handle.
  	 */
  	public String deposit(String packageId) {
  		// Zip up the packaging dir
  		Zipper zipper = new Zipper();
  		File zipFile = dataPackageDAO.createArchiveFile(packageId);
  		try {
  			zipper.zip(dataPackageDAO.getPackagingDirectory(packageId, false),
  					zipFile);
  		} catch (IOException e) {
  			LOG.error("Problem zipping up package: " + e.getMessage(), e);
  			throw new RuntimeException("Problem zipping up package: "
  					+ e.getMessage(), e);
  		}
  
  		Client client = new Client(Protocol.HTTP);
  		ChallengeResponse auth = new ChallengeResponse(
  				ChallengeScheme.HTTP_BASIC, authEmail, authPass);
  
  		Reference coll = lookupCollectionHandle(client, auth);
  		String loc = putPackage(zipFile, new Client(Protocol.HTTP), auth, coll);
  		String handle = findNewHandle(new Client(Protocol.HTTP), auth, loc);
  		return (handle.indexOf("hdl:") == 0) ? handle.replaceFirst("hdl:",
  				"http://hdl.handle.net/") : handle;
  	}
  
  	private String findNewHandle(Client client, ChallengeResponse auth,
  			String loc) {
  		LOG.debug("Propfinding: " + loc);
  		Request pfind = new Request(Method.PROPFIND, loc);
  		pfind.setChallengeResponse(auth);
  		Response pfindResponse = client.handle(pfind);
 		LOG.debug("Propfind returned: " + pfindResponse.getStatus());
 		try {
 			Document doc = new Builder().build(pfindResponse.getEntityAsDom()
 					.getStream());
 			Nodes nds = doc
 					.query(
 							"//dav:multistatus/dav:response/dav:propstat/dav:prop/dspace:handle/text()",
 							Constants.XPATH_CTX);
 			String handle = nds.get(0).getValue();
 			return handle;
 		} catch (IOException e) {
 			throw new RuntimeException(e);
 		} catch (ValidityException e) {
 			throw new RuntimeException(e);
 		} catch (ParsingException e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	private String putPackage(File zipFile, Client client,
 			ChallengeResponse auth, Reference coll) {
 		String pkgUrl = coll.toString() + "?package=METS&validate=false";
 		LOG.debug("Package: " + pkgUrl);
 		// PUT the package.
 		Request put = new Request(Method.PUT, pkgUrl);
 		put.setEntity(new FileRepresentation(zipFile,
 				MediaType.APPLICATION_ZIP, 100000));
 		put.setChallengeResponse(auth);
 		Response pRes = client.handle(put);
 		if (pRes.getStatus().getCode() > 300) {
 			throw new RuntimeException("Could not submit to LNI: "
 					+ pRes.getStatus() + ": "
 					+ pRes.getStatus().getDescription());
 		}
 		LOG.debug("Package submit returned: " + pRes.getStatus());
 		String loc = ((Series) pRes.getAttributes().get(
 				"org.restlet.http.headers")).getFirstValue("Location");
 		return loc;
 	}
 
 	private Reference lookupCollectionHandle(Client client,
 			ChallengeResponse auth) {
 		// Do the "right thing" - getting a redirect to the collection
 		String lookupUri = lniUrl + "/lookup/handle/" + collectionHandle;
 		LOG.debug("Lookup: " + lookupUri);
 		Request findColl = new Request(Method.GET, lookupUri);
 		findColl.setChallengeResponse(auth);
 		Response findCollR = client.handle(findColl);
 		Reference coll = findCollR.getRedirectRef();
 		if (coll == null) {
 			throw new RuntimeException("Handle lookup failed: "
 					+ findCollR.getStatus());
 		}
 		return coll;
 	}
 
 	public String getLniUrl() {
 		return lniUrl;
 	}
 
 	public void setLniUrl(String lniUrl) {
 		this.lniUrl = lniUrl;
 	}
 
 	public String getAuthEmail() {
 		return authEmail;
 	}
 
 	public void setAuthEmail(String authEmail) {
 		this.authEmail = authEmail;
 	}
 
 	public String getAuthPass() {
 		return authPass;
 	}
 
 	public void setAuthPass(String authPass) {
 		this.authPass = authPass;
 	}
 
 }