import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Stream;
import java.util.stream.Collectors;

 class Executor extends Thread {

     List<P2> generateP2(Production root, int depth) {

         CountDownLatch barrier = new CountDownLatch(2);

         P2 p2a = new P2(root.m_vertex.m_left, barrier);
         P2 p2b = new P2(root.m_vertex.m_right, barrier);

         p2a.start();
         p2b.start();

         barrier.await();

         if (depth == 0) {
             return new ArrayList<>{ p2a, p2b };
         } else {
             List<P2> fromA = generateP2(p2a, depth-1);
             List<P2> fromB = generateP2(p2b, depth-1);

             List<P2> merged = new ArrayList<>();
             merged.addAll(fromA);
             merged.addAll(fromB);
             return merged;
         }
     }

     List<Production> mergePairs(List<Production> prods) {

         if (prods.size() <= 2) {
             return prods;
         } else {

             int evenSize = prods.size();
             if (evenSize % 2 != 0) evenSize--;

             List<Production> newProds = new ArrayList<>();

             for (int i=0; i< evenSize; i += 2) {


                 A2 a2a = new A2(root.m_vertex.m_left, barrier);
                 A2 a2b = new A2(root.m_vertex.m_right, barrier);
             }
         }
     }

     void run2() {

         // tree

         CyclicBarrier barrier = new CyclicBarrier(1);
         P1 p1 = new P1(S,barrier);
         p1.start();
         barrier.await();

         int K = 5;

         List<P2> p2s = generateP2(p1, K);

         List<P3> p3s = p2s.stream().flatMap(p2 -> {
             CountDownLatch br = new CountDownLatch(2);
             P3 p3a = new P3(p2.m_vertex.m_left, br);
             P3 p3b = new P3(p2.m_vertex.m_right, br);
             p3a.start();
             p3b.start();
             br.await();
             return new ArrayList<P3> {p3a, p3b};
         });


        // solver


     }



 public synchronized void run() {
 Vertex S = new Vertex(null,null,null,"S");
 try {
 //[(P1)]
 CyclicBarrier barrier = new CyclicBarrier(1);
 P1 p1 = new P1(S,barrier);
 p1.start();
 barrier.await();
 //[(P2)1(P2)2]
 barrier = new CyclicBarrier(2);
 P2 p2a = new P2(p1.m_vertex.m_left,barrier);
 P2 p2b = new P2(p1.m_vertex.m_right,barrier);
 p2a.start();
 p2b.start();
 barrier.await();
 //[(P2)3(P2)4(P3)5(P3)6]
 barrier = new CyclicBarrier(4);
 P2 p2c = new P2(p2a.m_vertex.m_left,barrier);
 P2 p2d = new P2(p2a.m_vertex.m_right,barrier);
 P3 p3a = new P3(p2b.m_vertex.m_left,barrier);
 P3 p3b = new P3(p2b.m_vertex.m_right,barrier);
 p2c.start();
 p2d.start();
 p3a.start();
 p3b.start();
 barrier.await();
 //[(P3)1(P3)2(P3)3(P3)4]
 barrier = new CyclicBarrier(4);
 P3 p3c = new P3(p2c.m_vertex.m_left,barrier);
 P3 p3d = new P3(p2c.m_vertex.m_right,barrier);
 P3 p3e = new P3(p2d.m_vertex.m_left,barrier);
 P3 p3f = new P3(p2d.m_vertex.m_right,barrier);
 p3c.start();
 p3d.start();
 p3e.start();
 p3f.start();
 barrier.await();
 // MULTI-FRONTAL SOLVER ALGORITHM
 //[(A1)(A)1(A)2(A)3(A)4(AN)]
 barrier = new CyclicBarrier(6);
 A1 localMat1 = new A1(p3c.m_vertex, barrier);
 A localMat2 = new A(p3d.m_vertex, barrier);
 A localMat3 = new A(p3e.m_vertex, barrier);
 A localMat4 = new A(p3f.m_vertex, barrier);
 A localMat5 = new A(p3a.m_vertex, barrier);
 AN localMat6 = new AN(p3b.m_vertex, barrier);
 localMat1.start(); localMat2.start(); localMat3.start();
 localMat4.start(); localMat5.start(); localMat6.start();
 barrier.await();
 //[(EA)1(EA)2(EA)3(EA)4(EA)5(EA)6]
// barrier = new CyclicBarrier(6);
// EA localElim1 = new EA(p3c.m_vertex, barrier);
// EA localElim2 = new EA(p3d.m_vertex, barrier);
// EA localElim3 = new EA(p3e.m_vertex, barrier);
// EA localElim4 = new EA(p3f.m_vertex, barrier);
// EA localElim5 = new EA(p3a.m_vertex, barrier);
// EA localElim6 = new EA(p3b.m_vertex, barrier);
// localElim1.start(); localElim2.start(); localElim3.start();
// localElim4.start(); localElim5.start(); localElim6.start();
// barrier.await();
 //[(A2)1(A2)2(A2)3]
 barrier = new CyclicBarrier(3);
 A2 mergedMat1 = new A2(p2c.m_vertex, barrier);
 A2 mergedMat2 = new A2(p2d.m_vertex, barrier);
 A2 mergedMat3 = new A2(p2b.m_vertex, barrier);
 mergedMat1.start(); mergedMat2.start(); mergedMat3.start();
 barrier.await();
 //[(E2)1(E2)2(E2)3]
 barrier = new CyclicBarrier(3);
 E2 gaussElimMat1 = new E2(p2b.m_vertex, barrier);
 E2 gaussElimMat2 = new E2(p2c.m_vertex, barrier);
 E2 gaussElimMat3 = new E2(p2d.m_vertex, barrier);
 gaussElimMat1.start(); gaussElimMat2.start(); gaussElimMat3.start();
 barrier.await();
 //[(A2)4)]
 barrier = new CyclicBarrier(1);
 A2 mergedMat4 = new A2(p2a.m_vertex, barrier);
 mergedMat4.start();
 barrier.await();
 //[(E2)4]
 barrier = new CyclicBarrier(1);
 E2 gaussElimMat4 = new E2(p2a.m_vertex, barrier);
 gaussElimMat4.start();
 barrier.await();
 //[(Aroot)]
 barrier = new CyclicBarrier(1);
 Aroot mergedRootMat = new Aroot(p1.m_vertex, barrier);
 mergedRootMat.start();
 barrier.await();
 //[(Eroot)]
 barrier = new CyclicBarrier(1);
 Eroot fullElimMat = new Eroot(p1.m_vertex, barrier);
 fullElimMat.start();
 barrier.await();
 barrier = new CyclicBarrier(1);
 BS backSub1 = new BS(fullElimMat.m_vertex, barrier);
 backSub1.start();
 barrier.await();
 //[(BS)2(BS)3]
 barrier = new CyclicBarrier(2);
 BS backSub2 = new BS(backSub1.m_vertex.m_left, barrier);
 BS backSub3 = new BS(p2b.m_vertex.m_right, barrier);
 backSub2.start();
 backSub3.start();
 barrier.await();
 //[(BSA)1(BSA)2(BSA)3(BSA)4(BSA)5(BSA)6]
 barrier = new CyclicBarrier(6);
 BSA localbackSub1 = new BSA(p3c.m_vertex, barrier);
 BSA localbackSub2 = new BSA(p3d.m_vertex, barrier);
 BSA localbackSub3 = new BSA(p3e.m_vertex, barrier);
 BSA localbackSub4 = new BSA(p3f.m_vertex, barrier);
 BSA localbackSub5 = new BSA(p3a.m_vertex, barrier);
 BSA localbackSub6 = new BSA(p3b.m_vertex, barrier);
 localbackSub1.start(); localbackSub2.start(); localbackSub3.start();
 localbackSub4.start(); localbackSub5.start(); localbackSub6.start();
 barrier.await();
 } catch (InterruptedException | BrokenBarrierException e) {
 e.printStackTrace();
 }
 }
 }