/*

 * 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.

 */

/*

 * @(#)ParameterList.java     1.10 03/02/12

 */

package com.sun.xml.internal.messaging.saaj.packaging.mime.internet;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

/**

 * This class holds MIME parameters (attribute-value pairs).

 *

 * @version 1.10, 03/02/12

 * @author  John Mani

 */

public final class ParameterList {

    private final HashMap list;

    /**

     * No-arg Constructor.

     */

    public ParameterList() {

        this.list = new HashMap();

    }

    private ParameterList(HashMap m) {

        this.list = m;

    }

    /**

     * Constructor that takes a parameter-list string. The String

     * is parsed and the parameters are collected and stored internally.

     * A ParseException is thrown if the parse fails.

     * Note that an empty parameter-list string is valid and will be

     * parsed into an empty ParameterList.

     *

     * @param   s       the parameter-list string.

     * @exception       ParseException if the parse fails.

     */

    public ParameterList(String s) throws ParseException {

        HeaderTokenizer h = new HeaderTokenizer(s, HeaderTokenizer.MIME);

        HeaderTokenizer.Token tk;

        int type;

        String name;

        list = new HashMap();

        while (true) {

            tk = h.next();

            type = tk.getType();

            if (type == HeaderTokenizer.Token.EOF) // done

                return;

            if ((char)type == ';') {

                // expect parameter name

                tk = h.next();

                // tolerate trailing semicolon, even though it violates the spec

                if (tk.getType() == HeaderTokenizer.Token.EOF)

                    return;

                // parameter name must be a MIME Atom

                if (tk.getType() != HeaderTokenizer.Token.ATOM)

                    throw new ParseException();

                name = tk.getValue().toLowerCase();

                // expect '='

                tk = h.next();

                if ((char)tk.getType() != '=')

                    throw new ParseException();

                // expect parameter value

                tk = h.next();

                type = tk.getType();

                // parameter value must be a MIME Atom or Quoted String

                if (type != HeaderTokenizer.Token.ATOM &&

                    type != HeaderTokenizer.Token.QUOTEDSTRING)

                    throw new ParseException();

                list.put(name, tk.getValue());

            } else

                throw new ParseException();

        }

    }

    /**

     * Return the number of parameters in this list.

     *

     * @return  number of parameters.

     */

    public int size() {

        return list.size();

    }

    /**

     * Returns the value of the specified parameter. Note that

     * parameter names are case-insensitive.

     *

     * @param name      parameter name.

     * @return          Value of the parameter. Returns

     *                  <code>null</code> if the parameter is not

     *                  present.

     */

    public String get(String name) {

        return (String)list.get(name.trim().toLowerCase());

    }

    /**

     * Set a parameter. If this parameter already exists, it is

     * replaced by this new value.

     *

     * @param   name    name of the parameter.

     * @param   value   value of the parameter.

     */

    public void set(String name, String value) {

        list.put(name.trim().toLowerCase(), value);

    }

    /**

     * Removes the specified parameter from this ParameterList.

     * This method does nothing if the parameter is not present.

     *

     * @param   name    name of the parameter.

     */

    public void remove(String name) {

        list.remove(name.trim().toLowerCase());

    }

    /**

     * Return an enumeration of the names of all parameters in this

     * list.

     *

     * @return Enumeration of all parameter names in this list.

     */

    public Iterator getNames() {

        return list.keySet().iterator();

    }

    /**

     * Convert this ParameterList into a MIME String. If this is

     * an empty list, an empty string is returned.

     *

     * @return          String

     */

    public String toString() {

        return toString(0);

    }

    /**

     * Convert this ParameterList into a MIME String. If this is

     * an empty list, an empty string is returned.

     *

     * The 'used' parameter specifies the number of character positions

     * already taken up in the field into which the resulting parameter

     * list is to be inserted. It's used to determine where to fold the

     * resulting parameter list.

     *

     * @param used      number of character positions already used, in

     *                  the field into which the parameter list is to

     *                  be inserted.

     * @return          String

     */

    public String toString(int used) {

        StringBuffer sb = new StringBuffer();

        Iterator itr = list.entrySet().iterator();

        while (itr.hasNext()) {

            Map.Entry e = (Map.Entry)itr.next();

            String name = (String)e.getKey();

            String value = quote((String)e.getValue());

            sb.append("; ");

            used += 2;

            int len = name.length() + value.length() + 1;

            if (used + len > 76) { // overflows ...

                sb.append("\r\n\t"); // .. start new continuation line

                used = 8; // account for the starting <tab> char

            }

            sb.append(name).append('=');

            used += name.length() + 1;

            if (used + value.length() > 76) { // still overflows ...

                // have to fold value

                String s = MimeUtility.fold(used, value);

                sb.append(s);

                int lastlf = s.lastIndexOf('\n');

                if (lastlf >= 0)        // always true

                    used += s.length() - lastlf - 1;

                else

                    used += s.length();

            } else {

                sb.append(value);

                used += value.length();

            }

        }

        return sb.toString();

    }

    // Quote a parameter value token if required.

    private String quote(String value) {

        return MimeUtility.quote(value, HeaderTokenizer.MIME);

    }

    public ParameterList copy() {

        return new ParameterList((HashMap)list.clone());

    }

}