/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
* @author Alexander V. Esin, Stepan M. Mishura
* @version $Revision$
*/

package org.apache.harmony.security.x501;

import java.io.IOException;
import java.nio.charset.Charsets;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import javax.security.auth.x500.X500Principal;
import org.apache.harmony.security.Util;
import org.apache.harmony.security.asn1.ASN1Constants;
import org.apache.harmony.security.asn1.ASN1Oid;
import org.apache.harmony.security.asn1.ASN1Sequence;
import org.apache.harmony.security.asn1.ASN1StringType;
import org.apache.harmony.security.asn1.ASN1Type;
import org.apache.harmony.security.asn1.BerInputStream;
import org.apache.harmony.security.asn1.BerOutputStream;
import org.apache.harmony.security.utils.ObjectIdentifier;


/**
 * X.501 AttributeTypeAndValue
 */
public class AttributeTypeAndValue {

    // Country code attribute (name from RFC 1779)
    private static final ObjectIdentifier C;

    // Common name attribute (name from RFC 1779)
    private static final ObjectIdentifier CN;

    // Domain component attribute (name from RFC 2253)
    private static final ObjectIdentifier DC;

    // DN qualifier attribute (name from API spec)
    private static final ObjectIdentifier DNQ;

    private static final ObjectIdentifier DNQUALIFIER;

    // Email Address attribute (name from API spec)
    private static final ObjectIdentifier EMAILADDRESS;

    // Generation attribute (qualifies an individual's name)
    // (name from API spec)
    private static final ObjectIdentifier GENERATION;

    // Given name attribute (name from API spec)
    private static final ObjectIdentifier GIVENNAME;

    // Initials attribute (initials of an individual's name)
    // (name from API spec)
    private static final ObjectIdentifier INITIALS;

    // Name of a locality attribute (name from RFC 1779)
    private static final ObjectIdentifier L;

    // Organization name attribute (name from RFC 1779)
    private static final ObjectIdentifier O;

    // Organizational unit name attribute (name from RFC 1779)
    private static final ObjectIdentifier OU;

    // Serial number attribute (serial number of a device)
    // (name from API spec)
    private static final ObjectIdentifier SERIALNUMBER;

    // Attribute for the full name of a state or province
    // (name from RFC 1779)
    private static final ObjectIdentifier ST;

    // Street attribute (name from RFC 1779)
    private static final ObjectIdentifier STREET;

    // Surname attribute (comes from an individual's parent name)
    // (name from API spec)
    private static final ObjectIdentifier SURNAME;

    // Title attribute (object in an organization)(name from API spec)
    private static final ObjectIdentifier T;

    // User identifier attribute (name from RFC 2253)
    private static final ObjectIdentifier UID;

    //
    // OID's pool
    //

    // pool's capacity
    private static final int CAPACITY;

    // pool's size
    private static final int SIZE;

    // pool: contains all recognizable attribute type keywords
    private static final ObjectIdentifier[][] KNOWN_OIDS;

    // known keywords attribute
    private static final HashMap KNOWN_NAMES = new HashMap(30);

    // known attribute types for RFC1779 (see Table 1)
    private static final HashMap RFC1779_NAMES = new HashMap(10);

    // known attribute types for RFC2253
    // (see 2.3.  Converting AttributeTypeAndValue)
    private static final HashMap RFC2253_NAMES = new HashMap(10);

    // known attribute types for RFC2459 (see API spec.)
    private static final HashMap RFC2459_NAMES = new HashMap(10);

    static {

        // pool initialization
        CAPACITY = 10;
        SIZE = 10;
        KNOWN_OIDS = new ObjectIdentifier[SIZE][CAPACITY];

        // init known attribute type keywords
        C = new ObjectIdentifier(new int[] { 2, 5, 4, 6 }, "C", RFC1779_NAMES);
        CN = new ObjectIdentifier(new int[] { 2, 5, 4, 3 }, "CN", RFC1779_NAMES);

        DC = new ObjectIdentifier(
                new int[] { 0, 9, 2342, 19200300, 100, 1, 25 }, "DC",
                RFC2253_NAMES);
        // DN qualifier aliases
        DNQ = new ObjectIdentifier(new int[] { 2, 5, 4, 46 }, "DNQ",
                RFC2459_NAMES);
        DNQUALIFIER = new ObjectIdentifier(new int[] { 2, 5, 4, 46 },
                "DNQUALIFIER", RFC2459_NAMES);

        EMAILADDRESS = new ObjectIdentifier(new int[] { 1, 2, 840, 113549, 1,
                9, 1 }, "EMAILADDRESS", RFC2459_NAMES);

        GENERATION = new ObjectIdentifier(new int[] { 2, 5, 4, 44 },
                "GENERATION", RFC2459_NAMES);
        GIVENNAME = new ObjectIdentifier(new int[] { 2, 5, 4, 42 },
                "GIVENNAME", RFC2459_NAMES);

        INITIALS = new ObjectIdentifier(new int[] { 2, 5, 4, 43 }, "INITIALS",
                RFC2459_NAMES);

        L = new ObjectIdentifier(new int[] { 2, 5, 4, 7 }, "L", RFC1779_NAMES);

        O = new ObjectIdentifier(new int[] { 2, 5, 4, 10 }, "O", RFC1779_NAMES);
        OU = new ObjectIdentifier(new int[] { 2, 5, 4, 11 }, "OU",
                RFC1779_NAMES);

        SERIALNUMBER = new ObjectIdentifier(new int[] { 2, 5, 4, 5 },
                "SERIALNUMBER", RFC2459_NAMES);
        ST = new ObjectIdentifier(new int[] { 2, 5, 4, 8 }, "ST", RFC1779_NAMES);
        STREET = new ObjectIdentifier(new int[] { 2, 5, 4, 9 }, "STREET",
                RFC1779_NAMES);
        SURNAME = new ObjectIdentifier(new int[] { 2, 5, 4, 4 }, "SURNAME",
                RFC2459_NAMES);

        T = new ObjectIdentifier(new int[] { 2, 5, 4, 12 }, "T", RFC2459_NAMES);

        UID = new ObjectIdentifier(
                new int[] { 0, 9, 2342, 19200300, 100, 1, 1 }, "UID",
                RFC2253_NAMES);

        //
        // RFC1779
        //
        RFC1779_NAMES.put(CN.getName(), CN);
        RFC1779_NAMES.put(L.getName(), L);
        RFC1779_NAMES.put(ST.getName(), ST);
        RFC1779_NAMES.put(O.getName(), O);
        RFC1779_NAMES.put(OU.getName(), OU);
        RFC1779_NAMES.put(C.getName(), C);
        RFC1779_NAMES.put(STREET.getName(), STREET);

        //
        // RFC2253: includes all from RFC1779
        //
        RFC2253_NAMES.putAll(RFC1779_NAMES);

        RFC2253_NAMES.put(DC.getName(), DC);
        RFC2253_NAMES.put(UID.getName(), UID);

        //
        // RFC2459
        //
        RFC2459_NAMES.put(DNQ.getName(), DNQ);
        RFC2459_NAMES.put(DNQUALIFIER.getName(), DNQUALIFIER);
        RFC2459_NAMES.put(EMAILADDRESS.getName(), EMAILADDRESS);
        RFC2459_NAMES.put(GENERATION.getName(), GENERATION);
        RFC2459_NAMES.put(GIVENNAME.getName(), GIVENNAME);
        RFC2459_NAMES.put(INITIALS.getName(), INITIALS);
        RFC2459_NAMES.put(SERIALNUMBER.getName(), SERIALNUMBER);
        RFC2459_NAMES.put(SURNAME.getName(), SURNAME);
        RFC2459_NAMES.put(T.getName(), T);

        //
        // Init KNOWN_OIDS pool
        //

        // add from RFC2253 (includes RFC1779)
        Iterator it = RFC2253_NAMES.values().iterator();
        while (it.hasNext()) {
            addOID((ObjectIdentifier) it.next());
        }

        // add attributes from RFC2459
        it = RFC2459_NAMES.values().iterator();
        while (it.hasNext()) {
            Object o = it.next();

            //don't add DNQUALIFIER because it has the same oid as DNQ
            if (!(o == DNQUALIFIER)) {
                addOID((ObjectIdentifier) o);
            }
        }

        //
        // Init KNOWN_NAMES pool
        //

        KNOWN_NAMES.putAll(RFC2253_NAMES); // RFC2253 includes RFC1779
        KNOWN_NAMES.putAll(RFC2459_NAMES);
    }

    //Attribute type
    private final ObjectIdentifier oid;

    //Attribute value
    private AttributeValue value;

    // for decoder only
    private AttributeTypeAndValue(int[] oid, AttributeValue value)
            throws IOException {

        ObjectIdentifier thisOid = getOID(oid);
        if (thisOid == null) {
            thisOid = new ObjectIdentifier(oid);
        }
        this.oid = thisOid;
        this.value = value;
    }

    /**
     * Creates AttributeTypeAndValue with OID and AttributeValue. Parses OID
     * string representation
     *
     * @param sOid
     *            string representation of OID
     * @param value
     *            attribute value
     * @throws IOException
     *             if OID can not be created from its string representation
     */
    public AttributeTypeAndValue(String sOid, AttributeValue value)
            throws IOException {
        if (sOid.charAt(0) >= '0' && sOid.charAt(0) <= '9') {

            int[] array = org.apache.harmony.security.asn1.ObjectIdentifier
                    .toIntArray(sOid);

            ObjectIdentifier thisOid = getOID(array);
            if (thisOid == null) {
                thisOid = new ObjectIdentifier(array);
            }
            this.oid = thisOid;

        } else {
            this.oid = (ObjectIdentifier) KNOWN_NAMES.get(Util.toUpperCase(sOid));
            if (this.oid == null) {
                throw new IOException("Unrecognizable attribute name: " + sOid);
            }
        }
        this.value = value;
    }

    /**
     * Appends AttributeTypeAndValue string representation
     *
     * @param attrFormat - format of DN
     * @param buf - string buffer to be used
     */
    public void appendName(String attrFormat, StringBuffer buf) {

        boolean hexFormat = false;
        if (X500Principal.RFC1779.equals(attrFormat)) {
            if (RFC1779_NAMES == oid.getGroup()) {
                buf.append(oid.getName());
            } else {
                buf.append(oid.toOIDString());
            }

            buf.append('=');
            if (value.escapedString == value.getHexString()) {
                //FIXME all chars in upper case
                buf.append(Util.toUpperCase(value.getHexString()));
            } else if (value.escapedString.length() != value.rawString.length()) {
                // was escaped
                value.appendQEString(buf);
            } else {
                buf.append(value.escapedString);
            }
        } else {
            Object group = oid.getGroup();
            // RFC2253 includes names from RFC1779
            if (RFC1779_NAMES == group || RFC2253_NAMES == group) {
                buf.append(oid.getName());

                if (X500Principal.CANONICAL.equals(attrFormat)) {
                    // only PrintableString and UTF8String in string format
                    // all others are output in hex format
                    // BEGIN android-changed
                    // no hex for teletex; see bug 2102191
                    int tag = value.getTag();
                    if (!ASN1StringType.UTF8STRING.checkTag(tag)
                            && !ASN1StringType.PRINTABLESTRING.checkTag(tag)
                            && !ASN1StringType.TELETEXSTRING.checkTag(tag)) {
                        hexFormat = true;
                    }
                    // END android-changed
                }

            } else {
                buf.append(oid.toString());
                hexFormat = true;
            }

            buf.append('=');

            if (hexFormat) {
                buf.append(value.getHexString());
            } else {
                if (X500Principal.CANONICAL.equals(attrFormat)) {
                    buf.append(value.makeCanonical());
                } else {
                    buf.append(value.escapedString);
                }
            }
        }
    }

    /**
     * Gets type of the AttributeTypeAndValue
     *
     * @return ObjectIdentifier
     */
    public ObjectIdentifier getType() {
        return oid;
    }

    /**
     * According to RFC 3280 (http://www.ietf.org/rfc/rfc3280.txt)
     * X.501 AttributeTypeAndValue structure is defined as follows:
     *
     *   AttributeTypeAndValue ::= SEQUENCE {
     *      type     AttributeType,
     *      value    AttributeValue }
     *
     *    AttributeType ::= OBJECT IDENTIFIER
     *
     *    AttributeValue ::= ANY DEFINED BY AttributeType
     *    ...
     *    DirectoryString ::= CHOICE {
     *          teletexString           TeletexString (SIZE (1..MAX)),
     *          printableString         PrintableString (SIZE (1..MAX)),
     *          universalString         UniversalString (SIZE (1..MAX)),
     *          utf8String              UTF8String (SIZE (1.. MAX)),
     *          bmpString               BMPString (SIZE (1..MAX)) }
     *
     */

    public static final ASN1Type attributeValue = new ASN1Type(
            ASN1Constants.TAG_PRINTABLESTRING) {

        public boolean checkTag(int tag) {
            return true;
        }

        public Object decode(BerInputStream in) throws IOException {

            // FIXME what about constr???
            String str = null;
            if (DirectoryString.ASN1.checkTag(in.tag)) {
                // has string representation
                str = (String) DirectoryString.ASN1.decode(in);
            } else {
                // gets octets only
                in.readContent();
            }

            byte[] bytesEncoded = new byte[in.getOffset() - in.getTagOffset()];
            System.arraycopy(in.getBuffer(), in.getTagOffset(), bytesEncoded,
                    0, bytesEncoded.length);

            return new AttributeValue(str, bytesEncoded, in.tag);
        }

        public Object getDecodedObject(BerInputStream in) throws IOException {
            // stub to avoid wrong decoder usage
            throw new RuntimeException("AttributeValue getDecodedObject MUST NOT be invoked");
        }

        //
        // Encode
        //
        public void encodeASN(BerOutputStream out) {

            AttributeValue av = (AttributeValue) out.content;

            if (av.encoded != null) {
                out.content = av.encoded;
                out.encodeANY();
            } else {
                out.encodeTag(av.getTag());
                out.content = av.bytes;
                out.encodeString();
            }
        }

        public void setEncodingContent(BerOutputStream out) {

            AttributeValue av = (AttributeValue) out.content;

            if (av.encoded != null) {
                out.length = av.encoded.length;
            } else {

                if (av.getTag() == ASN1Constants.TAG_UTF8STRING) {

                    out.content = av.rawString;

                    ASN1StringType.UTF8STRING.setEncodingContent(out);

                    av.bytes = (byte[]) out.content;
                    out.content = av;
                } else {
                    av.bytes = av.rawString.getBytes(Charsets.UTF_8);
                    out.length = av.bytes.length;
                }
            }
        }

        public void encodeContent(BerOutputStream out) {
            // stub to avoid wrong encoder usage
            throw new RuntimeException("AttributeValue encodeContent MUST NOT be invoked");
        }

        public int getEncodedLength(BerOutputStream out) { //FIXME name

            AttributeValue av = (AttributeValue) out.content;

            if (av.encoded != null) {
                return out.length;
            } else {
                return super.getEncodedLength(out);
            }
        }
    };

    public static final ASN1Sequence ASN1 = new ASN1Sequence(new ASN1Type[] {
            ASN1Oid.getInstance(), attributeValue }) {

        protected Object getDecodedObject(BerInputStream in) throws IOException {
            Object[] values = (Object[]) in.content;
            return new AttributeTypeAndValue((int[]) values[0],
                    (AttributeValue) values[1]);
        }

        protected void getValues(Object object, Object[] values) {
            AttributeTypeAndValue atav = (AttributeTypeAndValue) object;

            values[0] = atav.oid.getOid();
            values[1] = atav.value;
        }
    };

    // returns known OID or null
    private static ObjectIdentifier getOID(int[] oid) {

        int index = hashIntArray(oid) % CAPACITY;

        // look for OID in the pool
        ObjectIdentifier[] list = KNOWN_OIDS[index];
        for (int i = 0; list[i] != null; i++) {
            if (Arrays.equals(oid, list[i].getOid())) {
                return list[i];
            }
        }
        return null;
    }

    // adds known OID to pool
    // for static AttributeTypeAndValue initialization only
    private static void addOID(ObjectIdentifier oid) {

        int[] newOid = oid.getOid();
        int index = hashIntArray(newOid) % CAPACITY;

        // look for OID in the pool
        ObjectIdentifier[] list = KNOWN_OIDS[index];
        int i = 0;
        for (; list[i] != null; i++) {

            // check wrong static initialization: no duplicate OIDs
            if (Arrays.equals(newOid, list[i].getOid())) {
                throw new Error("ObjectIdentifier: invalid static initialization; " +
                        "duplicate OIDs: " + oid.getName() + " " + list[i].getName());
            }
        }

        // check : to avoid NPE
        if (i == (CAPACITY - 1)) {
            throw new Error("ObjectIdentifier: invalid static initialization; " +
                    "small OID pool capacity");
        }
        list[i] = oid;
    }

    // returns hash for array of integers
    private static int hashIntArray(int[] oid) {
        int intHash = 0;
        for (int i = 0; i < oid.length && i < 4; i++) {
            intHash += oid[i] << (8 * i); //TODO what about to find better one?
        }
        return intHash & 0x7FFFFFFF; // only positive
    }
}