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

#ifndef _DECAF_SECURITY_MESSAGEDIGEST_H_
#define _DECAF_SECURITY_MESSAGEDIGEST_H_

#include <decaf/util/Config.h>

#include <decaf/security/MessageDigestSpi.h>
#include <decaf/nio/ByteBuffer.h>

#include <string>

namespace decaf {
namespace security {

    class MessageDigestSpi;
    class MessageDigestImpl;
    class Provider;

    /**
     * This MessageDigest class provides applications the functionality of a message digest
     * algorithm, such as MD5 or SHA. Message digests are secure one-way hash functions that
     * take arbitrary-sized data and output a fixed-length hash value.
     *
     * A MessageDigest object starts out initialized. The data is processed through it using
     * the update methods. At any point reset can be called to reset the digest. Once all the
     * data to be updated has been updated, one of the digest methods should be called to
     * complete the hash computation.
     *
     * The digest method can be called once for a given number of updates. After digest has
     * been called, the MessageDigest object is reset to its initialized state.
     *
     * Implementations are free to implement the clone method.  Client applications can test
     * cloneability by attempting cloning and catching the CloneNotSupportedException:
     *
     *   MessageDigest* md = MessageDigest::getInstance("SHA");
     *
     *   try {
     *       md->update(toChapter1);
     *       MessageDigest* tc1 = md.clone();
     *       byte[] toChapter1Digest = tc1.digest();
     *       md.update(toChapter2);
     *       ...etc.
     *   } catch (CloneNotSupportedException& ex) {
     *       throw DigestException("couldn't make digest of partial content");
     *   }
     *
     * Note that if a given implementation is not cloneable, it is still possible to compute
     * intermediate digests by instantiating several instances, if the number of digests is
     * known in advance.
     *
     * @see MessageDigestSpi
     *
     * @since 1.0
     */
    class DECAF_API MessageDigest {
    private:

        MessageDigestImpl* impl;

        MessageDigestSpi* spi;
        const Provider* provider;
        std::string algorithm;

    private:

        MessageDigest(const MessageDigest&);
        MessageDigest& operator= (const MessageDigest&);

    protected:

        MessageDigest(const std::string& name);

    public:

        virtual ~MessageDigest();

        /**
         * Completes the hash computation by performing final operations such as padding.
         * The digest is reset after this call is made.
         */
        std::vector<unsigned char> digest();

        /**
         * Completes the hash computation by performing final operations such as padding.
         * The digest is reset after this call is made.
         *
         * @param input
         *      The output buffer for the computed digest.
         * @param size
         *      The size of the given input buffer.
         * @param offset
         *      The offset into the output buffer to begin storing the digest.
         * @param length
         *      The number of bytes within buf allotted for the digest.
         *
         * @return the number of bytes placed into buffer.
         *
         * @throws DigestException if an error occurs.
         */
        int digest(unsigned char* input, int size, int offset, int length);

        /**
         * Performs a final update on the digest using the specified array of bytes, then
         * completes the digest computation. That is, this method first calls update(input),
         * passing the input array to the update method, then calls digest().
         *
         * @param input
         *      The input to be updated before the digest is completed.
         * @param size
         *      The length in bytes of the input buffer.
         *
         * @return the array of bytes for the resulting hash value.
         */
        std::vector<unsigned char> digest(const unsigned char* input, int size);

        /**
         * Performs a final update on the digest using the specified array of bytes, then
         * completes the digest computation. That is, this method first calls update(input),
         * passing the input array to the update method, then calls digest().
         *
         * @param input
         *      The input to be updated before the digest is completed.
         *
         * @return the array of bytes for the resulting hash value.
         */
        std::vector<unsigned char> digest(const std::vector<unsigned char>& input);

        /**
         * Returns a string that identifies the algorithm, independent of implementation
         * details. The name should be a standard name (such as "SHA", "MD5", etc).
         *
         * @return the algorithm name.
         */
        std::string getAlgorithmName() const {
            return this->algorithm;
        }

        /**
         * Returns the Provider associated with this MessageDigest.
         *
         * The pointer returned by this method remains the property of the Security framework
         * and should be deleted by the calling application at any time.
         *
         * @return the provider associated with this MessageDigest.
         */
        const Provider* getProvider() const {
            return this->provider;
        }

        /**
         * Returns the length of the digest in bytes, or 0 if this operation is not supported
         * by the provider and the implementation is not cloneable.
         *
         * @return the digest length in bytes, or 0 if this operation is not supported by the
         *          provider and the implementation is not cloneable.
         */
        int getDigestLength() const;

        /**
         * Returns a clone of this MessageDisgest instance if the MessageDigestSpi in use
         * is cloneable.
         *
         * @return a clone of this MessageDigest if possible.
         *
         * @throws CloneNotSupportedException if the SPI in use cannot be cloned.
         */
        MessageDigest* clone();

        /**
         * Resets the digest for further use.
         */
        void reset();

        /**
         * Returns a string representation of this message digest object.
         *
         * @return a string representation of this message digest object.
         */
        std::string toString() const;

        /**
         * Updates the digest using the specified byte.
         *
         * @param input
         *      The byte with which to update the digest.
         */
        void update(unsigned char input);

        /**
         * Updates the digest using the specified array of bytes, starting at the specified offset.
         *
         * @param input
         *      The array of bytes.
         * @param size
         *      The size of the given input buffer.
         * @param offset
         *      The offset to start from in the array of bytes.
         * @param length
         *      The number of bytes to use, starting at offset.
         */
        void update(unsigned char* input, int size, int offset, int length);

        /**
         * Updates the digest using the specified array of bytes.
         *
         * @param input
         *      The array of bytes to use for the update.
         */
        void update(const std::vector<unsigned char>& input);

        /**
         * Update the digest using the specified ByteBuffer. The digest is updated using
         * the input.remaining() bytes starting at input.position(). Upon return, the
         * buffer's position will be equal to its limit; its limit will not have changed.
         *
         * @param input
         *      The input ByteBuffer to use for the update.
         */
        void update(nio::ByteBuffer& input);

    public:

        /**
         * Returns a MessageDigest object that implements the specified digest algorithm.
         *
         * This method traverses the list of registered security Providers, starting with the
         * most preferred Provider. A new MessageDigest object encapsulating the MessageDigestSpi
         * implementation from the first Provider that supports the specified algorithm is returned.
         *
         * Note that the list of registered providers may be retrieved via the
         * Security.getProviders() method.
         *
         * @param algorithm
         *      The name of the algorithm requested. (MD5, SHA-1, etc)
         *
         * @return a Message Digest object that implements the specified algorithm.
         * @throws NoSuchAlgorithmException if no Provider supports a MessageDigestSpi implementation
         *         for the specified algorithm.
         */
        static MessageDigest* getInstance(const std::string& algorithm);

        /**
         * Compares two digests for equality. Does a simple byte compare.
         *
         * @param digesta
         *      The first digest for comparison.
         * @param digestb
         *      The second digest for comparison.
         *
         * @return true if the two digests are equal.
         */
        static bool isEqual(const std::vector<unsigned char>& digesta,
                            const std::vector<unsigned char>& digestb);

    };

}}

#endif /* _DECAF_SECURITY_MESSAGEDIGEST_H_ */