/*
 * RDFServlet.java
 *
 * Version: $Revision: 0.1 $
 *
 * Date: $Date: 2007/11/23 11:18:15 $
 *
 */

package nl.leidenuniv.dspace.app.webui.servlet;

import org.dspace.app.webui.servlet.DSpaceServlet;

import org.apache.log4j.Logger;

import java.io.IOException;
import java.sql.SQLException;
import javax.servlet.ServletException;
import org.dspace.authorize.AuthorizeException;

import org.dspace.core.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//import java.util.Enumeration;
import org.dspace.app.webui.util.UIUtil;
import org.dspace.app.webui.util.JSPManager;
//import org.dspace.core.LogManager;

//import nl.leidenuniv.dspace.metis.DSpace2MetisManager;

//import org.dspace.content.Item;
//import java.io.BufferedInputStream;
//import java.io.File;
//import java.io.InputStream;
//import java.io.FileInputStream;
//import org.dspace.content.FormatIdentifier;
//import org.dspace.authorize.ResourcePolicy;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
//import java.util.Date;
//import java.util.Calendar;
//import java.util.StringTokenizer;
import org.dspace.content.Item;
import org.dspace.content.DCValue;
import org.dspace.content.Bitstream;
//import org.dspace.content.BitstreamFormat;
//import org.dspace.content.Bundle;
//import org.dspace.eperson.Group;
//import org.dspace.app.webui.util.FileUploadRequest;
//import org.dspace.core.Constants;
import nl.leidenuniv.dspace.rdf.BitstreamArranger;
import nl.leidenuniv.dspace.rdf.RDFtriple;
import nl.leidenuniv.dspace.rdf.RDFpredicate;


/**
 * DSpace and RDF servlet.  Displays the
 * RDF edit page <code>/rdf/edit.jsp</code> on a GET or POST
 * Changes the RDF of the given DSpace object as editted by the user
 *
 * @author  Lucas van Schaik (Leiden University)
 * @version $Revision: 0.1 $
 */

public class RDFServlet extends DSpaceServlet
{
    /** log4j logger */
    private static Logger log = Logger.getLogger(RDFServlet.class);

    private final static String predicateDAI = "hasDAI";
    private final static String predicateDOI = "hasDOI";

    protected void doDSGet(Context context,
        HttpServletRequest request,
        HttpServletResponse response)
        throws ServletException, IOException, SQLException
    {
       doDSPost(context,request,response);
    }
    
    
    protected void doDSPost(Context context, HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException, SQLException {
       response.addDateHeader("expires", 1);
       response.addHeader("Pragma", "no-cache");
       response.addHeader("Cache-control", "no-store");

       Item item = null;

       int item_id = UIUtil.getIntParameter(request, "item_id");
       if (item_id > 0) {
         item = Item.find(context, item_id);
       }
       if (item == null) {
         request.setAttribute("invalid.id", new Boolean(true));
         JSPManager.showJSP(request, response,
                        "/dspace-admin/item-select.jsp");
       }
       else {
         try {
           processUpdateRDF(context,request,response,item); 
         }
         catch (AuthorizeException ae) {
           throw new ServletException("Unexpected authorization failure: "+ae);
         }
         prepItemEditForm(context,request,item);
         JSPManager.showJSP(request, response,
                        "/rdf/rdf-item-edit.jsp");
       }
    }

    void prepItemEditForm(Context c, HttpServletRequest request, Item item)
            throws SQLException
    {
        List rdfs = new ArrayList();
        
        { // herhalen voor andere DC's ????
          DCValue[] dcvs = item.getDC("contributor", "author", Item.ANY); 
          for (int i=0; i<dcvs.length; i++) {
            DCValue dcv = dcvs[i];
            Map map = new HashMap();
            String type = "dc_"+dcv.element;
            if (dcv.qualifier != null) type += "_"+dcv.qualifier;
            String predicateUri = predicateDAI;
            RDFpredicate predicate = RDFpredicate.find(c, predicateDAI);
            RDFtriple triple = RDFtriple.find(c,dcv,predicate,(Object)null);
            String dai = null;
            if (triple != null) {
              dai = (String)triple.getObject();
            }
            map.put("rdf_subject_type",type);
            map.put("rdf_subject_value",dcv.value);
            map.put("rdf_subject_text",dcv.value);
            map.put("rdf_predicate_uri",predicateUri);
            map.put("rdf_object_value",dai);
            rdfs.add(map);
          }
        }
        BitstreamArranger arranger = BitstreamArranger.getBitstreamArranger();
        Bitstream[] bitstreams = arranger.getOrderedListOfOriginalBistreams(c,item);
        for (int i=0; i<bitstreams.length; i++) {
          Map map = new HashMap();
          String predicateUri = predicateDOI;
          RDFpredicate predicate = RDFpredicate.find(c, predicateDOI);
          RDFtriple triple = RDFtriple.find(c,bitstreams[i],predicate,(Object)null);
          String doi = null;
          if (triple != null) {
            doi = (String)triple.getObject();
          }
          map.put("rdf_subject_type","bitstream");
          map.put("rdf_subject_value",new Integer(bitstreams[i].getID()));
          String text = bitstreams[i].getName();
          if (bitstreams[i].getDescription() != null) {
            text += " | "+bitstreams[i].getDescription();
          }
          map.put("rdf_subject_text",text);
          map.put("rdf_predicate_uri",predicateUri);
          map.put("rdf_object_value",doi);
          rdfs.add(map);
        } 

        request.setAttribute("item", item);
        request.setAttribute("rdfs", rdfs);
    }

    private void processUpdateRDF(Context context, HttpServletRequest request,
            HttpServletResponse response, Item item) throws ServletException,
            IOException, SQLException, AuthorizeException
    {
      String button = UIUtil.getSubmitButton(request, "submit");

      if (button.equals("submit")) {
        for (int count=1;count<1000;count++) {
          String st = request.getParameter("rdf_subject_type_"+count);
          String sv = request.getParameter("rdf_subject_value_"+count);
          String ov = request.getParameter("rdf_object_value_"+count);
          String pred = request.getParameter("rdf_predicate_uri_"+count);

          if (st == null || sv == null || pred == null) {
            break;
          } 
          Object subject = null;
          if (st.equals("bitstream")) {
            subject = Bitstream.find(context,(new Integer(sv)).intValue());  
          }
          else if (st.startsWith("dc_")) {
            String[] parts = st.split("_");
            String element = parts[1];
            String qualifier = null;
            if (parts.length > 2) {
              qualifier = parts[2];
            }
            DCValue[] dcs = item.getDC(element,qualifier,Item.ANY);
            for (int i=0; i<dcs.length; i++) {
              if (sv.equals(dcs[i].value)) {
                subject = dcs[i];
                break;
              }
            }
          }
          else {
            throw new ServletException("Unknown subject type: "+st);
          }
          RDFpredicate predicate = RDFpredicate.find(context,pred);
          if (predicate == null) {
            predicate = new RDFpredicate(context,pred);
          }
          RDFtriple triple = RDFtriple.find(context,subject,predicate,null);
          if (triple != null) {
            if (ov != null && ov.length() > 0) {
              Object obj = triple.getObject();
              if ( ! ov.equals(obj)) {
                triple.setObject(ov);
                triple.update();
              }
            }
            else {
              triple.delete();
            }
          }
          else {
            if (ov != null && ov.length() > 0) {
              triple = new RDFtriple(context,subject,predicate,ov);
            }
          }
        }
        context.commit();  
      }
    }
}