package org.test.pingpong;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String... args) throws InterruptedException {
        // Choose one:

        // countDownLatchSolution();
        // cyclicBarrierSolution();
        // queueMessagePassingSolution();
    }

    static volatile CountDownLatch pingLatch = new CountDownLatch(1);
    static volatile CountDownLatch pongLatch = new CountDownLatch(1);

    static class PingPongActivityZ extends Thread {

        private final IAction action;
        private final boolean isPing;

        public PingPongActivityZ(IAction act) {
            action = act;
            isPing = act instanceof Ping;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    (isPing ? pingLatch : pongLatch).await();
                    action.doAction();
                    resetLatch();
                    (isPing ? pongLatch : pingLatch).countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void resetLatch() {
            if (isPing) {
                pingLatch = new CountDownLatch(1);
            } else {
                pongLatch = new CountDownLatch(1);
            }
        }
    }

    static void countDownLatchSolution() throws InterruptedException {
        Ping ping = new Ping();
        Pong pong = new Pong();

        Thread tPing = new PingPongActivityZ(ping);
        Thread tPong = new PingPongActivityZ(pong);

        tPing.start();
        tPong.start();

        // progress processing
        pingLatch.countDown();

        tPing.join();
        tPong.join();
    }

    static class PingPongActivity extends Thread {
        private final IAction action;
        private final CyclicBarrier actBarrier;
        private final CyclicBarrier oppActBarrier;

        public PingPongActivity(IAction act, CyclicBarrier actBarrier, CyclicBarrier oppActBarrier) {
            action = act;
            this.actBarrier = actBarrier;
            this.oppActBarrier = oppActBarrier;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    actBarrier.await();
                    action.doAction();
                    oppActBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static void cyclicBarrierSolution() throws InterruptedException {
        Ping ping = new Ping();
        Pong pong = new Pong();

        CyclicBarrier pingBarrier = new CyclicBarrier(2);
        CyclicBarrier pongBarrier = new CyclicBarrier(2);

        Thread tPing = new PingPongActivity(ping, pingBarrier, pongBarrier);
        Thread tPong = new PingPongActivity(pong, pongBarrier, pingBarrier);

        tPing.start();
        tPong.start();

        // progress processing
        try {
            pingBarrier.await();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

        tPing.join();
        tPong.join();
    }

    static class PingPongActivityM implements Runnable {

        private final IAction action;
        private final ExecutorService oppActionActivity;
        private final IAction oppositeAction;
        private final ExecutorService actionActivity;

        public PingPongActivityM(IAction act, ExecutorService actActivity, IAction oppAction, ExecutorService oppActActivity) {
            action = act;
            actionActivity = actActivity;
            oppositeAction = oppAction;
            oppActionActivity = oppActActivity;
        }

        @Override
        public void run() {
            action.doAction();
            oppActionActivity.execute(new PingPongActivityM(oppositeAction, oppActionActivity, action, actionActivity));
        }

    }

    static void queueMessagePassingSolution() {
        ExecutorService pingActivity = Executors.newFixedThreadPool(1);
        ExecutorService pongActivity = Executors.newFixedThreadPool(1);

        Ping ping = new Ping();
        Pong pong = new Pong();
        pingActivity.execute(new PingPongActivityM(ping, pingActivity, pong, pongActivity));
    }

}