package digest;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

public class MessageDigestTest {
    private final MessageDigest sharedMd;

    private static final byte[] DATA1 = "the data".getBytes(StandardCharsets.UTF_8);
    private static final byte[] DATA2 = "more_data".getBytes(StandardCharsets.UTF_8);
    private static final byte[] DATA3 = "other data".getBytes(StandardCharsets.UTF_8);

    public MessageDigestTest() throws Exception {
        sharedMd = MessageDigest.getInstance("SHA-256");
    }

    public void calculateAndPrintHash() throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");

        md.update(DATA1);
        md.update(DATA2);
        byte[] hash = md.digest();
        System.out.println("Hash Calculated: " + Base64.getEncoder().encodeToString(hash));

        md.update(DATA3);
        byte[] hash2 = md.digest();
        System.out.println("Hash2: " + Base64.getEncoder().encodeToString(hash2));
    }

    public String calculateHash(byte[] data) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(data);
        byte[] hash = md.digest();
        return Base64.getEncoder().encodeToString(hash);
    }

    public String calculateHashShared(byte[] data) {
        sharedMd.reset();
        sharedMd.update(data);
        byte[] hash = sharedMd.digest();
        return Base64.getEncoder().encodeToString(hash);
    }

    public static void main(String[] args) throws Exception {
        MessageDigestTest test = new MessageDigestTest();

        String hash1 = test.calculateHash(DATA1);
        String hash2 = test.calculateHash(DATA2);

        List<Future<String>> hash1Futures = new ArrayList<>();
        List<Future<String>> hash2Futures = new ArrayList<>();

        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 100; i++) {
            hash1Futures.add(executor.submit(() -> test.calculateHashShared(DATA1)));
            hash2Futures.add(executor.submit(() -> test.calculateHashShared(DATA2)));
        }
        executor.shutdown();

        Set<String> hash1Results = hash1Futures.stream().map(t -> {
            try {
                return t.get();
            } catch (InterruptedException | ExecutionException e) {
                return e.toString();
            }
        }).collect(Collectors.toSet());

        Set<String> hash2Results = hash2Futures.stream().map(t -> {
            try {
                return t.get();
            } catch (InterruptedException | ExecutionException e) {
                return e.toString();
            }
        }).collect(Collectors.toSet());

        System.out.println("---");
        System.out.println("Expected Hash1: " + hash1);
        System.out.println("Hash1 Results: " + hash1Results);
        System.out.println("---");
        System.out.println("Expected Hash2: " + hash2);
        System.out.println("Hash2 Results: " + hash2Results);
        System.out.println("---");
    }
}