// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.tsp.ers;

import java.util.List;
import org.bouncycastle.asn1.tsp.PartialHashtree;
import org.bouncycastle.util.io.Streams;
import java.io.InputStream;
import java.util.Iterator;
import java.io.OutputStream;
import java.io.IOException;
import org.bouncycastle.operator.DigestCalculator;
import java.util.Comparator;

class ERSUtil
{
    private static final Comparator<byte[]> hashComp;
    
    private ERSUtil() {
    }
    
    static byte[] calculateDigest(final DigestCalculator digestCalculator, final byte[] b) {
        try {
            final OutputStream outputStream = digestCalculator.getOutputStream();
            outputStream.write(b);
            outputStream.close();
            return digestCalculator.getDigest();
        }
        catch (final IOException ex) {
            throw ExpUtil.createIllegalState("unable to calculate hash: " + ex.getMessage(), ex);
        }
    }
    
    static byte[] calculateBranchHash(final DigestCalculator digestCalculator, final byte[] array, final byte[] array2) {
        if (ERSUtil.hashComp.compare(array, array2) <= 0) {
            return calculateDigest(digestCalculator, array, array2);
        }
        return calculateDigest(digestCalculator, array2, array);
    }
    
    static byte[] calculateBranchHash(final DigestCalculator digestCalculator, final byte[][] array) {
        if (array.length == 2) {
            return calculateBranchHash(digestCalculator, array[0], array[1]);
        }
        return calculateDigest(digestCalculator, buildIndexedHashList(array).iterator());
    }
    
    static byte[] calculateDigest(final DigestCalculator digestCalculator, final byte[] b, final byte[] b2) {
        try {
            final OutputStream outputStream = digestCalculator.getOutputStream();
            outputStream.write(b);
            outputStream.write(b2);
            outputStream.close();
            return digestCalculator.getDigest();
        }
        catch (final IOException ex) {
            throw ExpUtil.createIllegalState("unable to calculate hash: " + ex.getMessage(), ex);
        }
    }
    
    static byte[] calculateDigest(final DigestCalculator digestCalculator, final Iterator<byte[]> iterator) {
        try {
            final OutputStream outputStream = digestCalculator.getOutputStream();
            while (iterator.hasNext()) {
                outputStream.write(iterator.next());
            }
            outputStream.close();
            return digestCalculator.getDigest();
        }
        catch (final IOException ex) {
            throw ExpUtil.createIllegalState("unable to calculate hash: " + ex.getMessage(), ex);
        }
    }
    
    static byte[] calculateDigest(final DigestCalculator digestCalculator, final InputStream inputStream) {
        try {
            final OutputStream outputStream = digestCalculator.getOutputStream();
            Streams.pipeAll(inputStream, outputStream);
            outputStream.close();
            return digestCalculator.getDigest();
        }
        catch (final IOException ex) {
            throw ExpUtil.createIllegalState("unable to calculate hash: " + ex.getMessage(), ex);
        }
    }
    
    static byte[] computeNodeHash(final DigestCalculator digestCalculator, final PartialHashtree partialHashtree) {
        final byte[][] values = partialHashtree.getValues();
        if (values.length > 1) {
            return calculateDigest(digestCalculator, buildIndexedHashList(values).iterator());
        }
        return values[0];
    }
    
    static List<byte[]> buildIndexedHashList(final byte[][] array) {
        final SortedHashList list = new SortedHashList();
        for (int i = 0; i != array.length; ++i) {
            list.add(array[i]);
        }
        return list.toList();
    }
    
    static List<byte[]> buildHashList(final DigestCalculator digestCalculator, final List<ERSData> list, final byte[] array) {
        final SortedHashList list2 = new SortedHashList();
        for (int i = 0; i != list.size(); ++i) {
            list2.add(((ERSData)list.get(i)).getHash(digestCalculator, array));
        }
        return list2.toList();
    }
    
    static List<IndexedHash> buildIndexedHashList(final DigestCalculator digestCalculator, final List<ERSData> list, final byte[] array) {
        final SortedIndexedHashList list2 = new SortedIndexedHashList();
        for (int i = 0; i != list.size(); ++i) {
            list2.add(new IndexedHash(i, ((ERSData)list.get(i)).getHash(digestCalculator, array)));
        }
        return list2.toList();
    }
    
    static byte[] concatPreviousHashes(final DigestCalculator digestCalculator, final byte[] b, final byte[] b2) {
        if (b == null) {
            return b2;
        }
        try {
            final OutputStream outputStream = digestCalculator.getOutputStream();
            outputStream.write(b2);
            outputStream.write(b);
            outputStream.close();
            return digestCalculator.getDigest();
        }
        catch (final IOException ex) {
            throw new IllegalStateException("unable to hash data");
        }
    }
    
    static {
        hashComp = new ByteArrayComparator();
    }
}