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

package org.bouncycastle.tsp.ers;

import org.bouncycastle.util.Arrays;
import org.bouncycastle.util.StoreException;
import java.util.HashSet;
import org.bouncycastle.util.Selector;
import java.util.Collections;
import java.util.ArrayList;
import org.bouncycastle.operator.OperatorCreationException;
import org.bouncycastle.asn1.tsp.PartialHashtree;
import org.bouncycastle.asn1.tsp.ArchiveTimeStamp;
import java.util.Iterator;
import java.util.HashMap;
import java.util.Collection;
import org.bouncycastle.operator.DigestCalculator;
import java.util.List;
import java.util.Map;
import org.bouncycastle.util.Store;

public class ERSEvidenceRecordStore implements Store<ERSEvidenceRecord>
{
    private Map<HashNode, List<ERSEvidenceRecord>> recordMap;
    private DigestCalculator digCalc;
    
    public ERSEvidenceRecordStore(final Collection<ERSEvidenceRecord> collection) throws OperatorCreationException {
        this.recordMap = new HashMap<HashNode, List<ERSEvidenceRecord>>();
        this.digCalc = null;
        for (final ERSEvidenceRecord ersEvidenceRecord : collection) {
            final ArchiveTimeStamp archiveTimeStamp = ersEvidenceRecord.getArchiveTimeStamps()[0];
            if (this.digCalc == null) {
                this.digCalc = ersEvidenceRecord.getDigestAlgorithmProvider().get(archiveTimeStamp.getDigestAlgorithmIdentifier());
            }
            final PartialHashtree hashTreeLeaf = archiveTimeStamp.getHashTreeLeaf();
            if (hashTreeLeaf != null) {
                final byte[][] values = hashTreeLeaf.getValues();
                if (values.length > 1) {
                    for (int i = 0; i != values.length; ++i) {
                        this.addRecord(new HashNode(values[i]), ersEvidenceRecord);
                    }
                    this.addRecord(new HashNode(ERSUtil.computeNodeHash(this.digCalc, hashTreeLeaf)), ersEvidenceRecord);
                }
                else {
                    this.addRecord(new HashNode(values[0]), ersEvidenceRecord);
                }
            }
            else {
                this.addRecord(new HashNode(archiveTimeStamp.getTimeStampDigestValue()), ersEvidenceRecord);
            }
        }
    }
    
    private void addRecord(final HashNode hashNode, final ERSEvidenceRecord o) {
        final List list = this.recordMap.get(hashNode);
        if (list != null) {
            final ArrayList list2 = new ArrayList(list.size() + 1);
            list2.addAll(list);
            list2.add((Object)o);
            this.recordMap.put(hashNode, (ArrayList)list2);
        }
        else {
            this.recordMap.put(hashNode, Collections.singletonList(o));
        }
    }
    
    @Override
    public Collection<ERSEvidenceRecord> getMatches(final Selector<ERSEvidenceRecord> selector) throws StoreException {
        if (selector instanceof ERSEvidenceRecordSelector) {
            final List list = this.recordMap.get(new HashNode(((ERSEvidenceRecordSelector)selector).getData().getHash(this.digCalc, null)));
            if (list != null) {
                final ArrayList list2 = new ArrayList(list.size());
                for (int i = 0; i != list.size(); ++i) {
                    final ERSEvidenceRecord ersEvidenceRecord = (ERSEvidenceRecord)list.get(i);
                    if (selector.match(ersEvidenceRecord)) {
                        list2.add((Object)ersEvidenceRecord);
                    }
                }
                return (Collection<ERSEvidenceRecord>)Collections.unmodifiableList((List<?>)list2);
            }
            return (Collection<ERSEvidenceRecord>)Collections.emptyList();
        }
        else {
            if (selector == null) {
                final HashSet c = new HashSet(this.recordMap.size());
                final Iterator<List<ERSEvidenceRecord>> iterator = this.recordMap.values().iterator();
                while (iterator.hasNext()) {
                    c.addAll(iterator.next());
                }
                return (Collection<ERSEvidenceRecord>)Collections.unmodifiableList((List<?>)new ArrayList<Object>(c));
            }
            final HashSet c2 = new HashSet();
            for (final List list3 : this.recordMap.values()) {
                for (int j = 0; j != list3.size(); ++j) {
                    if (selector.match((ERSEvidenceRecord)list3.get(j))) {
                        c2.add(list3.get(j));
                    }
                }
            }
            return (Collection<ERSEvidenceRecord>)Collections.unmodifiableList((List<?>)new ArrayList<Object>(c2));
        }
    }
    
    private static class HashNode
    {
        private final byte[] dataHash;
        private final int hashCode;
        
        public HashNode(final byte[] dataHash) {
            this.dataHash = dataHash;
            this.hashCode = Arrays.hashCode(dataHash);
        }
        
        @Override
        public int hashCode() {
            return this.hashCode;
        }
        
        @Override
        public boolean equals(final Object o) {
            return o instanceof HashNode && Arrays.areEqual(this.dataHash, ((HashNode)o).dataHash);
        }
    }
}