/*
 *    MGPPGDBMServices.java
 *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.greenstone.gsdl3.service;

import org.greenstone.mgpp.*;
import org.greenstone.gdbm.*;
import org.greenstone.gsdl3.util.*;

import org.w3c.dom.Document; 
import org.w3c.dom.Node; 
import org.w3c.dom.Text; 
import org.w3c.dom.Element; 
import org.w3c.dom.NodeList; 

import java.util.HashMap;
import java.util.Vector;
import java.util.Set;
import java.util.Map;
import java.util.Iterator;
/**
 * A ServicesImpl class for MGPP+GDBM
 *
 * @author <a href="mailto:kjdon@cs.waikato.ac.nz">Katherine Don</a>
 * @version $Revision: 3492 $
 * @see ServicesImpl
 */


public class MGPPGDBMServices 
    extends ServicesImpl {

    private MGPPWrapper mgpp_src_=null;
    private GDBMWrapper gdbm_src_=null;
    
    private String default_index_=null;
    private String default_level_=null;

    public MGPPGDBMServices() {
	mgpp_src_ = new MGPPWrapper();
	gdbm_src_ = new GDBMWrapper();

    }
    

    /** configure this service */
    public boolean configure(Element info) {

	System.out.println("configuring MGPPGDBMServices");

	// get the default index from <defaultIndex>
	Element def = (Element)GSXML.getChildByTagName(info, "defaultIndex");
	if (def !=null) {
	    default_index_ = def.getAttribute("name");
	}
	if (default_index_==null||default_index_.equals("")) {
	    System.err.println("Error: default index not specified!");
	    return false;
	}

	System.out.println("default index="+default_index_);

	// get the default level out of <defaultLevel>
	def = (Element)GSXML.getChildByTagName(info, "defaultLevel");
	if (def !=null) {
	    default_level_ = def.getAttribute("name");
	}
	if (default_level_==null||default_level_.equals("")) {
	    System.err.println("Error: default level not specified!");
	    return false;
	}
	// the default level is also the level which gdbm is expecting
	mgpp_src_.setReturnLevel(default_level_);
	System.out.println("default level="+default_level_);

	// set up which services are available for this collection
	Element e = null;
	// these entries should reflect the build config file - some services may not be available depending on how the collection was built.

	// set up short_service_info_ - for now just has name and type
	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "TextQuery");
	short_service_info_.appendChild(e);

	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "FieldQuery");
	short_service_info_.appendChild(e);

	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "ResourceRetrieve");
	short_service_info_.appendChild(e);

	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "MetadataRetrieve");
	short_service_info_.appendChild(e);

	// set up service_info_map_ - for now, just has the same elements as above
	// should have full details about each service incl params lists etc.
	// do the text query one - for now a static list. later use buildcfg.xml values to dynamically change this
	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "TextQuery");
	Element paramList = doc_.createElement("paramList");
	Element param;
	// first do index and level params

	// the index info - read from config file
	Element index_list = (Element)GSXML.getChildByTagName(info, "indexList");
	NodeList indexes = index_list.getElementsByTagName("index");
	int len = indexes.getLength();
	if (len > 1) {
	    // add level param to list
	    String [] inds  = new String[len];
	    for (int i=0; i<len; i++) {
		inds[i] = ((Element)indexes.item(i)).getAttribute("name");
	    }
	    param = GSXML.createParameter(doc_, "index", GSXML.PARAM_TYPE_ENUM, default_index_, inds);
	    paramList.appendChild(param);
	} // else dont need to add it

	// the level info - read from config file
	Element level_list = (Element)GSXML.getChildByTagName(info, "levelList");
	NodeList levels = level_list.getElementsByTagName("level");
	len = levels.getLength();
	if (len > 1) {
	    // add level param to list
	    String [] levs  = new String[len];
	    for (int i=0; i<len; i++) {
		levs[i] = ((Element)levels.item(i)).getAttribute("name");
	    }
	    param = GSXML.createParameter(doc_, "queryLevel", GSXML.PARAM_TYPE_ENUM, default_level_, levs);
	    paramList.appendChild(param);
	} // else dont need to add it

	// boolean params
	param = GSXML.createParameter(doc_, "case", GSXML.PARAM_TYPE_BOOLEAN, "1", null);
	paramList.appendChild(param);
	param = GSXML.createParameter(doc_, "stem", GSXML.PARAM_TYPE_BOOLEAN, "1", null);
	paramList.appendChild(param);
	// enum params
	String []vals = {"all", "some"};
	param = GSXML.createParameter(doc_, "matchMode", GSXML.PARAM_TYPE_ENUM, "all", vals);
	paramList.appendChild(param);
	String [] vals1 = {"rank", "natural"};
	param = GSXML.createParameter(doc_, "sortBy", GSXML.PARAM_TYPE_ENUM, "rank", vals1 );
	paramList.appendChild(param);

	// Integer params
	param = GSXML.createParameter(doc_, "maxDocs", GSXML.PARAM_TYPE_INTEGER, "10", null);
	paramList.appendChild(param);


	e.appendChild(paramList);
	
	service_info_map_.put("TextQuery", e);
	

	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "FieldQuery");
	service_info_map_.put("FieldQuery", e);
	
	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "ResourceRetrieve");
	service_info_map_.put("ResourceRetrieve", e);
	
	e = doc_.createElement("service");
	e.setAttribute("type", "query");
	e.setAttribute("name", "MetadataRetrieve");
	service_info_map_.put("MetadataRetrieve", e);

	if (gdbm_src_.openDatabase(GSFile.GDBMDatabaseFile(site_home_, cluster_name_), GDBMWrapper.READER)) {
	    return true;
	}
	else {
	    System.err.println("couldn't open gdbm database!");
	    return false;
	}
    }
       

    /** passes the request Element to the appropriate service function*/
    protected Element processService(String name, Element request) {

	// dont need to check that the service name is  supported for this particular object, because that has been checked by ServicesImpl
	if (name.equals("TextQuery")) {
	    return processTextQuery(request);
	} else if(name.equals("FieldQuery")) {
	    return processFieldQuery(request);
	} else if (name.equals("ResourceRetrieve")) {
	    return processResourceRetrieve(request);
	} else if (name.equals("MetadataRetrieve")) {
	    return processMetadataRetrieve(request);
	}
	
	System.err.println("MGPPGDBMServices:should never get here. service type wrong:"+name);
	return null;
	
	
    }

    /** process a text query */
    protected Element processTextQuery(Element request) {

	Element result = doc_.createElement("response");
	String from = GSPath.appendLink(cluster_name_, "TextQuery");
	result.setAttribute("from", from);
	result.setAttribute("type", "query");
	
	// get param list and content
	Element param_elem=null;
	Element content_elem=null;
	Node n = request.getFirstChild();
	while (n!=null) {
	  String node_name = n.getNodeName();
	  if (node_name.equals("paramList")) {
	      param_elem = (Element)n;
	  } else if (node_name.equals("content")) {
	      content_elem = (Element)n;
	  }
	  n = n.getNextSibling();
	}

	if (param_elem==null || content_elem==null) {
	    System.out.println("bad query request");
	    return result; // empty result
	}

	// get the query string
	String query = GSXML.getNodeText(content_elem);
	if (query==null) {
	    System.out.println("nothing to query");
	    return result;
	}

	HashMap params = GSXML.extractParams(param_elem);
	String index = (String)params.get("index"); 
	if (index==null) { // if its not present, use the default index
	    index=default_index_;
	}

	// now set up the mgpp stuff
	String basedir = GSFile.collectionBaseDir(site_home_, 
						  cluster_name_);
	String indexdir = GSFile.collectionIndexPath(cluster_name_, index);

	mgpp_src_.loadIndexData(basedir, indexdir);
	setQueryParams(params);
	
	mgpp_src_.runQuery(query);
	MGPPQueryResult mqr= mgpp_src_.getQueryResult();
	
	// get the docnums out, and convert to HASH ids
	Vector docs = mqr.getDocs();
	if (docs.size()==0) {
	    // no docs found
	    return result;
	}
	// create a resourceList element
	Element c = doc_.createElement("content");
	result.appendChild(c);
	Element resource_list = doc_.createElement("resourceList");
	c.appendChild(resource_list);
	// add each resource
	for (int d=0; d<docs.size(); d++) {
	    long docnum = ((MGPPDocInfo)docs.elementAt(d)).num_;
	    String id = gdbm_src_.docnum2Oid(docnum);
	    Node no = GSXML.createResourceElement(doc_, id);
	    resource_list.appendChild(no);
	}
	return result;
    }//processTextQuery

    /** process a fielded query */
    protected Element processFieldQuery(Element request) {
	Element result = doc_.createElement("response");
	String from = GSPath.appendLink(cluster_name_, "FieldQuery");
	result.setAttribute("from", from);
	result.setAttribute("type", "query");

	
	// dummy result
	Text t = null;
	t = doc_.createTextNode("Fieldquery result... ");
	result.appendChild(t);
	return result;
    }

    /** retrieve a document */
    protected Element processResourceRetrieve(Element request) {

	// where the mgpp text files are
	String basedir = GSFile.collectionBaseDir(site_home_, 
						  cluster_name_);
	String textdir = GSFile.collectionTextPath(cluster_name_);

	// an empty result
	Element result = doc_.createElement("response");
	String from = GSPath.appendLink(cluster_name_, "ResourceRetrieve");
	result.setAttribute("from", from);
	result.setAttribute("type", "query");
	Element result_doc = doc_.createElement("content");
	result.appendChild(result_doc);
	
	// get param list and content - this code same as for TextQuery - put
	// somewhere else?
	Element param_elem=null;
	Element content_elem=null;
	Node n = request.getFirstChild();
	while (n!=null) {
	  String node_name = n.getNodeName();
	  if (node_name.equals("paramList")) {
	      param_elem = (Element)n;
	  } else if (node_name.equals("content")) {
	      content_elem = (Element)n;
	  }
	  n = n.getNextSibling();
	}

	if (param_elem==null || content_elem==null) {
	    System.out.println("bad query request");
	    return result; // empty result
	}
	
	HashMap params = GSXML.extractParams(param_elem);
	String resource_type = (String)params.get("resourceType");
	if (resource_type==null) {
	    System.out.println("no resourceType defined, assume 'core'");
	    // have error? or assume that its core?
	    resource_type="core";
	}

	if (resource_type.equals("core")) {
	    // get docs from mgpp, and possibly associated files too
	    String level = (String)params.get("level"); // level at which to 
	    // retrieve a doc
	    if (level==null) {
		level=default_level_;
	    }
	    // whether to just get the doc, or all assoc files too.
	    String retrieve_extent = (String)params.get("retrieveExtent");
	    if (retrieve_extent==null) {
		// assume just the doc
		retrieve_extent = "docOnly";
	    }

	    // always get the doc (for now - this may change later)
	    // get the doc text, and if retrieveExtent = allFiles, get assoc files too	
	    
	    String []ids = GSXML.getResourceNameList(content_elem);
	    for (int j=0; j<ids.length; j++) {
		long real_num = gdbm_src_.oid2Docnum(ids[j]);
		System.out.println("getting doc text, basedir="+basedir+", textdir="+textdir+", level="+level+", num="+real_num);
		String document = mgpp_src_.getDocument(basedir, textdir,  level, real_num);
	    // for now, stick it in a text node - eventually should be parsed as xml??

		// something funny with the doc - 
		Element new_doc = GSXML.createResourceElement(doc_, ids[j]);
		GSXML.addDocText(doc_, new_doc, document);
		if (retrieve_extent.equals("allFiles")) {
		    // get the assoc files too
		}
		result_doc.appendChild(new_doc);
	    }
	    
	} else if (resource_type.equals("assoc")) {
	    // get associated files
	    String assoc_file_dir = (String)params.get("assocfilepath");
	    if (assoc_file_dir==null) {
		System.err.println("need assocfilepath to find files");
		
	    } else {
		String []files = GSXML.getResourceNameList(content_elem);
		for (int j=0; j<files.length; j++) {
		    Element new_doc = GSXML.createResourceElement(doc_, 
								  files[j]);
		    // add the file
		    result_doc.appendChild(new_doc);
		}
	    }
	} else {
	    System.out.println("error: resource Type is not legal");
	}
	
	return result;

    }

    /** retrieve metadata */
    protected Element processMetadataRetrieve(Element request) {
	Element result = doc_.createElement("response");
	String from = GSPath.appendLink(cluster_name_, "MetadataRetrieve");
	result.setAttribute("from", from);
	result.setAttribute("type", "query");
	Element result_content = doc_.createElement("content");
	result.appendChild(result_content);
	Element resource_list = doc_.createElement("resourceList");
	result_content.appendChild(resource_list);
	// get the metadata
	
	Element content = (Element)request.getElementsByTagName("content").item(0);
	if (content==null) {
	    // error: query had no content!! - should make an error message
	    return result;
	}
	String []metas = GSXML.getMetaNameList(content);
	String []ids = GSXML.getResourceNameList(content);
	for (int j=0; j<ids.length; j++) { // for each document
	    Element doc = GSXML.createResourceElement(doc_, ids[j]);
	    Element list = GSXML.addMetaList(doc_, doc);
	    DBInfo info = gdbm_src_.getInfo(ids[j]);
	    for (int m=0; m<metas.length; m++) {
		String value = info.getInfo(metas[m]);
		GSXML.addMetadata(doc_, list, metas[m], value);
	    }
	    resource_list.appendChild(doc);
	}
	return result;
    }

    // should probably use a list rather than map
    protected boolean setQueryParams(HashMap params) {

	Set entries = params.entrySet();
	Iterator i = entries.iterator();
	while (i.hasNext()) {
	    Map.Entry m = (Map.Entry)i.next();
	    String name = (String)m.getKey();
	    String value = (String)m.getValue();
	   
	    if (name.equals("case")) {
		boolean val = (value.equals("1")?true:false);
		mgpp_src_.setCase(val);		
	    } else if (name.equals("stem")) {
		boolean val = (value.equals("1")?true:false);
		mgpp_src_.setStem(val);
	    } else if (name.equals("maxDocs")) {
		int docs = Integer.parseInt(value);
		mgpp_src_.setMaxDocs(docs);
	    } else if (name.equals("queryLevel")) {
		mgpp_src_.setQueryLevel(value);
	    } else if (name.equals("resultLevel")) {
		mgpp_src_.setReturnLevel(value);
	    } else if (name.equals("matchMode")) {
		int mode;
		if (value.equals("all")) mode=1;
		else mode=0;
		mgpp_src_.setMatchMode(mode);
	    } else if (name.equals("sortBy")) {
		if (value.equals("rank")) {
		    mgpp_src_.setSortByRank(true);
		} else if (value.equals("natural")) {
		    mgpp_src_.setSortByRank(false);
		}
	    } else if (name.equals("termInfo")) {
		boolean val = (value.equals("1")?true:false);
		mgpp_src_.setReturnTerms(val);
	    } // ignore any others
	}
	return true;
    }


}