import java.util.ResourceBundle;
import java.util.Locale;
import java.util.HashMap;
import java.net.URL;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.Reader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.BufferedReader;
//import org.apache.xerces.parsers.DOMParser;
import org.xml.sax.InputSource;
//import org.xml.sax.XMLReader;
//import org.xml.sax.XMLReaderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class Dictionary {

    private ResourceBundle glidict = null;
    private ResourceBundle perldict = null;
    private MacroFile core_macros = null;
    private MacroFile aux_macros = null;
    private HashMap metadata = null;
    private Locale locale = null;
    private String lang = null;
    static final private int GLIDICT = 0;
    static final private int GLIHELP = 1;
    static final private int COREDM = 2;
    static final private int AUXDM = 3;
    static final private int TUTORIALS = 4;
    static final private int PERLMODULES = 5;
    static final private int METADATA = 6;

    protected String gsdl_home = null;
    
    private ClassLoader classloader = null;


    public Dictionary(String lang) {
	this.lang = lang;
	this.locale = new Locale(lang);
	if (this.locale==null) {
	    this.locale = Locale.getDefault();
	}
	gsdl_home = System.getProperty("GSDLHOME");
	if (gsdl_home == null) {
	    System.err.println("Error: GSDLHOME is null!!");
	    System.exit(1);
	}

	this.classloader = new MyClassLoader(this.getClass().getClassLoader());
    }
    
    public String get(String key) {
	return get(key, null);
    }
    public String get(String key, String args) {
	int pos = key.indexOf("::");
	if (pos==-1) {
	    System.err.println("invalid key: "+key);
	    return "";
	}
	String package_name = key.substring(0, pos);
	String key_name = key.substring(pos+2);
	//System.err.println("pack = "+package_name+", key="+key_name);

	if (package_name.equals("glidict")) {
	    loadDictionary(GLIDICT);
	    return getDictionaryText(glidict, key_name, args);
	}
	if (package_name.equals("coredm")) {
	    loadDictionary(COREDM);
	    return getMacroText(core_macros, key_name);
	}
	if (package_name.equals("perlmodules")) {
	    loadDictionary(PERLMODULES);
	    return getDictionaryText(perldict, key_name, args);
	}
	if (package_name.equals("auxdm")) {
	    loadDictionary(AUXDM);
	    return getMacroText(aux_macros, key_name);
	}
	if (package_name.equals("glihelp")) {
	    return "";
	}
	if (package_name.equals("tutorials")) {
	    return "";
	}
	if (package_name.equals("metadata")) {
	    pos = key_name.indexOf(".");
	    String namespace = key_name.substring(0,pos);
	    String element = key_name.substring(pos+1);
	    if (loadMetadata(namespace)) {
		return getMetadataName(namespace, element);
	    }
	    return key_name;
	}
	System.err.println("invalid package name "+package_name);
	return "";
    }

    public String getDictionaryText(ResourceBundle dictionary, String key, String args) {

	try {
	    String initial_raw = dictionary.getString(key);
	    // convert to unicode, copied from gatherer dictionary
	    String initial = new String(initial_raw.getBytes("ISO-8859-1"), "UTF-8");
	    if (args == null || args.equals("")) {
		return initial;
	    }
	    String [] args_array = args.split(";");
	    // If the string contains arguments we have to insert them.
	    String complete = "";
	    // While we still have initial string left.
	    while(initial.length() > 0 && initial.indexOf('{') != -1 && initial.indexOf('}') != -1) {
		// Remove preamble
		int opening = initial.indexOf('{');
		int closing = initial.indexOf('}');
		complete = complete + initial.substring(0, opening);
		// Parse arg_num
		String arg_str = initial.substring(opening + 1, closing);
		int arg_num = Integer.parseInt(arg_str);
		if(closing + 1 < initial.length()) {
		    initial = initial.substring(closing + 1);
		}
		else {
		    initial = "";
		}
		// Insert argument
		if(0 <= arg_num && arg_num < args_array.length) {
		    complete = complete + args_array[arg_num];
		}
	    }
	    return complete + initial;

	    //this.raw = ResourceBundle.getBundle(this.resource, this.locale);
	} catch (Exception e) {
	    //System.err.println("Dictionary: couldn't locate a resource bundle for "+resource);
	}
	System.err.println("no value found for key "+key+" in dictionary "+dictionary.toString());
	return "";
    }

    private String getMacroText(MacroFile macros, String key) {
	return macros.get(key);
    }
    
    private String getMetadataName(String namespace, String element_name) {
	Element meta_set = (Element)metadata.get(namespace);
	String default_value = namespace+"."+element_name;
	if (meta_set == null) {
	    return default_value;
	}
	Element this_elem = getNamedChild(meta_set, "Element", "name", element_name);
	if (this_elem == null) {
	    return default_value;
	}
	Element this_lang = getNamedChild(this_elem, "Language", "code", this.lang);
	if (this_lang == null) {
	    this_lang = this_elem; // sometimes have attributes as children of element
	}
	
	// need to modify this if we get multiple languages at the same level
	Element label_att = getNamedChild(this_lang, "Attribute", "name", "label");
	if (label_att == null) {
	    return default_value;
	}
	return namespace+"."+getTextValue(label_att);
    }
    
    private Element getNamedChild(Element parent, String child_element, String att_name, String att_value) {
	NodeList elements = parent.getElementsByTagName(child_element);
	for (int i=0; i<elements.getLength(); i++) {
	    Element e = (Element)elements.item(i);
	    if (e.getAttribute(att_name).equals(att_value)) {
		return e;
	    }
	}
	return null;
    }
    
    private String getTextValue(Element elem) {
	elem.normalize();
	Node n = elem.getFirstChild();
        while (n!=null && n.getNodeType() !=Node.TEXT_NODE) {
            n=n.getNextSibling();
        }
	return n.getNodeValue();
    }

		
    
    private boolean loadDictionary(int type) {
	switch (type) {
	case GLIDICT:
	    if (this.glidict == null) {
		glidict = ResourceBundle.getBundle("dictionary", this.locale, this.classloader);
		
	    }
	    break;
	case PERLMODULES:
	    if (this.perldict == null) {
		perldict = ResourceBundle.getBundle("strings", this.locale, this.classloader);
	    }
	    break;
	    
	case COREDM:
	    if (this.core_macros == null) {
		core_macros = new MacroFile(MacroFile.CORE);
	    }
	    break;
	    
	case AUXDM:
	    if (this.aux_macros == null) {
		aux_macros = new MacroFile(MacroFile.AUX);
	    }
	    break;
	}
	return true;
    }
    
    private boolean loadMetadata(String namespace) {
	if (metadata == null) {
	    metadata = new HashMap();
	}

	if (metadata.containsKey(namespace)) {
	    // already loaded
	    return true;
	}
	// find the metadata file
	String file_name = namespace+".mds";
	if (namespace.equals("dc")) {
	    // what about qualified???
	    file_name = "dublin.mds";
	}
	
	file_name = gsdl_home + File.separator + "gli" + File.separator + "metadata"+ File.separator + file_name;
	//System.err.println("metadata filename = "+file_name);
	File metadata_file = new File(file_name);
	if (!metadata_file.exists()) {
	    System.err.println("metadata file "+file_name+" does not exist!");
	    return false;
	}
	// parse the file
	Element elem = parseXMLFile(metadata_file);
	if (elem != null) {
	    metadata.put(namespace, elem);
	    return true;
	}
	return false;
    }

    private Element parseXMLFile(File file) {

	try {
	    //DOMParser parser = new DOMParser();
	    //XMLReader parser = XMLReaderFactory.createXMLReader();
	    DocumentBuilder builder =  DocumentBuilderFactory.newInstance().newDocumentBuilder();
	    Document doc = builder.parse(file);
	    //FileReader reader = new FileReader(file);
	    //InputSource xml_source = new InputSource(reader);

            //parser.parse(xml_source);
            return doc.getDocumentElement();
	} catch (Exception e) {
	    System.err.println("XML Parse Error: "+e.getMessage());
	    return null;
	}
	
    }
    private class MyClassLoader 
    extends ClassLoader {

	private String gliclassesdir = null;
	private String perldir = null;

	public MyClassLoader(ClassLoader parent) {

	    super(parent);
	    gliclassesdir = gsdl_home+File.separator+"gli"+File.separator+"classes";
	    perldir = gsdl_home+File.separator+"perllib";
	    
	}

	public URL findResource(String name) {
	    try {
		File resource_path = new File(this.gliclassesdir, name);
		if (resource_path.exists()) {
		    return new URL("file://"+resource_path.getAbsolutePath());
		}
		resource_path = new File(this.perldir, name);
		if (resource_path.exists()) {
		    return new URL("file://"+resource_path.getAbsolutePath());
		}
	    } catch (Exception e) {};
	    
	    
	    return super.findResource(name);
	}


    }

    private class MacroFile {
	public static final int CORE = 0;
	public static final int AUX = 1;
	
	private File macro_file = null;
	private HashMap macros = null;

	public MacroFile(int type) {
	    String filename = gsdl_home+File.separator+"macros"+File.separator;
	    if (lang.equals("en")) {
		filename += "english";
	    } else if (lang.equals("fr")) {
		filename += "french";
	    } else if (lang.equals("es")) {
		filename += "spanish";
	    } else if (lang.equals("ru")) {
		filename += "russian";
	    } else {
		System.err.println("Couldn't work out macro file name for lang "+lang);
		return;
	    }
	    if(type == CORE) {
		filename += ".dm";
	    } else if (type == AUX) {
		filename += "2.dm";
	    } else {
		System.err.println("Unknown Macro file type: "+type+"!");
	    }

	    macro_file = new File(filename);
	    if (!macro_file.exists()) {
		System.err.println("Macro file "+filename+" doesn't exist!");
		return;
	    }
	    macros = new HashMap();
	    loadMacroFile();
	}

	public String get(String key) {
	    if (!key.startsWith("_") || !key.endsWith("_")) {
		System.err.println("Error in macro key "+key);
		return "";
	    }
	    String value = (String)macros.get(key.substring(1, key.length()-1));
	    //System.err.println("proper_key"+key.substring(1, key.length()-1));
	    if (value == null) {
		System.err.println("No value found for key "+key+" in macro file "+macro_file.getName());
		return "";
	    } 
	    return value;
	}
	private boolean loadMacroFile() {
	    String current_package = "";
	    try {
		InputStream istream = new FileInputStream(macro_file);
		Reader in_reader = new InputStreamReader(istream, "UTF-8");
		BufferedReader in = new BufferedReader(in_reader);
		String macro_str = null;
		while((macro_str = in.readLine()) != null) {
		    if (macro_str.startsWith("#")) {
			// a comment
			continue;
		    }
		    if (macro_str.startsWith("package")) {
			macro_str = macro_str.substring(8);
			macro_str = macro_str.trim();
			if (macro_str.indexOf("#")!=-1) {
			    macro_str = macro_str.substring(0, macro_str.indexOf("#"));
			    macro_str = macro_str.trim();
			}
			current_package = macro_str;
			//System.err.println("current package = "+current_package);
			continue;
		    }
		    if (macro_str.startsWith("_")) {
			if (macro_str.indexOf("#")!=-1) {
			    //strip off any comments - hopefully there are no # in the actual text
			    macro_str = macro_str.substring(0, macro_str.indexOf("#"));
			}
			macro_str = macro_str.trim();
			String macro_name = macro_str.substring(1, macro_str.indexOf("_", 1));
			//System.err.println("macro name = "+macro_name);
			// find the {
			int start_bracket = macro_str.indexOf("{");
			int end_bracket = 0;
			String line = null;
			while(!macro_str.endsWith("}") && (line = in.readLine()) != null) {
			    macro_str += line;
			    macro_str = macro_str.trim();
			}
			if (!macro_str.endsWith("}")) {
			    System.err.println("can't find the end of macro "+macro_name+", value="+macro_str);
			    continue;
			}
			String macro_value = macro_str.substring(start_bracket+1, macro_str.length()-1);
			//System.err.println("macro value = "+macro_value);
			//System.err.println("adding key "+current_package+":"+macro_name+", value = "+macro_value);
			macros.put(current_package+":"+macro_name, macro_value);
			continue;
		    }
		} //while
	    } catch (Exception e) {
		System.err.println("Exception when trying to load macro file "+macro_file+":"+e.getMessage());
		return false;
	    }
	    return true;
	}
    }

    public static void main(String []args) {
	if (args.length != 1) {
	    System.err.println("Usage: java Dictionary <iso lang code>");
	    return;
	}
	
	Dictionary dict = new Dictionary(args[0]);
	System.err.println("glidict::General.OK " +dict.get("glidict::General.OK"));
	System.err.println("glidict::Autofilter.Order_Tooltip "+ dict.get("glidict::Autofilter.Order_Tooltip"));

	System.err.println("macros _Global:textdefaulttitle_ "+dict.get("coredm::_Global:textdefaulttitle_"));
	System.err.println("macros _about:textsubcols2_ "+dict.get("coredm::_about:textsubcols2_"));
	System.err.println("macros _home:textdescrcollector_ "+dict.get("auxdm::_home:textdescrcollector_"));
	
	//System.err.println("", dict.get(""));
	//System.err.println("", dict.get(""));

    }
}