source: documentation/trunk/shared/Dictionary.java@ 27035

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;
    protected String gsdl_or_gsdl3src_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);
    }
    
    // Creating var gsdl_or_gsdl3src_home to point to GSDLHOME for GS2 and GSDL3SRCHOME for GS3
    // since in GS3, gli is located in GSDL3SRCHOME, not in GSDLHOME (gs2build) 
    String gsdl3_src_home = System.getProperty("GSDL3SRCHOME");
    if(gsdl3_src_home == null || gsdl3_src_home.equals("")) { // both tests important
        gsdl_or_gsdl3src_home = gsdl_home; // for GS2, all subfolders including gli are located in GSDLHOME
    } else {
        gsdl_or_gsdl3src_home = gsdl3_src_home;
    }

    this.classloader = new MyClassLoader(this.getClass().getClassLoader());
    }
    
    public String get(String key) {
    return get(key, null);
    }
    public String get(String key, String args) {
    
    boolean isGS3 = false;
    String gsdl3_src_home = System.getProperty("GSDL3SRCHOME");
    if(gsdl3_src_home != null && !gsdl3_src_home.equals("")) {
        File gs3_installation = new File (gsdl3_src_home);
        if(gs3_installation.exists()) {
            isGS3 = true;
        }
    }
    
    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("perlmodules")) {
        loadDictionary(PERLMODULES);
        return getDictionaryText(perldict, key_name, args);
    }
    if(!isGS3) {
        if (package_name.equals("coredm")) {
            loadDictionary(COREDM);
            return getMacroText(core_macros, key_name);
        }
        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;
    }
    if(isGS3 && (package_name.equals("coredm") || package_name.equals("auxdm"))) {
        //System.err.println("(package "+package_name+" does not exist for GS3)");
    } else {
        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_or_gsdl3src_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_or_gsdl3src_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(""));

    }
}