package org.greenstone.mat;

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.io.PrintWriter;
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 = new ArrayList();
    
    private int Mode = 0;
    private int TotalDoc = 0; 
    private String path = null;
    
    protected Document doc=null;
    protected MessageRouter mr = null;
    protected XMLConverter converter=null;
    private ArrayList removedID = new ArrayList();

    private final String rootDocument = "archivedir";
    private final String documentTag = "Document";
    private final String frequencyTag ="Frequency";
    private final String valueTag = "ActualValue";
    private final String ASCII_sort = "ASCII";
    private final String urlFile = "dc.Identifier";
    
    private static final int DEF_DIV_SCALE = 10;

    public DataMaker(MetadataStats stats){
    	ms = stats;
    	nameList = stats.metadataNameList;
    	path = stats.StatsDirectory;
    	setTotalDocNumber();
    }
    
    private Element getRootNode(String 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();
	    return rootNode;  
	}catch (Exception e) {
    	    e.printStackTrace();
    	    return null;
	}
    }
    
    public void setTotalDocNumber(){
    	Element ex = getRootNode(rootDocument);
    	NodeList listOfFrequency = ex.getElementsByTagName(documentTag);
    	TotalDoc = listOfFrequency.getLength();
    }
    
    public int getTotalDocNumber(){
    	return TotalDoc;
    }
    
    public int getTotalElementUsed(){
	
	int totalNumber = 0;
	
	for(int i = 0 ; i<nameList.size(); i++){   
	    Element rootElement = getRootNode((String)nameList.get(i));
	    NodeList listOfFrequency = rootElement.getElementsByTagName(frequencyTag);
	    
	    for(int a=0; a<listOfFrequency.getLength() ; a++){
	    	Node FrequencyNode = listOfFrequency.item(a);
	    	NodeList textFNList = FrequencyNode.getChildNodes();
	    	String TextNode = textFNList.item(0).getNodeValue();
	    	totalNumber = totalNumber + Integer.parseInt(TextNode);
	    }
	}
	return totalNumber;
    }
    
    public int getFrequency(String core_element){
	
        int totalNumber = 0;    	
	Element rootElement = getRootNode(core_element);
      	NodeList listOfFrequency = rootElement.getElementsByTagName(frequencyTag);

      	if(listOfFrequency.getLength()==0){
	    return 0;
	}
	
      	for(int a=0; a<listOfFrequency.getLength(); a++){
	    Node FrequencyNode = listOfFrequency.item(a);
	    NodeList textFNList = FrequencyNode.getChildNodes();
	    String TextNode = textFNList.item(0).getNodeValue();
	    int count = Integer.parseInt(TextNode);
	    totalNumber = totalNumber + count;
        }
	return totalNumber;
    }
    
    public int getDistinctNumber(String core_element){
	
        ArrayList alist = new ArrayList();
      	Element rootElement = getRootNode(core_element);
      	NodeList listOfFrequency = rootElement.getElementsByTagName(valueTag);

      	if(listOfFrequency.getLength()==0){
	    return 0;
	}
	
        for(int a=0; a<listOfFrequency.getLength(); a++){
	    Node ActualValueNode = listOfFrequency.item(a);
	    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 rootElement = getRootNode(core_element);
      	NodeList listOfFrequency = rootElement.getElementsByTagName(frequencyTag);
	
      	for(int a=0; a<listOfFrequency.getLength(); a++){
	    totalNumber++;
        }
	return totalNumber;
    }
       
    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 rootElement = getRootNode(core_element);
      	NodeList listOfFrequency = rootElement.getElementsByTagName(frequencyTag);
      	
        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 a=0; a<listOfFrequency.getLength(); a++){
	    FrequencyNode = listOfFrequency.item(a);
	    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 rootElement = getRootNode(core_element);
      	NodeList listOfFrequency = rootElement.getElementsByTagName(frequencyTag);

        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 a=0; a<listOfFrequency.getLength(); a++){
	    FrequencyNode = listOfFrequency.item(a);
	    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 rootElement = getRootNode(core_element);
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);

    	if(listOfDocument.getLength()==0){
	    Mode = 0; 
	    return 0;
	}
	
    	ArrayList alist = new ArrayList();
    	String[] idList = getDocumentIDs(core_element);
    	
	for(int i = 0; i<idList.length; i++){
	    alist.add(idList[i]);
    	}

    	int[] list = new int[TotalDoc];
    	
	for(int i = 0; i<list.length; i++){
	    list[i] = 0;
    	}
	
    	for(int a=0; a<listOfDocument.getLength(); a++){
	    Node docNode = listOfDocument.item(a);
	    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(frequencyTag);
	    int frequency = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = frequency;
    	}
    	
        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 rootElement = getRootNode(core_element);
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);

    	if(listOfDocument.getLength()==0){ 
	    return 100;
	}
	
    	ArrayList alist = new ArrayList();
    	String[] idList = getDocumentIDs(core_element);
    	
	for(int i = 0; i<idList.length; i++){
	    alist.add(idList[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 a=0; a<listOfDocument.getLength(); a++){
	    Node docNode = listOfDocument.item(a);
	    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(frequencyTag);
	    int frequency = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = frequency;
    	}
	
    	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 rootElement = getRootNode(core_element);
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
  
    	ArrayList alist = new ArrayList();
    	String[] idList = getDocumentIDs(core_element);

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

    	int[] list = new int[TotalDoc];

    	for(int i = 0; i<list.length; i++){
    		list[i] = 0;
    	}
    	
    	for(int a=0; a<listOfDocument.getLength(); a++){
	    Node docNode = listOfDocument.item(a);
	    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(frequencyTag);
	    int frequency = Integer.parseInt(xList.item(0).getChildNodes().item(0).getNodeValue());
	    list[location] = frequency;
    	}
    	      	
        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);
	}
    }
    
    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_sort)){
	    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;
    	}	
    }

    
    public HashMap getDistinctValueMap(String core_element){
    	
	Element rootElement = getRootNode(core_element);
    	HashMap hp = new HashMap();
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
    	
	for(int a=0; a<listOfDocument.getLength(); a++){
	    
	    Node docNode = listOfDocument.item(a);
	    Element docElement = (Element)docNode;
	    NodeList valueList = docElement.getElementsByTagName(valueTag);
	    
	    for(int b= 0; b<valueList.getLength(); b++){
		
		Element valueElement = (Element)valueList.item(b);
		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 rootElement = getRootNode(core_element);
    	HashMap hp = new HashMap();
    	NodeList listOfDocument= rootElement.getElementsByTagName(documentTag);
    	
	for(int a=0; a<listOfDocument.getLength(); a++){
	    
	    Node docNode = listOfDocument.item(a);  
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    
	    Element docElement = (Element)docNode;
	    NodeList valueList = docElement.getElementsByTagName(frequencyTag);
	    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 rootElement = getRootNode(rootDocument);
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
    	String[] ids = new String[listOfDocument.getLength()];
    	
	for(int a=0; a<listOfDocument.getLength(); a++){
	    Node docNode = listOfDocument.item(a);
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    ids[a] = att_name;
    	}
    	return (String[])ids.clone();
    }
    
    public int[] getMetadataRows(String core_element){
    	Element rootElement = getRootNode(core_element);
    	ArrayList alist = new ArrayList();
    	String[] idsx = getDocumentIDs(core_element);
	
    	for(int i = 0; i<idsx.length; i++){
    		alist.add(idsx[i]);
    	}

    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
    	int[] row = new int[TotalDoc];
	
    	for(int i = 0; i<row.length; i++){
    		row [i] = 0;
    	}
    	
    	for(int a=0; a<listOfDocument.getLength(); a++){   
    		Node docNode = listOfDocument.item(a);
    		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){
    	//System.out.println(d1);
        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 * ms.getDocNum();
	    
	    for(int i = 0; i<alist.size(); i++){
		String name = (String)alist.get(i);
		totalElementUsed = totalElementUsed + getDocumentUsedElement(name);
	    }
	}
    	//System.out.println(totalElementUsed +" "+ totalElement);
    	double x = (double)totalElementUsed/totalElement;
    	//System.out.println(x);
    	Double d1 = new Double(x);
    	//System.out.println(d1);
    	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 HashMap getLinks(String[] args, String core_element){
		Element rootElement = getRootNode(core_element);
    	HashMap hp = new HashMap();
    	NodeList listOfDocument = rootElement.getElementsByTagName("Document");
    	ArrayList tempList = new ArrayList();

    	
    	for(int i = 0; i<args.length; i++){
    		tempList.add(args[i]);		
    	}
    	
    	for(int s=0; s<listOfDocument.getLength() ; s++){
    		Node docNode = listOfDocument.item(s);
    		Element docElement = (Element)docNode;
    		NodeList valueList = docElement.getElementsByTagName(valueTag);
	    
    		if(valueList.getLength()==1){
    			String id = docNode.getAttributes().item(0).getNodeValue();
    			
    			Element valueElement = (Element)valueList.item(0);
    			NodeList textFNList = valueElement.getChildNodes();
    			String text = ((Node)textFNList.item(0)).getNodeValue();
    			
    			if(tempList.contains(text)){
    				hp.put(id, text);
    			}
       		}	
    	}
    	
    	rootElement = getRootNode(urlFile);
    	listOfDocument = rootElement.getElementsByTagName(documentTag);
    	HashMap newHp = new HashMap();
    	
    	for(int a=0; a<listOfDocument.getLength(); a++){
    		Node docNode = listOfDocument.item(a);
    		Element docElement = (Element)docNode;
    		NodeList valueList = docElement.getElementsByTagName(valueTag);
	    
    		if(valueList.getLength()==1){
    			String id = docNode.getAttributes().item(0).getNodeValue();
    			
    			Element valueElement = (Element)valueList.item(0);
    			NodeList textFNList = valueElement.getChildNodes();
    			String text = ((Node)textFNList.item(0)).getNodeValue();
   				newHp.put(text,id);  			
       		}	
    	}
    	
    	HashMap tempMap = new HashMap();
    	Collection c = hp.values();
    	Iterator i = c.iterator();
    	while(i.hasNext()){
    		String id = (String)i.next();
    		if(newHp.containsKey(id)){
    			String text = (String)newHp.get(id);
    			if(text.indexOf("http")!=-1){
    				tempMap.put((String)tempMap.get(id),text);
    			}
    		}
    	}
    	
    	return tempMap;
	}
	
	
    public ArrayList getURLMap(String elementName){

    	String core_element =elementName;
    	Element rootElement = getRootNode(core_element);
    	ArrayList alist = new ArrayList();

    	if(rootElement.equals(null)){
    		return new ArrayList();
    	}
    		
        NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
        	
        if(listOfDocument.getLength()==0){return new ArrayList();}
        
        //System.out.println(listOfDocument.getLength());
    	for(int a=0; a<listOfDocument.getLength(); a++){
    	    Node docNode = listOfDocument.item(a);
    	    Element docElement = (Element)docNode;
    	    NodeList valueList = docElement.getElementsByTagName(valueTag);
    	    
    	    //System.out.println(valueList.getLength());
    	    for(int b=0; b<valueList.getLength(); b++){
    	    	Element valueElement = (Element)valueList.item(b);
    	    	NodeList textFNList = valueElement.getChildNodes();
    	    	String text = ((Node)textFNList.item(0)).getNodeValue();

    	    	if(!text.equals(" ")){
    	    		 NamedNodeMap NodeIDMap = docNode .getAttributes();
    	    		 Node DocNodeID = NodeIDMap.item(0);
    	    		 String DocID = DocNodeID.getNodeValue();
    	    		if(alist.contains(DocID)){}
    	    		else{
    	    			alist.add(DocID);
    	    		}
    	    	}
    	    }
       }             

        	return alist;
}

    public HashMap getIdentifierLink(String core_element){
    	
    	Element rootElement = getRootNode(core_element);
        HashMap hp = new HashMap();
        NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
        	
    	for(int a=0; a<listOfDocument.getLength(); a++){
    	    Node docNode = listOfDocument.item(a);
    	    String HashID = docNode.getAttributes().item(0).getNodeValue();
    	    Element docElement = (Element)docNode;
    	    NodeList valueList = docElement.getElementsByTagName(valueTag);
    	    
    	    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 rootElement = getRootNode(core_element);
    	NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
    	String[] ids = new String[listOfDocument.getLength()];
    	
	for(int a=0; a<listOfDocument.getLength(); a++){
	    Node docNode = listOfDocument .item(a);
	    NamedNodeMap NodeMap = docNode.getAttributes();
	    Node AttributeNode = NodeMap.item(0);
	    String att_name = AttributeNode.getNodeValue();
	    ids[a] = att_name;
    	}
    	return (String[])ids.clone();
    }
    

    public HashMap getInternalIdentifier(String core_element){
    	
    	Element rootElement = getRootNode(core_element);
        HashMap hp = new HashMap();
        NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
        	
    	for(int a=0; a<listOfDocument.getLength(); a++){
    	    Node docNode = listOfDocument.item(a);
    	    String HashID = docNode.getAttributes().item(0).getNodeValue();

    	    Element docElement = (Element)docNode;
    	    NodeList valueList = docElement.getElementsByTagName(valueTag);
    	    
    	    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 getIdentifierLinkNoIdentifier(){
    	
    	Element rootElement = getRootNode(rootDocument);
        HashMap hp = new HashMap();
        NodeList listOfDocument = rootElement.getElementsByTagName(documentTag);
        String url ="No Source Available";
    	for(int s=0; s<listOfDocument.getLength() ; s++){
    	    Node docNode = listOfDocument.item(s);
    	    String HashID = docNode.getAttributes().item(0).getNodeValue();
    	    InternalLink il = new InternalLink();
			il.increaseElement(HashID);
			hp.put(HashID, il);
        	}               
        	return hp;
        }   
}