/*
 *  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 Vladimir N. Molotkov, Stepan M. Mishura
* @version $Revision$
*/

package org.apache.harmony.security.asn1;

import java.io.IOException;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;


/**
 * This abstract class represents ASN.1 Choice type.
 *
 * To implement custom ASN.1 choice type an application class
 * must provide implementation for the following methods:
 *     getIndex()
 *     getObjectToEncode()
 *
 * There are two ways to implement custom ASN.1 choice type:
 * with application class that represents ASN.1 custom choice type or without.
 * The key point is how a value of choice type is stored by application classes.
 *
 * For example, let's consider the following ASN.1 notations
 * (see http://www.ietf.org/rfc/rfc3280.txt)
 *
 * Time ::= CHOICE {
 *       utcTime        UTCTime,
 *       generalTime    GeneralizedTime
 * }
 *
 * Validity ::= SEQUENCE {
 *       notBefore      Time,
 *       notAfter       Time
 *  }
 *
 * 1)First approach:
 * No application class to represent ASN.1 Time notation
 *
 * The Time notation is a choice of different time formats: UTC and Generalized.
 * Both of them are mapped to java.util.Date object, so an application
 * class that represents ASN.1 Validity notation may keep values
 * as Date objects.
 *
 * So a custom ASN.1 Time choice type should map its notation to Date object.
 *
 * class Time {
 *
 *     // custom ASN.1 choice class: maps Time to is notation
 *     public static final ASN1Choice asn1 = new ASN1Choice(new ASN1Type[] {
 *         ASN1GeneralizedTime.asn1, ASN1UTCTime.asn1 }) {
 *
 *         public int getIndex(java.lang.Object object) {
 *             return 0; // always encode as ASN1GeneralizedTime
 *         }
 *
 *         public Object getObjectToEncode(Object object) {
 *
 *             // A value to be encoded value is a Date object
 *             // pass it to custom time class
 *             return object;
 *         }
 *     };
 * }
 *
 * class Validity {
 *
 *     private Date notBefore;    // choice as Date
 *     private Date notAfter;     // choice as Date
 *
 *     ... // constructors and other methods go here
 *
 *     // custom ASN.1 sequence class: maps Validity class to is notation
 *     public static final ASN1Sequence ASN1
 *         = new ASN1Sequence(new ASN1Type[] {Time.asn1, Time.asn1 }) {
 *
 *         protected Object getObject(Object[] values) {
 *
 *             // ASN.1 Time choice passed Data object - use it
 *             return new Validity((Date) values[0], (Date) values[1]);
 *         }
 *
 *         protected void getValues(Object object, Object[] values) {
 *
 *             Validity validity = (Validity) object;
 *
 *             // pass Date objects to ASN.1 Time choice
 *             values[0] = validity.notBefore;
 *             values[1] = validity.notAfter;
 *         }
 *     }
 * }
 *
 * 2)Second approach:
 * There is an application class to represent ASN.1 Time notation
 *
 * If it is a matter what time format should be used to decode/encode
 * Date objects a class to represent ASN.1 Time notation must be created.
 *
 * For example,
 *
 * class Time {
 *
 *     private Date utcTime;
 *     private Date gTime;
 *
 *     ... // constructors and other methods go here
 *
 *     // custom ASN.1 choice class: maps Time to is notation
 *     public static final ASN1Choice asn1 = new ASN1Choice(new ASN1Type[] {
 *         ASN1GeneralizedTime.asn1, ASN1UTCTime.asn1 }) {
 *
 *         public Object getDecodedObject(BerInputStream in) {
 *
 *             // create Time object to pass as decoded value
 *             Time time = new Time();
 *
 *             if (in.choiceIndex==0) {
 *                 // we decoded GeneralizedTime
 *                 // store decoded Date value in corresponding field
 *                 time.gTime = in.content;
 *                 // return it
 *                 return time;
 *             } else {
 *                 // we decoded UTCTime
 *                 // store decoded Date value in corresponding field
 *                 time.utcTime = in.content;
 *                 // return it
 *                 return time;
 *             }
 *         }
 *
 *         public int getIndex(java.lang.Object object) {
 *             Time time = (Time)object;
 *             if(time.utcTime!=null){
 *                 // encode Date as UTCTime
 *                 return 1;
 *             } else {
 *                 // otherwise encode Date as GeneralizedTime
 *                 return 0;
 *             }
 *         }
 *
 *         public Object getObjectToEncode(Object object) {
 *             Time time = (Time)object;
 *             if(time.utcTime!=null){
 *                 // encode Date as UTCTime
 *                 return 1;
 *             } else {
 *                 // otherwise encode Date as GeneralizedTime
 *                 return 0;
 *             }
 *         }
 *     };
 * }
 *
 * So now Validity class must keep all values in Time object
 * and its custom ASN.1 sequence class must handle this class of objects
 *
 * class Validity {
 *
 *     private Time notBefore;    // now it is a Time!!!
 *     private Time notAfter;     // now it is a Time!!!
 *
 *     ... // constructors and other methods go here
 *
 *     // custom ASN.1 sequence class: maps Validity class to is notation
 *     public static final ASN1Sequence ASN1
 *         = new ASN1Sequence(new ASN1Type[] {Time.asn1, Time.asn1 }) {
 *
 *         protected Object getObject(Object[] values) {
 *
 *             // We've gotten Time objects here !!!
 *             return new Validity((Time) values[0], (Time) values[1]);
 *         }
 *
 *         protected void getValues(Object object, Object[] values) {
 *
 *             Validity validity = (Validity) object;
 *
 *             // pass Time objects to ASN.1 Time choice
 *             values[0] = validity.notBefore;
 *             values[1] = validity.notAfter;
 *         }
 *     }
 * }
 *
 * @see <a href="http://asn1.elibel.tm.fr/en/standards/index.htm">ASN.1</a>
 */
public abstract class ASN1Choice extends ASN1Type {
    public final ASN1Type[] type;

    /**
     * identifiers table: [2][number of distinct identifiers]
     * identifiers[0]: stores identifiers (includes nested choices)
     * identifiers[1]: stores identifiers' indexes in array of types
     */
    private final int[][] identifiers;

    /**
     * Constructs ASN.1 choice type.
     *
     * @param type -
     *            an array of one or more ASN.1 type alternatives.
     * @throws IllegalArgumentException -
     *             type parameter is invalid
     */
    public ASN1Choice(ASN1Type[] type) {
        super(TAG_CHOICE); // has not tag number

        if (type.length == 0) {
            throw new IllegalArgumentException("ASN.1 choice type MUST have at least one alternative: " + getClass().getName());
        }

        // create map of all identifiers
        TreeMap<BigInteger, BigInteger> map = new TreeMap<BigInteger, BigInteger>();
        for (int index = 0; index < type.length; index++) {
            ASN1Type t = type[index];

            if (t instanceof ASN1Any) {
                // ASN.1 ANY is not allowed,
                // even it is a single component (not good for nested choices)
                throw new IllegalArgumentException("ASN.1 choice type MUST have alternatives with distinct tags: " + getClass().getName()); // FIXME name
            } else if (t instanceof ASN1Choice) {

                // add all choice's identifiers
                int[][] choiceToAdd = ((ASN1Choice) t).identifiers;
                for (int j = 0; j < choiceToAdd[0].length; j++) {
                    addIdentifier(map, choiceToAdd[0][j], index);
                }
                continue;
            }

            // add primitive identifier
            if (t.checkTag(t.id)) {
                addIdentifier(map, t.id, index);
            }

            // add constructed identifier
            if (t.checkTag(t.constrId)) {
                addIdentifier(map, t.constrId, index);
            }
        }

        // fill identifiers array
        int size = map.size();
        identifiers = new int[2][size];
        Iterator<Map.Entry<BigInteger, BigInteger>> it = map.entrySet().iterator();

        for (int i = 0; i < size; i++) {
            Map.Entry<BigInteger, BigInteger> entry = it.next();
            BigInteger identifier = entry.getKey();

            identifiers[0][i] = identifier.intValue();
            identifiers[1][i] = entry.getValue().intValue();
        }

        this.type = type;
    }

    private void addIdentifier(TreeMap<BigInteger, BigInteger> map, int identifier, int index){
        if (map.put(BigInteger.valueOf(identifier), BigInteger.valueOf(index)) != null) {
            throw new IllegalArgumentException("ASN.1 choice type MUST have alternatives "
                    + "with distinct tags: " + getClass().getName());
        }
    }

    /**
     * Tests whether one of choice alternatives has the same identifier or not.
     *
     * @param identifier -
     *            ASN.1 identifier to be verified
     * @return - true if one of choice alternatives has the same identifier,
     *         otherwise false;
     */
    public final boolean checkTag(int identifier) {
        return Arrays.binarySearch(identifiers[0], identifier) >= 0;
    }

    public Object decode(BerInputStream in) throws IOException {
        int index = Arrays.binarySearch(identifiers[0], in.tag);
        if (index < 0) {
            throw new ASN1Exception("Failed to decode ASN.1 choice type.  No alternatives were found for " + getClass().getName());// FIXME message
        }

        index = identifiers[1][index];

        in.content = type[index].decode(in);

        // set index for getDecodedObject method
        in.choiceIndex = index;

        if (in.isVerify) {
            return null;
        }
        return getDecodedObject(in);
    }

    public void encodeASN(BerOutputStream out) {
        encodeContent(out);
    }

    public final void encodeContent(BerOutputStream out) {
        out.encodeChoice(this);
    }

    public abstract int getIndex(Object object);

    public abstract Object getObjectToEncode(Object object);

    public final void setEncodingContent(BerOutputStream out) {
        out.getChoiceLength(this);
    }
}