package tubular;

import java.util.Arrays;

public class tabular {
    int indexOfArr = 0;
    String alternatriveArr[];
    String essentialPrime = "";
    int indexOfEssentialPrime [];
    static String[] binn ;
    int onlyOneArray[];
    String [] strOfMaxCoverages = new String[10000];
    int[] arrOfMaxCoverages = new int[10000];
    int indexx = 0;
    int ref = 0;
    static String[] finum ;
    static String[] finum2 ;
    static String[] pprime=new String[20];
    static String[] fprimenum=new String[20];
    String[] prime = new String[20];

    private void initalize (String []arr){
        alternatriveArr = new String[arr.length];
        System.arraycopy(arr, 0, alternatriveArr ,0, arr.length);
        onlyOneArray  = new int[binn.length];
        Arrays.fill(onlyOneArray , -1);
        indexOfEssentialPrime = new int[arr.length];
        Arrays.fill(indexOfEssentialPrime , -1);
        Arrays.fill(arrOfMaxCoverages, -1);
    }

 // parameter is string representing minterms of each term
    private int[] checkOnlyOne (String[] arr){
    //  alternatriveArr = new String[arr.length];

    //    System.arraycopy(arr, 0, alternatriveArr ,0, arr.length);
        int i ;
        for(i =0 ;i<binn.length ;i++){
            int onlyOne = 0;
            int indexOfminTermMustToken = 0;
            boolean exist = false;
            for(int j =0  ;j<arr.length; j++){
                arr[j]=" "+arr[j]+" ";
                String a = " "+binn[i]+" ";
                if(arr[j].contains(a)){
                    onlyOne++;
                    indexOfminTermMustToken = j;
                }
                arr[j]=arr[j].trim();
            }
            // onlyOneArray contains numbers of minterms must be token
            if(onlyOne == 1){
                // remove repeted onlyOneArray
                for(int k =0 ;k< onlyOneArray.length;k++){
                    if(onlyOneArray[k]==indexOfminTermMustToken){
                        exist= true;
                        break;
                    }
                }
                if(!exist){

                    indexOfEssentialPrime[indexOfArr] = indexOfminTermMustToken;
                    indexOfArr++;
                    onlyOneArray[i]= indexOfminTermMustToken;
                    removeTokenMinTermsFormStringArr(arr[indexOfminTermMustToken]);
                    break;
                }
            }
        }
        if(i<binn.length)
            checkOnlyOne(alternatriveArr);
        return onlyOneArray;
    }

    private void removeTokenMinTermsFormStringArr(String token){
        token = token.trim();
        token = token.replaceAll("\\s+", " ");
        String [] tokenn = token.split(" ");
        for(int k =0 ;k<alternatriveArr.length ;k++){
            alternatriveArr[k] = " " + alternatriveArr[k] +" ";
            for(int i=0;i<tokenn.length;i++){
                if(tokenn[i]!=" "){
                    alternatriveArr[k] = alternatriveArr[k].replace(" "+tokenn[i]+ " "," ");
                }
            }
            //alternatriveArr[k] = alternatriveArr[k].trim();
//            alternatriveArr[k] = alternatriveArr[k].replaceAll("^ +", "$1");
//            alternatriveArr[k] = alternatriveArr[k].replaceAll(" +$", "$1");
//            alternatriveArr[k] = alternatriveArr[k].replaceAll("( )+", "$1");
                alternatriveArr[k] = alternatriveArr[k].replaceAll("\\s+", " ").trim();

       /*   alternatriveArr[k] = alternatriveArr[k].replace("    ", " ");
            alternatriveArr[k] = alternatriveArr[k].replace("   ", " ");
            alternatriveArr[k] = alternatriveArr[k].replace("  ", " ");
            alternatriveArr[k] = alternatriveArr[k].replace("  ", " ");  */
        }
    }

    private boolean IsAlternativeEmpty(String []arr){
        String term = "";
        boolean empty=true;
        for(int i =0 ;i<arr.length; i++){
            term = arr[i].trim();
            term = arr[i].replaceAll("( )+", "$1");
            if(!term.equals("")){
                empty=false;
                break;
            }
        }
        if(empty){
            return true;
        }
        else{
            return false;
        }
    }

    private int findEssentialPrimeImplicants(String[] arr){
        if(IsAlternativeEmpty(arr)){
            return 0;
        }
        checkOnlyOne(arr);
        int maxnoOfCoverages = 0;
        int indexOfmaxnoOfCoverages = -1;
        int indexOfmaxnoOfCoverages2 = -1;
        boolean a =false;
        for(int i =0 ;i<arr.length;i++){
            int noOfcoverages = alternatriveArr[i].split(" ").length;
            if(alternatriveArr[i].equals("")){
                noOfcoverages = 0;
            }
            if(maxnoOfCoverages < noOfcoverages){
                maxnoOfCoverages = noOfcoverages;
                indexOfmaxnoOfCoverages = i;
                a= true;
            }
        }

        /*
        int[] repetedOfsameCoverages = new int[alternatriveArr.length];
        Arrays.fill(repetedOfsameCoverages,-1);
        int inddex = 0;
        int totalCoverage = 0 ;
        boolean repeted = false;
        for(int k=0;k<alternatriveArr.length;k++){
            int noOfcoverages = alternatriveArr[k].split(" ").length;
            if(maxnoOfCoverages == noOfcoverages && indexOfmaxnoOfCoverages!= k){
                repeted=true;
                repetedOfsameCoverages[inddex]=k;
                inddex++;
            }
        }

        if(repeted){
            for(int x=0;x<inddex;x++){
                String [] copyOfAlternative = new String[alternatriveArr.length];
                System.arraycopy(alternatriveArr, 0, copyOfAlternative, 0, alternatriveArr.length);
                int [] copyOfindexOfEssentialPrime = new int[indexOfEssentialPrime.length];
                System.arraycopy(indexOfEssentialPrime, 0, copyOfindexOfEssentialPrime, 0, indexOfEssentialPrime.length);
                int copyOfindexOfArr = indexOfArr;
                indexOfEssentialPrime[indexOfArr]=indexOfmaxnoOfCoverages;
                indexOfArr++;
                removeTokenMinTermsFormStringArr(alternatriveArr[repetedOfsameCoverages[x]]);
                //  essentialPrime += indexOfmaxnoOfCoverages;
                totalCoverage = maxnoOfCoverages+ findEssentialPrimeImplicants(alternatriveArr);
                arrOfMaxCoverages[indexx]=totalCoverage;
                indexx++;
                System.arraycopy(copyOfAlternative, 0, alternatriveArr, 0, alternatriveArr.length);
                System.arraycopy(copyOfindexOfEssentialPrime, 0, indexOfEssentialPrime, 0, indexOfEssentialPrime.length);
                indexOfArr = copyOfindexOfArr;
            }
        }*/
       // else if(!repeted){
        if(a){
            indexOfEssentialPrime[indexOfArr]=indexOfmaxnoOfCoverages;
            indexOfArr++;
            removeTokenMinTermsFormStringArr(alternatriveArr[indexOfmaxnoOfCoverages]);
            essentialPrime += indexOfmaxnoOfCoverages;

        }
            //      totalCoverage = maxnoOfCoverages+ findEssentialPrimeImplicants(alternatriveArr);
      //  }
        return 0;



//        indexOfEssentialPrime[indexOfArr]=indexOfmaxnoOfCoverages;
//        indexOfArr++;
//        removeTokenMinTermsFormStringArr(alternatriveArr[indexOfmaxnoOfCoverages]);
//        essentialPrime += indexOfmaxnoOfCoverages;
//        int noOfterms = 1 + findEssentialPrimeImplicants(alternatriveArr);

    }

    private String[] removeDonotCare (String[] uncorrecttStr , String donotcare){
        String[] correctStr = new String[uncorrecttStr.length];
        String[] donotcareParts = donotcare.replaceAll("\\s+", " ").trim().split(" ");
        Arrays.fill(correctStr, "");
        for(int i=0;i<uncorrecttStr.length ;i++ ){
            String [] part = uncorrecttStr[i].replaceAll("\\s+", " ").trim().split(" ");
            for(int j=0 ;j<donotcareParts.length ;j++){
                for(int k=0 ;k<part.length ;k++){
                    if(part[k].equals(donotcareParts[j])){
                        part[k] = "";
                    }
                }
            }
            for(int j = 0 ; j<part.length ; j++){
                correctStr[i]+= part[j] + " ";
            }
            correctStr[i] = correctStr[i].replaceAll("\\s+", " ").trim();
        }
        return correctStr;
    }

    private String[] printEssentialImplicants(String[] binx){
        // generates inputs
        String[] printedForms = new String [binx.length];
        Arrays.fill(printedForms, "");
        for(int j = 0 ;j<indexOfArr ; j++){
            String current = binx[indexOfEssentialPrime[j]];
            for(int k=0 ;k< current.length();k++){
                if(current.charAt(k) == '0'){
                    printedForms[j]+= Character.toChars(65+k)[0] + "'";
                }
                else if(current.charAt(k) == '1'){
                    printedForms[j]+= Character.toChars(65+k)[0];
                }
                else if (current.charAt(k) == '-'){
                }
            }
        }
        return printedForms;
    }

    public String[] min(String minterm, int input) {
        String bin[] = minterm.split(" ");
        pprime=bin;
       int  num[]= new int[bin.length];
        String str[] = new String[bin.length];
        for (int i = 0; i < bin.length; i++) {
            num[i] = Integer.parseInt(bin[i]);
            str[i] = new String();
            str[i] = convertBinary(num[i]);
           // System.out.println(num[i]);
            int numberOfDigit = input - str[i].length();
            for (int j = 0; j < numberOfDigit; j++)
                str[i] = "0" + str[i];
        }
        // int d[i]=str[0].length()-str[0].replace("1", "").length();
        return str;

    }

    public String convertBinary(int num) {
        StringBuilder binary = new StringBuilder();
        while (num > 0) {
            binary.append(num % 2);
            num = num / 2;
        }
        binary.reverse();
        return binary.toString();
    }
 boolean flag=true;
    public String[] rec(String org[], int input, String [] bprime) {
        int k = 0;
        boolean[] check = new boolean[org.length];
        String[] res = new String[100];
        String[] primenum=new String[20];
        for (int h=0;h<org.length&&flag;h++){

            System.out.println(org[h]+"<--->"+bprime[h]);
        }
        flag=false;
        System.out.println("---------------Next Step---------------");

        String temp = new String();
        for (int i = org.length - 1; i >= 0; i--) {
            for (int j = i - 1; j >= 0; j--) {
                temp += Math.abs(Integer.parseInt(org[i]) - Integer.parseInt(org[j]));
                int numberOfDigit = Math.abs(input - temp.length());
                for (int h = 0; h < numberOfDigit; h++)
                    temp = "0" + temp;
                if (temp.length() - temp.replace("1", "").length() == 1
                        && temp.length() - temp.replace("0", "").length() == input - 1) {
                    check[i] = true;
                    check[j] = true;
                    res[k] = new String();
                    int indexx = temp.indexOf("1");
                    primenum[k]=new String();
                    primenum[k] = bprime[i]+" "+bprime[j];
                    res[k] = org[i];
                    res[k] = res[k].substring(0, indexx) + '5' + res[k].substring((indexx + 1));
                    if (k!=0&&!res[k].equals(org[k-1]))
                    System.out.println(res[k].replace('5', '-')+"<--->"+primenum[k]);
                    k++;
                }
                temp = new String();
            }
        }
        for (int y = 0; y < org.length; y++) {
            if (!check[y]) {
                fprimenum[ref]=bprime[y];
                prime[ref] = new String();
                prime[ref] = org[y];
                ref++;
            }
        }
        String[] resanum = new String[k];
        String[] resa = new String[k];
        for (int l = 0; l < k; l++)
            {
            resanum[l]=primenum[l];
            resa[l] = res[l];

            }

        if (allfalse(check)) {
            String[] fiprime = new String[ref];
            finum = new String[ref];
            for (int i = 0; i < ref; i++) {
                fiprime[i] = new String();
                finum[i]=new String();
                finum[i]=fprimenum[i];
                fiprime[i] = prime[i];
                fiprime[i] = fiprime[i].replace('5', '-');
            }

            fiprime = removeDuplicates(fiprime);
            return fiprime;
        }

        else

            return rec(resa, input,primenum);

    }

    private static boolean allfalse(boolean[] values) {
        for (boolean value : values) {
            if (value)
                return false;
        }
        return true;
    }

    public static String[] removeDuplicates(String[] arr) {

        int end = arr.length;

        for (int i = 0; i < end; i++) {
            for (int j = i + 1; j < end; j++) {
                if (arr[i].equals(arr[j])) {
                    int shiftLeft = j;
                    for (int k = j + 1; k < end; k++, shiftLeft++) {
                        arr[shiftLeft] = arr[k];
                        finum[shiftLeft]=finum[k];
                    }
                    end--;
                    j--;
                }
            }
        }
        finum2 = new String[end];
        String[] whitelist = new String[end];
        for (int i = 0; i < end; i++) {
            finum2[i] = finum[i];
            whitelist[i] = arr[i];
        }
        return whitelist;
    }

    public static void main(String[] args) {
        tabular test = new tabular();
        // boolean [] arr={false ,false ,false ,false ,false ,false ,false
        // ,false ,false };
//        String bin[] = test.min("", 6);
//        String binx[] = test.rec(bin, 6, pprime);
//
//        // System.out.println(allfalse(arr));
//        for (int i = 0; i < finum2.length; i++) {
//            System.out.println(finum2[i]+ "   " +binx[i]);


        // run
     /*   binn =  "0 1 4 5 6 7 9 10 11 14 15".split(" ");
        String [] a = test.min("0 1 4 5 6 7 9 10 11 14 15", 4);
        String [] b = test.rec(a, 4, pprime);
        for (int i = 0; i < finum2.length; i++) {
          System.out.println(finum2[i]);
        }
        String d [] = test.removeDonotCare(finum2, "10 14");
        for (int i = 0; i < d.length; i++) {
            System.out.println(d[i]);
          }
        test.initalize(d);
        int n = test.findEssentialPrimeImplicants(d);
        String c [] = test.printEssentialImplicants(b);
        for (int i = 0; i < c.length; i++) {
         System.out.println(c[i]);
        } */

//        binn = "1 2 3 4 5 6 7".split(" ");
//        String arr[] = {"1 5 7 6", "1 2 4 6" , "5 4 3" , "7 2 3"};
//        test.initalize(arr);
//        test.findEssentialPrimeImplicants(arr);
//        String c [] = test.printEssentialImplicants(arr);
//        for (int i = 0; i < c.length; i++) {
//         System.out.println(c[i]);
//        }
//

        binn = "0 1 3 7 11 12 13 15".split(" ");
        String [] a = test.min("0 1 3 7 11 12 13 15", 4);
        String [] b = test.rec(a, 4, pprime);
//        for (int i = 0; i < finum2.length; i++) {
//          System.out.println(finum2[i]);
//        }
//        System.out.println("");
        //String d [] = test.removeDonotCare(finum2, "3 13 15");
        /*for (int i = 0; i < d.length; i++) {
            System.out.println(d[i]);
          }*/
       // test.initalize(d);
       // int n = test.findEssentialPrimeImplicants(d);
       // String c [] = test.printEssentialImplicants(b);
      /*  for (int i = 0; i < c.length; i++) {
         System.out.println(c[i]);
        }*/



   }
}