public class Table {

    private ArrayList<ArrayList<ImplicantGroup>> table = new ArrayList<>();
    private ArrayList<Implicant> primes = new ArrayList<>();
    private ArrayList<Integer> expression = new ArrayList<>();
    private ArrayList<String> Ans = new ArrayList<>();
    private ArrayList<ArrayList<String>> allAnswers = new ArrayList<>();
    private HashMap<Integer, Boolean> visited = new HashMap<>();
    private HashMap<Integer, Integer> hashAnswer = new HashMap<>();
    private boolean[] taken;
    String ret = new String();
    public void initialize(String expression, String dontCare) {
        for (int i = 0; i < 500; i++)
            Ans.add("");
        int maxBinaryLength = 0;
        ArrayList<Implicant> initialExpression = new ArrayList<>();
        Pattern numPattern = Pattern.compile("\\d+");
        String totalExpression = expression + " " + dontCare;
        Matcher numMatcher = numPattern.matcher(totalExpression);
        while (numMatcher.find()) {
            String num = numMatcher.group();
            Integer temp = Integer.valueOf(num);
            String binary = Integer.toBinaryString(temp);
            maxBinaryLength = Math.max(maxBinaryLength, binary.length());
        }
        numMatcher = numPattern.matcher(totalExpression);
        while (numMatcher.find()) {
            HashSet<Integer> decimalNum = new HashSet<>();
            String num = numMatcher.group();
            Integer temp = Integer.valueOf(num);
            if (hashAnswer.get(temp) != null)
                continue;
            hashAnswer.put(temp, 0);
            decimalNum.add(temp);
            String binary = Integer.toBinaryString(temp);
            for (int i = binary.length(); i < maxBinaryLength; i++)
                binary = "0" + binary;

            System.out.println(binary);
            initialExpression.add(new Implicant(binary, decimalNum, false));
        }
        numMatcher = numPattern.matcher(expression);
        while (numMatcher.find()) {
            Integer temp = Integer.valueOf(numMatcher.group());
            if (visited.get(temp) == null)
                visited.put(temp, true);
            else
                continue;
            this.expression.add(temp);
        }
        table.add(divideIntoGroups(initialExpression, maxBinaryLength));
    }

    private ArrayList<ImplicantGroup> divideIntoGroups(ArrayList<Implicant> initial, int maxBinaryLength) {
        ArrayList<ImplicantGroup> ret = new ArrayList<>();
        for (int i = 0; i <= maxBinaryLength; i++) {
            ImplicantGroup temp = new ImplicantGroup();
            for (int j = 0; j < initial.size(); j++) {
                if (initial.get(j).countOnes() == i)
                    temp.group.add(initial.get(j));
            }
            ret.add(temp);
        }

        return ret;
    }

    public void minimizeMyTable() {

        while (true) {
            ArrayList<ImplicantGroup> newGroup = new ArrayList<>();
            ArrayList<ImplicantGroup> currentList = table.get(table.size() - 1);
            ImplicantGroup temp;
            for (int i = 0; i < currentList.size() - 1; i++) {
                temp = ImplicantGroup.createGroup(currentList.get(i), currentList.get(i + 1));
                if (temp.size() != 0)
                    newGroup.add(temp);
            }
            if (newGroup.size() != 0)
                table.add(newGroup);
            else
                break;
        }
        for (int i = 0; i < table.size(); i++) {
            for (ImplicantGroup j : table.get(i)) {
                for (Implicant k : j.group) {
                    if (k.taken)
                        k.binary += "  \u2713";
                    else
                        primes.add(k);
                }
            }
        }
        taken = new boolean[primes.size()];
        Arrays.fill(taken, new Boolean(false));
    }

    void checkAnswer(int cnt) {
        for (int i = 0; i < expression.size(); i++)
            if (hashAnswer.get(expression.get(i)) == 0)
                return;
        if (cnt < Ans.size()) {
            allAnswers.clear();
            Ans = new ArrayList<String>();
            for (int i = 0; i < taken.length; i++) {
                if (taken[i] == true)
                    Ans.add(primes.get(i).binary);
            }
            allAnswers.add(Ans);
        } else if (cnt == Ans.size()) {
            Ans = new ArrayList<String>();
            for (int i = 0; i < taken.length; i++) {
                if (taken[i] == true)
                    Ans.add(primes.get(i).binary);
            }
            allAnswers.add(Ans);
        }
    }

    public void getAns(int i, int cnt) {

        if (i == primes.size()) {
            checkAnswer(cnt);
            return;
        }

        for (int j : primes.get(i).terms) {
            hashAnswer.put(j, hashAnswer.get(j) + 1);
        }
        taken[i] = true;
        getAns(i + 1, cnt + 1);
        for (int j : primes.get(i).terms)
            hashAnswer.put(j, hashAnswer.get(j) - 1);
        taken[i] = false;
        getAns(i + 1, cnt);
    }

    public String printMyTable() {
      ret = "";
      for (int i = 0; i < table.size(); i++) {
      for (int j = 0; j < table.get(i).size(); j++) {
      for (int k = 0; k < table.get(i).get(j).size(); k++){
          ArrayList<Integer> temp = new ArrayList<>(table.get(i).get(j).group.get(k).terms);
          for (int h = 0; h < temp.size(); h++) {
            System.out.print(temp.get(h) + " ");
            ret += temp.get(h).toString() + " ";
          }
          System.out.print("|");
        //  ret += "|";
          System.out.println(table.get(i).get(j).group.get(k).binary);
         // ret += table.get(i).get(j).group.get(k).binary + "\n";
        }
        System.out.println("-------------------------");
      //  ret += "-------------------------\n" ;
      }
      System.out.println("=========================================");
     // ret += "=========================================\n";
    }
    getAns(0, 0);
    HashSet<ArrayList<String>> duplicatesRemover = new HashSet<>(allAnswers);
    allAnswers = new ArrayList<>(duplicatesRemover);
    for (ArrayList<String> i : allAnswers) {
      for (int j = 0; j < i.size(); j++) {
        for (int k = 0; k < i.get(j).length(); k++) {
          if (i.get(j).charAt(k) == '-')
            continue;
          System.out.print((char) (k + (int) 'A'));
          ret += (char) (k + (int) 'A');
          if (i.get(j).charAt(k) == '0') {
            System.out.print("`");
            ret += " ";
          }
        }
        if (j != i.size() - 1){
            System.out.print(" + ");
            ret += " + ";
        }

      }
      System.out.println();
     // ret += "\n";
    }
    return ret;
  }
}