/*
 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.activation.registries;

import java.io.*;
import java.util.*;

public class MailcapFile {

    
A Map indexed by MIME type (string) that references
a Map of commands for each type.  The comand Map
is indexed by the command name and references a List of
class names (strings) for each command.
/**
     * A Map indexed by MIME type (string) that references
     * a Map of commands for each type.  The comand Map
     * is indexed by the command name and references a List of
     * class names (strings) for each command.
     */
    private Map type_hash = new HashMap();

    
Another Map like above, but for fallback entries.
/**
     * Another Map like above, but for fallback entries.
     */
    private Map fallback_hash = new HashMap();

    
A Map indexed by MIME type (string) that references
a List of native commands (string) corresponding to the type.
/**
     * A Map indexed by MIME type (string) that references
     * a List of native commands (string) corresponding to the type.
     */
    private Map native_commands = new HashMap();

    private static boolean addReverse = false;

    static {
        try {
            addReverse = Boolean.getBoolean("javax.activation.addreverse");
        } catch (Throwable t) {
            // ignore any errors
        }
    }

    
The constructor that takes a filename as an argument.
Params:
new_fname – The file name of the mailcap file./**
     * The constructor that takes a filename as an argument.
     *
     * @param new_fname The file name of the mailcap file.
     */
    public MailcapFile(String new_fname) throws IOException {
        if (LogSupport.isLoggable())
            LogSupport.log("new MailcapFile: file " + new_fname);
        FileReader reader = null;
        try {
            reader = new FileReader(new_fname);
            parse(new BufferedReader(reader));
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException ex) { }
            }
        }
    }

    
The constructor that takes an input stream as an argument.
Params:
is –        the input stream/**
     * The constructor that takes an input stream as an argument.
     *
     * @param is        the input stream
     */
    public MailcapFile(InputStream is) throws IOException {
        if (LogSupport.isLoggable())
            LogSupport.log("new MailcapFile: InputStream");
        parse(new BufferedReader(new InputStreamReader(is, "iso-8859-1")));
    }

    
Mailcap file default constructor.
/**
     * Mailcap file default constructor.
     */
    public MailcapFile() {
        if (LogSupport.isLoggable())
            LogSupport.log("new MailcapFile: default");
    }

    
Get the Map of MailcapEntries based on the MIME type.

Semantics: First check for the literal mime type,
if that fails looks for wildcard /\* and return that. Return the
list of all that hit.
/**
     * Get the Map of MailcapEntries based on the MIME type.
     *
     * <p>
     * <strong>Semantics:</strong> First check for the literal mime type,
     * if that fails looks for wildcard <type>/\* and return that. Return the
     * list of all that hit.
     */
    public Map getMailcapList(String mime_type) {
        Map search_result = null;
        Map wildcard_result = null;

        // first try the literal
        search_result = (Map)type_hash.get(mime_type);

        // ok, now try the wildcard
        int separator = mime_type.indexOf('/');
        String subtype = mime_type.substring(separator + 1);
        if (!subtype.equals("*")) {
            String type = mime_type.substring(0, separator + 1) + "*";
            wildcard_result = (Map)type_hash.get(type);

            if (wildcard_result != null) { // damn, we have to merge!!!
                if (search_result != null)
                    search_result =
                        mergeResults(search_result, wildcard_result);
                else
                    search_result = wildcard_result;
            }
        }
        return search_result;
    }

    
Get the Map of fallback MailcapEntries based on the MIME type.

Semantics: First check for the literal mime type,
if that fails looks for wildcard /\* and return that. Return the
list of all that hit.
/**
     * Get the Map of fallback MailcapEntries based on the MIME type.
     *
     * <p>
     * <strong>Semantics:</strong> First check for the literal mime type,
     * if that fails looks for wildcard <type>/\* and return that. Return the
     * list of all that hit.
     */
    public Map getMailcapFallbackList(String mime_type) {
        Map search_result = null;
        Map wildcard_result = null;

        // first try the literal
        search_result = (Map)fallback_hash.get(mime_type);

        // ok, now try the wildcard
        int separator = mime_type.indexOf('/');
        String subtype = mime_type.substring(separator + 1);
        if (!subtype.equals("*")) {
            String type = mime_type.substring(0, separator + 1) + "*";
            wildcard_result = (Map)fallback_hash.get(type);

            if (wildcard_result != null) { // damn, we have to merge!!!
                if (search_result != null)
                    search_result =
                        mergeResults(search_result, wildcard_result);
                else
                    search_result = wildcard_result;
            }
        }
        return search_result;
    }

    
Return all the MIME types known to this mailcap file.
/**
     * Return all the MIME types known to this mailcap file.
     */
    public String[] getMimeTypes() {
        Set types = new HashSet(type_hash.keySet());
        types.addAll(fallback_hash.keySet());
        types.addAll(native_commands.keySet());
        String[] mts = new String[types.size()];
        mts = (String[])types.toArray(mts);
        return mts;
    }

    
Return all the native comands for the given MIME type.
/**
     * Return all the native comands for the given MIME type.
     */
    public String[] getNativeCommands(String mime_type) {
        String[] cmds = null;
        List v =
            (List)native_commands.get(mime_type.toLowerCase(Locale.ENGLISH));
        if (v != null) {
            cmds = new String[v.size()];
            cmds = (String[])v.toArray(cmds);
        }
        return cmds;
    }

    
Merge the first hash into the second.
This merge will only effect the hashtable that is
returned, we don't want to touch the one passed in since
its integrity must be maintained.
/**
     * Merge the first hash into the second.
     * This merge will only effect the hashtable that is
     * returned, we don't want to touch the one passed in since
     * its integrity must be maintained.
     */
    private Map mergeResults(Map first, Map second) {
        Iterator verb_enum = second.keySet().iterator();
        Map clonedHash = new HashMap(first);

        // iterate through the verbs in the second map
        while (verb_enum.hasNext()) {
            String verb = (String)verb_enum.next();
            List cmdVector = (List)clonedHash.get(verb);
            if (cmdVector == null) {
                clonedHash.put(verb, second.get(verb));
            } else {
                // merge the two
                List oldV = (List)second.get(verb);
                cmdVector = new ArrayList(cmdVector);
                cmdVector.addAll(oldV);
                clonedHash.put(verb, cmdVector);
            }
        }
        return clonedHash;
    }

    
appendToMailcap: Append to this Mailcap DB, use the mailcap
format:
Comment == "# comment string
Entry == "mimetype;        javabeanclass
Example:
# this is a comment
image/gif       jaf.viewers.ImageViewer
/**
     * appendToMailcap: Append to this Mailcap DB, use the mailcap
     * format:
     * Comment == "# <i>comment string</i>
     * Entry == "mimetype;        javabeanclass<nl>
     *
     * Example:
     * # this is a comment
     * image/gif       jaf.viewers.ImageViewer
     */
    public void appendToMailcap(String mail_cap) {
        if (LogSupport.isLoggable())
            LogSupport.log("appendToMailcap: " + mail_cap);
        try {
            parse(new StringReader(mail_cap));
        } catch (IOException ex) {
            // can't happen
        }
    }

    
parse file into a hash table of MC Type Entry Obj
/**
     * parse file into a hash table of MC Type Entry Obj
     */
    private void parse(Reader reader) throws IOException {
        BufferedReader buf_reader = new BufferedReader(reader);
        String line = null;
        String continued = null;

        while ((line = buf_reader.readLine()) != null) {
            //    LogSupport.log("parsing line: " + line);

            line = line.trim();

            try {
                if (line.charAt(0) == '#')
                    continue;
                if (line.charAt(line.length() - 1) == '\\') {
                    if (continued != null)
                        continued += line.substring(0, line.length() - 1);
                    else
                        continued = line.substring(0, line.length() - 1);
                } else if (continued != null) {
                    // handle the two strings
                    continued = continued + line;
                    //  LogSupport.log("parse: " + continued);
                    try {
                        parseLine(continued);
                    } catch (MailcapParseException e) {
                        //e.printStackTrace();
                    }
                    continued = null;
                }
                else {
                    //  LogSupport.log("parse: " + line);
                    try {
                        parseLine(line);
                        // LogSupport.log("hash.size = " + type_hash.size());
                    } catch (MailcapParseException e) {
                        //e.printStackTrace();
                    }
                }
            } catch (StringIndexOutOfBoundsException e) {}
        }
    }

    
 A routine to parse individual entries in a Mailcap file.
 Note that this routine does not handle line continuations.
 They should have been handled prior to calling this routine.
/**
     *  A routine to parse individual entries in a Mailcap file.
     *
     *  Note that this routine does not handle line continuations.
     *  They should have been handled prior to calling this routine.
     */
    protected void parseLine(String mailcapEntry)
                                throws MailcapParseException, IOException {
        MailcapTokenizer tokenizer = new MailcapTokenizer(mailcapEntry);
        tokenizer.setIsAutoquoting(false);

        if (LogSupport.isLoggable())
            LogSupport.log("parse: " + mailcapEntry);
        //      parse the primary type
        int currentToken = tokenizer.nextToken();
        if (currentToken != MailcapTokenizer.STRING_TOKEN) {
            reportParseError(MailcapTokenizer.STRING_TOKEN, currentToken,
                                        tokenizer.getCurrentTokenValue());
        }
        String primaryType =
            tokenizer.getCurrentTokenValue().toLowerCase(Locale.ENGLISH);
        String subType = "*";

        //      parse the '/' between primary and sub
        //      if it's not present that's ok, we just don't have a subtype
        currentToken = tokenizer.nextToken();
        if ((currentToken != MailcapTokenizer.SLASH_TOKEN) &&
                        (currentToken != MailcapTokenizer.SEMICOLON_TOKEN)) {
            reportParseError(MailcapTokenizer.SLASH_TOKEN,
                                MailcapTokenizer.SEMICOLON_TOKEN, currentToken,
                                tokenizer.getCurrentTokenValue());
        }

        //      only need to look for a sub type if we got a '/'
        if (currentToken == MailcapTokenizer.SLASH_TOKEN) {
            //  parse the sub type
            currentToken = tokenizer.nextToken();
            if (currentToken != MailcapTokenizer.STRING_TOKEN) {
                reportParseError(MailcapTokenizer.STRING_TOKEN,
                            currentToken, tokenizer.getCurrentTokenValue());
            }
            subType =
                tokenizer.getCurrentTokenValue().toLowerCase(Locale.ENGLISH);

            //  get the next token to simplify the next step
            currentToken = tokenizer.nextToken();
        }

        String mimeType = primaryType + "/" + subType;

        if (LogSupport.isLoggable())
            LogSupport.log("  Type: " + mimeType);

        //      now setup the commands hashtable
        Map commands = new LinkedHashMap();     // keep commands in order found

        //      parse the ';' that separates the type from the parameters
        if (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) {
            reportParseError(MailcapTokenizer.SEMICOLON_TOKEN,
                            currentToken, tokenizer.getCurrentTokenValue());
        }
        //      eat it

        //      parse the required view command
        tokenizer.setIsAutoquoting(true);
        currentToken = tokenizer.nextToken();
        tokenizer.setIsAutoquoting(false);
        if ((currentToken != MailcapTokenizer.STRING_TOKEN) &&
                    (currentToken != MailcapTokenizer.SEMICOLON_TOKEN)) {
            reportParseError(MailcapTokenizer.STRING_TOKEN,
                            MailcapTokenizer.SEMICOLON_TOKEN, currentToken,
                            tokenizer.getCurrentTokenValue());
        }

        if (currentToken == MailcapTokenizer.STRING_TOKEN) {
            // have a native comand, save the entire mailcap entry
            //String nativeCommand = tokenizer.getCurrentTokenValue();
            List v = (List)native_commands.get(mimeType);
            if (v == null) {
                v = new ArrayList();
                v.add(mailcapEntry);
                native_commands.put(mimeType, v);
            } else {
                // XXX - check for duplicates?
                v.add(mailcapEntry);
            }
        }

        //      only have to get the next token if the current one isn't a ';'
        if (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) {
            currentToken = tokenizer.nextToken();
        }

        // look for a ';' which will indicate whether
        // a parameter list is present or not
        if (currentToken == MailcapTokenizer.SEMICOLON_TOKEN) {
            boolean isFallback = false;
            do {
                //      eat the ';'

                //      parse the parameter name
                currentToken = tokenizer.nextToken();
                if (currentToken != MailcapTokenizer.STRING_TOKEN) {
                    reportParseError(MailcapTokenizer.STRING_TOKEN,
                            currentToken, tokenizer.getCurrentTokenValue());
                }
                String paramName = tokenizer.getCurrentTokenValue().
                                                toLowerCase(Locale.ENGLISH);

                //      parse the '=' which separates the name from the value
                currentToken = tokenizer.nextToken();
                if ((currentToken != MailcapTokenizer.EQUALS_TOKEN) &&
                    (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) &&
                    (currentToken != MailcapTokenizer.EOI_TOKEN)) {
                    reportParseError(MailcapTokenizer.EQUALS_TOKEN,
                            MailcapTokenizer.SEMICOLON_TOKEN,
                            MailcapTokenizer.EOI_TOKEN,
                            currentToken, tokenizer.getCurrentTokenValue());
                }

                //      we only have a useful command if it is named
                if (currentToken == MailcapTokenizer.EQUALS_TOKEN) {
                    //  eat it

                    //  parse the parameter value (which is autoquoted)
                    tokenizer.setIsAutoquoting(true);
                    currentToken = tokenizer.nextToken();
                    tokenizer.setIsAutoquoting(false);
                    if (currentToken != MailcapTokenizer.STRING_TOKEN) {
                        reportParseError(MailcapTokenizer.STRING_TOKEN,
                        currentToken, tokenizer.getCurrentTokenValue());
                    }
                    String paramValue =
                                tokenizer.getCurrentTokenValue();

                    // add the class to the list iff it is one we care about
                    if (paramName.startsWith("x-java-")) {
                        String commandName = paramName.substring(7);
                        //      7 == "x-java-".length

                        if (commandName.equals("fallback-entry") &&
                            paramValue.equalsIgnoreCase("true")) {
                            isFallback = true;
                        } else {

                            //  setup the class entry list
                            if (LogSupport.isLoggable())
                                LogSupport.log("    Command: " + commandName +
                                                    ", Class: " + paramValue);
                            List classes = (List)commands.get(commandName);
                            if (classes == null) {
                                classes = new ArrayList();
                                commands.put(commandName, classes);
                            }
                            if (addReverse)
                                classes.add(0, paramValue);
                            else
                                classes.add(paramValue);
                        }
                    }

                    //  set up the next iteration
                    currentToken = tokenizer.nextToken();
                }
            } while (currentToken == MailcapTokenizer.SEMICOLON_TOKEN);

            Map masterHash = isFallback ? fallback_hash : type_hash;
            Map curcommands =
                (Map)masterHash.get(mimeType);
            if (curcommands == null) {
                masterHash.put(mimeType, commands);
            } else {
                if (LogSupport.isLoggable())
                    LogSupport.log("Merging commands for type " + mimeType);
                // have to merge current and new commands
                // first, merge list of classes for commands already known
                Iterator cn = curcommands.keySet().iterator();
                while (cn.hasNext()) {
                    String cmdName = (String)cn.next();
                    List ccv = (List)curcommands.get(cmdName);
                    List cv = (List)commands.get(cmdName);
                    if (cv == null)
                        continue;
                    // add everything in cv to ccv, if it's not already there
                    Iterator cvn = cv.iterator();
                    while (cvn.hasNext()) {
                        String clazz = (String)cvn.next();
                        if (!ccv.contains(clazz))
                            if (addReverse)
                                ccv.add(0, clazz);
                            else
                                ccv.add(clazz);
                    }
                }
                // now, add commands not previously known
                cn = commands.keySet().iterator();
                while (cn.hasNext()) {
                    String cmdName = (String)cn.next();
                    if (curcommands.containsKey(cmdName))
                        continue;
                    List cv = (List)commands.get(cmdName);
                    curcommands.put(cmdName, cv);
                }
            }
        } else if (currentToken != MailcapTokenizer.EOI_TOKEN) {
            reportParseError(MailcapTokenizer.EOI_TOKEN,
                MailcapTokenizer.SEMICOLON_TOKEN,
                currentToken, tokenizer.getCurrentTokenValue());
        }
     }

     protected static void reportParseError(int expectedToken, int actualToken,
                String actualTokenValue) throws MailcapParseException {
        throw new MailcapParseException("Encountered a " +
                MailcapTokenizer.nameForToken(actualToken) + " token (" +
                actualTokenValue + ") while expecting a " +
                MailcapTokenizer.nameForToken(expectedToken) + " token.");
     }

     protected static void reportParseError(int expectedToken,
        int otherExpectedToken, int actualToken, String actualTokenValue)
                                        throws MailcapParseException {
        throw new MailcapParseException("Encountered a " +
                MailcapTokenizer.nameForToken(actualToken) + " token (" +
                actualTokenValue + ") while expecting a " +
                MailcapTokenizer.nameForToken(expectedToken) + " or a " +
                MailcapTokenizer.nameForToken(otherExpectedToken) + " token.");
     }

     protected static void reportParseError(int expectedToken,
            int otherExpectedToken, int anotherExpectedToken, int actualToken,
            String actualTokenValue) throws MailcapParseException {
        if (LogSupport.isLoggable())
            LogSupport.log("PARSE ERROR: " + "Encountered a " +
                MailcapTokenizer.nameForToken(actualToken) + " token (" +
                actualTokenValue + ") while expecting a " +
                MailcapTokenizer.nameForToken(expectedToken) + ", a " +
                MailcapTokenizer.nameForToken(otherExpectedToken) + ", or a " +
                MailcapTokenizer.nameForToken(anotherExpectedToken) + " token.");
        throw new MailcapParseException("Encountered a " +
                MailcapTokenizer.nameForToken(actualToken) + " token (" +
                actualTokenValue + ") while expecting a " +
                MailcapTokenizer.nameForToken(expectedToken) + ", a " +
                MailcapTokenizer.nameForToken(otherExpectedToken) + ", or a " +
                MailcapTokenizer.nameForToken(anotherExpectedToken) + " token.");
     }

     /** for debugging
     public static void main(String[] args) throws Exception {
        Map masterHash = new HashMap();
        for (int i = 0; i < args.length; ++i) {
            System.out.println("Entry " + i + ": " + args[i]);
            parseLine(args[i], masterHash);
        }

        Enumeration types = masterHash.keys();
        while (types.hasMoreElements()) {
            String key = (String)types.nextElement();
            System.out.println("MIME Type: " + key);

            Map commandHash = (Map)masterHash.get(key);
            Enumeration commands = commandHash.keys();
            while (commands.hasMoreElements()) {
                String command = (String)commands.nextElement();
                System.out.println("    Command: " + command);

                Vector classes = (Vector)commandHash.get(command);
                for (int i = 0; i < classes.size(); ++i) {
                        System.out.println("        Class: " +
                                            (String)classes.elementAt(i));
                }
            }

            System.out.println("");
        }
    }
    */
}