import java.math.BigInteger;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import java.util.stream.IntStream;

public class NumberTest {
    static BigInteger TWO = new BigInteger("2");
    static BigInteger SEVEN = new BigInteger("7");
    static BigInteger EIGHT = new BigInteger("8");
    static BigInteger NINE = new BigInteger("9");
    private static int MAX_SIZE = 20;
    static Map<Integer, BigInteger> powerCache2 = Collections.synchronizedMap(new LRUCache<>());
    static Map<Integer, BigInteger> powerCache7 = Collections.synchronizedMap(new LRUCache<>());
    static Map<Integer, BigInteger> powerCache8 = Collections.synchronizedMap(new LRUCache<>());



    public static class LRUCache<A,B> extends LinkedHashMap<A, B> {

        /**
         *
         */
        private static final long serialVersionUID = 1L;

        public LRUCache() {
            super(2,0.75f, true);

        }

        @Override
        protected boolean removeEldestEntry(java.util.Map.Entry<A, B> eldest) {
            return size() > MAX_SIZE;
        }
    }

    public static void main(String[] args) {
        //testNumber(1,6,6,2);

        IntStream.iterate(4, i -> i + 1).parallel().forEach(NumberTest::generateNumber);
    }

    public static int generateNumber(int numDigets) {
        for (int i2 = 0;i2 <= numDigets;i2++) {
            for (int i7 = 0; i7 <= numDigets-i2;i7++) {
                if (numDigets-i2 == 0) {
                    testNumber(i2, i7, 0, 0);
                }else {
                    for (int i8 = 0;i8 <= numDigets-i2-i7;i8++) {
                        testNumber(i2, i7, i8, numDigets-i2-i7-i8);
                    }
                }
            }
        }

        return 0;
    }

    public static BigInteger getPowerCache2(BigInteger p, Integer exp) {
        return powerCache2.computeIfAbsent(exp, (k) -> {return p.pow(k);});
    }

    public static BigInteger getPowerCache7(BigInteger p, Integer exp) {
        return powerCache7.computeIfAbsent(exp, (k) -> {return p.pow(k);});
    }

    public static BigInteger getPowerCache8(BigInteger p, Integer exp) {
        return powerCache8.computeIfAbsent(exp, (k) -> {return p.pow(k);});
    }

    public static BigInteger getPowerCache(Integer i, Integer exp) {
        if (i.equals(2))
            return getPowerCache2(TWO, exp);
        if (i.equals(7))
            return getPowerCache7(SEVEN, exp);
        if (i.equals(8))
            return getPowerCache8(EIGHT, exp);
        return new BigInteger(Integer.toString(i)).pow(exp);
    }



    public static int testNumber(int numberTwos, int numberSevens, int numberEights, int numberNines) {

        HashMap<Integer, Integer> map = new HashMap<>();

        map.put(2, numberTwos);
        map.put(7, numberSevens);
        map.put(8, numberEights);
        map.put(9, numberNines);

        BigInteger num = map.entrySet().parallelStream().map((v) -> {return getPowerCache(v.getKey(), v.getValue());}).reduce(BigInteger.ONE, (a, b) -> {return a.multiply(b);});

        int count = calculateProductOfDigets(num);

        if (count > 5)
            System.out.println(count + " = " + numberTwos + "-" + numberSevens + "-" + numberEights + "-" + numberNines);

        return 0;

    }

    public static int calculateProductOfDigets(BigInteger number) {

        // This is step 2 of the iteration as testNumber does the first step

        int count = 1;
        while (number.compareTo(BigInteger.TEN) > 0) {
            String actualNumber = number.toString();

            number = new BigInteger("1");

            for(int i =0;i < actualNumber.length();i++) {

                char c= actualNumber.charAt(i);

                // anything multiplied by 0 is 0 so this is the last number in the iteration
                if (c == '0')
                    return count+1;

                number = number.multiply(new BigInteger(Character.toString(c)));
            }

            count++;
        }

        return count;
    }

}