/*
 * Copyright (c) 1997, 2005, 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.
     */
    private Map type_hash = new HashMap();

    /**
     * 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.
     */
    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.
     *
     * @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.
     *
     * @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.
     */
    public MailcapFile() {
        if (LogSupport.isLoggable())
            LogSupport.log("new MailcapFile: default");
    }

    /**
     * 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.
     *
     * <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.
     */
    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.
     */
    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.
     */
    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 == "# <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
     */
    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.
     */
    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("");
        }
    }
    */
}