package org.greenstone3.ms;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.math.BigDecimal;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.greenstone.gsdl3.core.MessageRouter;
import org.greenstone.gsdl3.util.XMLConverter;

public class DataMaker {
    
    MetadataStats  ms;
    ArrayList nameList;
    private int Mode;
    private int TotalDoc; 
    private String path;
    
    protected Document doc=null;
    protected MessageRouter mr = null;
    protected XMLConverter converter=null;
    private ArrayList removedID = new ArrayList();
    private HashMap elementMap = new HashMap();
    private static final int DEF_DIV_SCALE = 10;
    
    public DataMaker(MetadataStats arg1){
	ms = arg1;
	nameList = arg1.metadataNameList;
	path = arg1.myNewDir;
	setTotalDocNumber();
    }
    
    
    private Element getRootNode(String core_element){
	
    	if(elementMap.containsKey(core_element)){
    		return (Element)elementMap.get(core_element);
    	}
	try{
	    DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
	    DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
	    Document doc = docBuilder.newDocument();
	    doc = docBuilder.parse (new File(path+"/"+core_element+".xml"));
	    Element rootNode = doc.getDocumentElement();
	    //elementMap.put(core_element, rootNode);
	    return rootNode;   
    	}catch (Exception e) {
    	    e.printStackTrace();
    	    return null;
    	}
    }
    
    
    public void setTotalDocNumber(){
    	Element ex = getRootNode("archivedir");
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	TotalDoc = listOfFrequency.getLength();
    }
    
    public int getTotalElementUsed(){
	
	int totalNumber = 0;
	
	for(int i = 0 ; i<nameList.size(); i++){
	    
	    Element ex = getRootNode((String)nameList.get(i));
	    NodeList listOfFrequency = ex.getElementsByTagName("Frequency");
	
	    for(int s=0; s<listOfFrequency.getLength() ; s++){
	    	Node FrequencyNode = listOfFrequency.item(s);
	    	NodeList textFNList = FrequencyNode.getChildNodes();
	    	String TextNode = textFNList.item(0).getNodeValue();
	    	totalNumber = totalNumber + Integer.parseInt(TextNode);
	    }
	}
	return totalNumber;
    }
      
    public int getFrequency(String name){
	
        int totalNumber = 0;
      	
        Element ex = getRootNode(name);
      	NodeList listOfFrequency = ex.getElementsByTagName("Frequency");
      	if(listOfFrequency.getLength()==0){return 0;}
      	
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    Node FrequencyNode = listOfFrequency.item(s);
	    NodeList textFNList = FrequencyNode.getChildNodes();
	    String TextNode = textFNList.item(0).getNodeValue();
	    int x = Integer.parseInt(TextNode);
	    totalNumber = totalNumber + x;
        }
	return totalNumber;
    }
    
    public int getDistinctNumber(String name){
	
        ArrayList alist = new ArrayList();
      	Element ex = getRootNode(name);
      	NodeList listOfFrequency = ex.getElementsByTagName("ActualValue");
      	
	if(listOfFrequency.getLength()==0){
	    return 0;
	}
        
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    Node ActualValueNode = listOfFrequency.item(s);
	    NodeList textFNList = ActualValueNode.getChildNodes();
	    String TextNode = textFNList.item(0).getNodeValue();
	    
	    if(!alist.contains(TextNode) && !TextNode.equals(" ")){
		alist.add(TextNode);
	    }
        }
	return alist.size();
    }
    
    public int getDocumentUsedElement(String core_element){
    
        int totalNumber = 0;
      	Element ex = getRootNode(core_element);
      	NodeList listOfFrequency = ex.getElementsByTagName("Frequency");
    	for(int s=0; s<listOfFrequency.getLength() ; s++){
      		totalNumber++;
        }
	return totalNumber;
    }
       
    // for all elements
    public double Mean(String core_element){
    	
	int due = getDocumentUsedElement(core_element);
	
    	if(due==0 || TotalDoc==0){return 0;}
    	Double d1 = new Double(due);
    	Double d2 = new Double(TotalDoc);
    	Double result = div(d1,d2);
    	result = mul(result, new Double(100));
    	return round(result.doubleValue(),1);
    }
    
    public int getMinRange(String core_element){
	
      	Element ex = getRootNode(core_element);
      	NodeList listOfFrequency = ex.getElementsByTagName("Frequency");
      	
        if(listOfFrequency.getLength()==0){return 0;}
        
    	Node FrequencyNode = listOfFrequency.item(0);
    	NodeList textFNList = FrequencyNode.getChildNodes();
    	String TextNode = textFNList.item(0).getNodeValue();
        int minNumber = 0;
        
        if(listOfFrequency.getLength()==TotalDoc){
	    minNumber = Integer.parseInt(TextNode);
        }
        
        else {
	    minNumber = 0;
        }
        
        for(int s=0; s<listOfFrequency.getLength() ; s++){
	    FrequencyNode = listOfFrequency.item(s);
	    textFNList = FrequencyNode.getChildNodes();
	    TextNode = textFNList.item(0).getNodeValue();
	    int x = Integer.parseInt(TextNode);
	    if(x<minNumber){minNumber=x;}
        }
	return minNumber;
    }
    
    public int getMaxRange(String core_element){
	
      	Element ex = getRootNode(core_element);
      	NodeList listOfFrequency = ex.getElementsByTagName("Frequency");
        if(listOfFrequency.getLength()==0){return 0;}
    	Node FrequencyNode = listOfFrequency.item(0);
    	NodeList textFNList = FrequencyNode.getChildNodes();
    	String TextNode = textFNList.item(0).getNodeValue();
        int maxNumber = 0;
        
        for(int s=0; s<listOfFrequency.getLength() ; s++){
	    FrequencyNode = listOfFrequency.item(s);
	    textFNList = FrequencyNode.getChildNodes();
	    TextNode = textFNList.item(0).getNodeValue();
	    int x = Integer.parseInt(TextNode);
	    if(x>maxNumber){maxNumber=x;}
        }
	return maxNumber;
    }
    
    public int getMode(String core_element){
	
    	Element ex = getRootNode(core_element);
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	if(listOfFrequency.getLength()==0){Mode = 0; return 0;}
    	ArrayList alist = new ArrayList();
    	String[] idsx = getDocumentIDs(core_element);
    	
	for(int i = 0; i<idsx.length; i++){
	    alist.add(idsx[i]);
    	}
    	int[] list = new int[TotalDoc];
    	
	for(int i = 0; i<list.length; i++){
	    list[i] = 0;
    	}
	
    	for(int s=0; s< listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    NamedNodeMap NodeIDMap = docNode.getAttributes();
	    Node DocNodeID = NodeIDMap.item(0);
	    String DocID = DocNodeID.getNodeValue();
	    Element xNode = (Element)docNode;
	    int location = alist.indexOf(DocID);
	    NodeList xList = xNode.getElementsByTagName("Frequency");
	    int fre = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = fre;
    	}
    	
        Arrays.sort(list);
	
	int max_idx = 0; // Index of the maximum count
	int max_cnt = 0;
	int count = 0;
	
	for ( int i = 0; i <list.length; i++) {
	    count = 0;
	    for ( int j = 0; j < list.length; j++) {
		if (list[i] == list[j]) {
		    count++;
		}
	    }
	    if (count > max_cnt) {
		max_cnt = count;
		max_idx = i;
	    }	
	}
	Mode = list [max_idx];
	return list [max_idx];

    }
    
    public double ModeFrequency(String core_element){
	
    	Element ex = getRootNode(core_element);
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	if(listOfFrequency.getLength()==0){ return 100;}
    	ArrayList alist = new ArrayList();
    	String[] idsx = getDocumentIDs(core_element);
    	
	for(int i = 0; i<idsx.length; i++){
	    alist.add(idsx[i]);
    	}
	
    	int[] list = new int[TotalDoc];
    	
	for(int i = 0; i<list.length; i++){
	    list[i] = 0;
    	}
    	
    	int length = alist.size();
    	int counter = 0;
    	
    	for(int s=0; s< listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    NamedNodeMap NodeIDMap = docNode.getAttributes();
	    Node DocNodeID = NodeIDMap.item(0);
	    String DocID = DocNodeID.getNodeValue();
	    Element xNode = (Element)docNode;
	    int location = alist.indexOf(DocID);
	    NodeList xList = xNode.getElementsByTagName("Frequency");
	    int fre = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = fre;
    	}
	
    	for(int i =0; i<list.length; i++){
	    if(list[i]==Mode){counter++;}
    	}

        Double result = div(new Double(counter), new Double(length));
        result = mul(result ,new Double (100));
        return round(result.doubleValue(),1);
    }
    
    public double Median(String core_element){
	   	
    	Element ex = getRootNode(core_element);
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
  
    	ArrayList alist = new ArrayList();
    	String[] idsx = getDocumentIDs(core_element);

    	for(int i = 0; i<idsx.length; i++){
	    alist.add(idsx[i]);
    	}

    	int[] list = new int[TotalDoc];

    	for(int i = 0; i<list.length; i++){
	    list[i] = 0;
    	}
    	
    	for(int s=0; s< listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    NamedNodeMap NodeIDMap = docNode.getAttributes();
	    Node DocNodeID = NodeIDMap.item(0);
	    String DocID = DocNodeID.getNodeValue();
	    Element xNode = (Element)docNode;
	    int location = alist.indexOf(DocID);
	    NodeList xList = xNode.getElementsByTagName("Frequency");
	    int fre = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = fre;
    	}
    	      	
        int length = alist.size();
      	int middle = length/2 -1;
      	
        Arrays.sort(list);
	
	if(length % 2 == 1){
	    middle = middle + 1;
	    return list[middle];
	}
	
	else{
	    return  round((double)(list[middle]+list[middle+1])/2,1);
	}
    }
        
    // for all elements
    public double Average(String core_element){
    	
    	int t1 = getFrequency(core_element);
    	int t2 = getDocumentUsedElement(core_element);
    	if(t1==0 || t2==0){return 0;}
    	Double result = div(new Double(t1),new Double(t2));
    	return	round(result.doubleValue(),1);
    }
    
    public Object[][] AllInformation(){
    	
	int rows = nameList.size();
    	int cols = 11;
    	int y = 0;

    	Object[][] info = new Object[rows][cols];
    	String[] list = new String[rows];
    	
	for(int i = 0 ; i < list.length; i++){
	    list[i] = nameList.get(i).toString();
    	}
	
    	Arrays.sort(list);
    	
    	for(int iu = 0; iu<list.length; iu++){ 
    	    String xi = list[iu];
	    info[y][0] = xi ;
	    info[y][1] = new Integer(getFrequency(xi));
	    info[y][2] = new Integer(getDocumentUsedElement(xi));
	    info[y][3] = new Double(Mean(xi));
	    info[y][4] = new Double(Median(xi));
	    info[y][5] = new Integer(getDistinctNumber(xi));
	    info[y][6] = new Integer(getMinRange(xi));
	    info[y][7] = new Integer(getMaxRange(xi));
	    info[y][8] = new Double(Average(xi));
	    info[y][9] = new Integer(getMode(xi));
	    info[y][10] = ModeFrequency(xi)+"%";
	    y++;
	}
    	return info;
    }
    
    public String[] getSortList(String core_element,String sort){
	
    	if(sort.equals("ASCII")){
    		HashMap hp = getDistinctValueMap (core_element);
    		String[] temp = new String[hp.size()];
    		int counter = 0;
    		Set s = hp.keySet();
    		Iterator i = s.iterator();

    		while(i.hasNext()){
    			temp[counter] = (String)i.next();
    			counter++;
    		}
	    
    		Arrays.sort(temp);
    		return temp;
    	}
	
    	else{
    		Map m = getDistinctValueMap (core_element);
    		ArrayList outputList = sortMap(m);
    		String[] temp = new String[outputList.size()];
	    
    		for(int i = 0; i< outputList.size(); i++){
    			Map.Entry entry = (Map.Entry) outputList.get(i);
    			temp[i] = (String) entry.getKey();
    		}
    		
	    return temp;
    	}
	
    }

    
    /*
     * Actually, we can directly access to "ActualValue" node instead of document node
     */
    
    public HashMap getDistinctValueMap(String core_element){
    	
	Element ex = getRootNode(core_element);
    	HashMap hp = new HashMap();
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    Element docElement = (Element)docNode;
	    NodeList valueList = docElement.getElementsByTagName("ActualValue");
	    
	    for(int y = 0; y<valueList.getLength(); y++){
		Element valueElement = (Element)valueList.item(y);
		NodeList textFNList = valueElement.getChildNodes();
		String text = ((Node)textFNList.item(0)).getNodeValue();
		
		if(!text.equals(" ")){
		    if(hp.containsKey(text)){
			Integer i = (Integer)hp.get(text);
			int number = i.intValue();
			number++;
			hp.put(text,new Integer(number));
		    }
		    else{
			Integer i = new Integer(1);
			hp.put(text, i);
		    }
		}
	    }
    	}               
    	return hp;
    }
    
    public HashMap getDocFrequencyMap(String core_element){
    	
	Element ex = getRootNode(core_element);
    	HashMap hp = new HashMap();
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    
	    Node docNode = listOfFrequency.item(s);  
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    
	    Element docElement = (Element)docNode;
	    NodeList valueList = docElement.getElementsByTagName("Frequency");
	    Element frequencyElement = (Element)valueList.item(0);
	    NodeList textFNList = frequencyElement.getChildNodes();
	    String text = ((Node)textFNList.item(0)).getNodeValue();
	    Integer i = new Integer(Integer.parseInt(text));
	    hp.put(att_name, i);
    	}               
    	return hp;
    }
    

    public String[] getDocumentIDs(String core_element){
	
    	Element ex = getRootNode("archivedir");
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	String[] ids = new String[listOfFrequency.getLength()];
    	
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    ids[s] = att_name;
    	}
    	return (String[])ids.clone();
    }
    
    public int[] getMetadataRows(String core_element){
    	Element ex = getRootNode(core_element);
    	//ArrayList alist = ms.getIDArray();
    	ArrayList alist = new ArrayList();
    	String[] idsx = getDocumentIDs(core_element);
	
    	for(int i = 0; i<idsx.length; i++){
    		alist.add(idsx[i]);
    	}

    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	int[] row = new int[TotalDoc];
	
    	for(int i = 0; i<row.length; i++){
    		row [i] = 0;
    	}
    	
    	for(int s=0; s<listOfFrequency.getLength() ; s++){   
    		Node docNode = listOfFrequency.item(s);
    		int location = alist.indexOf(docNode.getAttributes().item(0).getNodeValue());
    		row[location] =1;
    
   	}
    	return row;
    }
        
    /**
     * This method will use Arrays.sort for sorting Map
     * @param map
     * @return outputList of Map.Entries
     */

    public ArrayList sortMap(Map map) {
	ArrayList outputList = null;
	int count = 0;
	Set set = null;
	Map.Entry[] entries = null;
	//     Logic:
	//     get a set from Map
	//     Build a Map.Entry[] from set
	//     Sort the list using Arrays.sort
	//     Add the sorted Map.Entries into arrayList and return
	
	set = (Set) map.entrySet();
	Iterator iterator = set.iterator();
	entries = new Map.Entry[set.size()];
	while(iterator.hasNext()) {
	    entries[count++] = (Map.Entry) iterator.next();
	}
	
	//     Sort the entries with your own comparator for the values:
	Arrays.sort(entries, new Comparator() {
		public int compareTo(Object lhs, Object rhs) {
		    Map.Entry le = (Map.Entry)lhs;
		    Map.Entry re = (Map.Entry)rhs;
		    return ((Comparable)le.getValue()).compareTo((Comparable)re.getValue());
		}
		
		public int compare(Object lhs, Object rhs) {
		    Map.Entry le = (Map.Entry)lhs;
		    Map.Entry re = (Map.Entry)rhs;
		    return ((Comparable)le.getValue()).compareTo((Comparable)re.getValue());
		}
	    });

	outputList = new ArrayList();
	for(int i = 0; i < entries.length; i++) {
	    outputList.add(entries[i]);
	}
	return outputList;
    }//End of sortMap
    
    private Double div(Double d1, Double d2){
    	BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return new Double(b1.divide(b2,DEF_DIV_SCALE,BigDecimal.ROUND_HALF_UP).doubleValue());
    }
    
    private Double mul(Double d1,Double d2){
        BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return new Double(b1.multiply(b2).doubleValue());
    }
    
    public double round(double v,int scale){
        if(scale<0){
            throw new IllegalArgumentException(
					       "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    
    public double getSingleMetadataSetCompleteness(ArrayList mds_list){
   
    	int totalElement = 0;
    	int totalElementUsed = 0;
    
	for(int a = 0; a<mds_list.size(); a++){
	    MetadataSet mds = (MetadataSet)mds_list.get(a);
	
	    ArrayList alist = mds.getIndexsList();

	    int length = alist.size();

	    totalElement = totalElement + length * TotalDoc;
	    for(int i = 0; i<alist.size(); i++){
	    	String name = (String)alist.get(i);
	    	
	    	totalElementUsed = totalElementUsed + getDocumentUsedElement(name);
	  
	    }
	}
    	double x = (double)totalElementUsed/totalElement;
    	Double d1 = new Double(x);
    	Double d2 = new Double(100);
    	Double result = mul(d1,d2);
    
    	return round(result.doubleValue(),1);
    }
    
    public Object[][] getMetadataInfo(MetadataSet mds){
    	
    	ArrayList alist = mds.getIndexsList();
    	int rows = alist.size();
    	int cols = 11;
    	int y = 0;
    	Object[][] dataset = new Object[rows][cols];
    	
       	String[] list = new String[rows];
    	
	for(int i = 0 ; i < list.length; i++){
	    list[i] = alist.get(i).toString();
	 
    	}
	
    	Arrays.sort(list);
    	
    	for(int iu = 0; iu<list.length; iu++){
    	    String xi = list[iu];
    	    dataset[y][0] = xi ;
    	    dataset[y][1] = new Integer(getFrequency(xi));
    	    dataset[y][2] = new Integer(getDocumentUsedElement(xi));
    	    dataset[y][3] = new Double (Mean(xi));
    	    dataset[y][4] = new Double (Median(xi));
    	    dataset[y][5] = new Integer(getDistinctNumber(xi));
    	    dataset[y][6] = new Integer(getMinRange(xi));
    	    dataset[y][7] = new Integer(getMaxRange(xi));
    	    dataset[y][8] = new Double (Average(xi));
    	    dataset[y][9] = new Integer(getMode(xi));
    	    dataset[y][10] = ModeFrequency(xi)+"%";
	    y++;
	    
    	}
    	return dataset;
    }
    
    public boolean IsElementEmpty(String core_element){
    	
    	int[] list = getMetadataRows(core_element);
    	boolean status = true;
    	
	for(int i = 0; i< list.length; i++){
    		if(list[i]==1){status = false;}
    	}
    	return status;
    }
    
    public boolean IsElementFull(String core_element){
    	
    	int[] list = getMetadataRows(core_element);
    	boolean status = true;
    	
	for(int i = 0; i< list.length; i++){
    		if(list[i]==0){status = false;}
    	}
    	return status;
    }
    
    public ArrayList removeDocument(ArrayList dataset, String[] ids, int number){
    	removedID = new ArrayList();
    	
    	int[] metadataLevel =(int[])dataset.get(0);
    	int docIDslength = metadataLevel.length;
    	int[][] valueMap = new int[dataset.size()][docIDslength];
    	
    	for(int i = 0; i< docIDslength; i++){
    		
    		boolean status = true;
    		
    		for(int j = 0; j<dataset.size(); j++){
    		 int[] metadataLevelArray = (int[])dataset.get(j);
    		 valueMap[j][i] =  metadataLevelArray[i];
    		 if(metadataLevelArray[i]!=number){status = false;}
    	
    		}
    		if(status == true){
		
		    for(int j = 0; j<dataset.size(); j++){

			valueMap[j][i]=-1;

		    }
		    removedID.add(ids[i]);
    		}
    	}
    	ArrayList wholeList = new ArrayList();

    	for(int i = 0; i<valueMap.length; i++){
	    ArrayList numberList = new ArrayList();
	    
	    for(int j = 0; j<valueMap[i].length; j++){
		numberList.add(new Integer(valueMap[i][j]));
	    }
	    wholeList.add(numberList);
    	}
    	
    	for(int i =0; i< wholeList.size(); i++){
	    ArrayList numberList = (ArrayList)wholeList.get(i);
	    Integer value = new Integer(-1);
	    while(numberList.contains(value)){
		numberList.remove(value);
	    }
	    int[] valueList = new int [numberList.size()];
	    
	    for(int j = 0; j< valueList.length; j++){
		valueList[j] = ((Integer)numberList.get(j)).intValue();
	    }
	    wholeList.remove(i);
	    wholeList.add(i,valueList);
    	}
   
    	return wholeList;
    }
    
    public ArrayList getRemovedID(){
    	return removedID;
    }
    
    public int getDocNum(){
    	return TotalDoc;
    }
       
    public HashMap getInternalIdentifier(String core_element){
    	
    	Element ex = getRootNode(core_element);
        HashMap hp = new HashMap();
        NodeList listOfFrequency = ex.getElementsByTagName("Document");
        	
    	for(int s=0; s<listOfFrequency.getLength() ; s++){
    	    Node docNode = listOfFrequency.item(s);
    	    String HashID = docNode.getAttributes().item(0).getNodeValue();
    	    //System.out.println(HashID);
    	    Element docElement = (Element)docNode;
    	    NodeList valueList = docElement.getElementsByTagName("ActualValue");
    	    
    	    for(int y = 0; y<valueList.getLength(); y++){
    		Element valueElement = (Element)valueList.item(y);
    		NodeList textFNList = valueElement.getChildNodes();
    		String text = ((Node)textFNList.item(0)).getNodeValue();
    		
    		if(!text.equals(" ")){
    		    if(hp.containsKey(text)){
    			InternalLink il = (InternalLink)hp.get(text);
    			il.increaseElement(HashID);
    			hp.put(text,il);
    		    }
    		    else{
    		    InternalLink il = new InternalLink();
    			il.setValue(text);
    			il.increaseElement(HashID);
    			hp.put(text, il);
    		    }
    		}
    	    }
        	}               
        	return hp;
        }
        

    public HashMap getIdentifierLink(String core_element){
    	
    	Element ex = getRootNode(core_element);
        HashMap hp = new HashMap();
        NodeList listOfFrequency = ex.getElementsByTagName("Document");
        	
    	for(int s=0; s<listOfFrequency.getLength() ; s++){
    	    Node docNode = listOfFrequency.item(s);
    	    String HashID = docNode.getAttributes().item(0).getNodeValue();
    	    Element docElement = (Element)docNode;
    	    NodeList valueList = docElement.getElementsByTagName("ActualValue");
    	    
    	    for(int y = 0; y<valueList.getLength(); y++){
    		Element valueElement = (Element)valueList.item(y);
    		NodeList textFNList = valueElement.getChildNodes();
    		String text = ((Node)textFNList.item(0)).getNodeValue();
    		
    		if(!text.equals(" ") && text.startsWith("http:")){
    		    if(hp.containsKey(HashID)){
    			InternalLink il = (InternalLink)hp.get(HashID);
    			il.increaseElement(text);
    			hp.put(HashID,il);
    		    }
    		    else{
    		    InternalLink il = new InternalLink();
    			il.setValue(HashID);
    			il.increaseElement(text);
    			hp.put(HashID, il);
    		    }
    		}
    	    }
        	}               
        	return hp;
        }

    
    public String[] getDocumentIDList(String core_element){
    	
    	Element ex = getRootNode(core_element);
    	NodeList listOfFrequency = ex.getElementsByTagName("Document");
    	String[] ids = new String[listOfFrequency.getLength()];
    	
	for(int s=0; s<listOfFrequency.getLength() ; s++){
	    Node docNode = listOfFrequency.item(s);
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    ids[s] = att_name;
    	}
    	return (String[])ids.clone();
    }

}