// =========================================================================
1. Реализовать программу, в которой два потока поочередно пишут ping и pong.
// =========================================================================



package ru.home.geekbrains.threading.data;

public enum Message {
    PING("ping"),
    PONG("pong");

    private String message;

    Message(String message) {
        this.message = message;
    }
}




// ===============================================================


package ru.home.geekbrains.threading.model;

import ru.home.geekbrains.threading.data.Message;
import java.util.concurrent.SynchronousQueue;

// домашний синглетончик
public enum Storage {

    INSTANCE;

    SynchronousQueue<Message> queue = new SynchronousQueue<>();

    public SynchronousQueue<Message> getQueue() {
        return queue;
    }
}


// ===============================================================



package ru.home.geekbrains.threading;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyCounter {

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    private long counter;


    public long get() {

        long result;

        try {
            lock.readLock().lock();
            result = counter;
        }
        finally {
            lock.readLock().unlock();
        }

        return result;
    }


    public long incrementAndGet() {

        long result;

        try {
            lock.writeLock().lock();
            result = ++counter;
        }
        finally {
            lock.writeLock().unlock();
        }
        return result;
    }


    public long decrementAndGet() {

        long result;

        try {
            lock.writeLock().lock();
            result = --counter;
        }
        finally {
            lock.writeLock().unlock();
        }
        return result;
    }

}



// ===============================================================



package ru.home.geekbrains.threading;

import lombok.extern.slf4j.Slf4j;
import ru.home.geekbrains.threading.data.Message;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

@Slf4j
public abstract class AbstractThread extends Thread {

    BlockingQueue<Message> queue;
    MyCounter rx = new MyCounter();
    MyCounter tx = new MyCounter();

    public AbstractThread(BlockingQueue<Message> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {

        Message message = null;
        while(!Thread.currentThread().isInterrupted()) {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
                communicateLogic();

                log.info("{} - Rx/Tx: {}/{}", Thread.currentThread().getName(), rx.get(), tx.get());

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    protected void sendMessage(Message message) throws InterruptedException {
        log.info("{} - send: {}", Thread.currentThread().getName(), message);
        queue.put(message);
        tx.incrementAndGet();
    }

    protected Message readMessage() throws InterruptedException {
        Message result = queue.take();
        log.info("{} - received: {}", Thread.currentThread().getName(), result);
        rx.incrementAndGet();
        return result;
    }

    protected abstract void communicateLogic() throws InterruptedException;


}






// ===============================================================






package ru.home.geekbrains.threading;

import ru.home.geekbrains.threading.data.Message;

import java.util.concurrent.SynchronousQueue;

public class MasterThread extends AbstractThread {

    public MasterThread(SynchronousQueue<Message> queue) {
        super(queue);
        setName("Master");
    }

    @Override
    protected void communicateLogic() throws InterruptedException {
        Message message;
        sendMessage(Message.PING); // send
        message = readMessage();   // receive
    }
}


// ===============================================================


package ru.home.geekbrains.threading;

import ru.home.geekbrains.threading.data.Message;
import java.util.concurrent.SynchronousQueue;

public class SlaveThread extends AbstractThread {

    public SlaveThread(SynchronousQueue<Message> queue) {
        super(queue);
        setName("Slave");
    }

    @Override
    protected void communicateLogic() throws InterruptedException {

        Message message;
        message = readMessage();   // receive
        sendMessage(Message.PONG); // send
    }
}





// ===============================================================




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ThreadingApplication {

    public static void main(String[] args) {
        SpringApplication.run(ThreadingApplication.class, args);
    }

}


// ===============================================================



package ru.home.geekbrains.threading;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import ru.home.geekbrains.threading.model.Storage;

@Component
public class ThreadApplicationRunner implements ApplicationRunner {


    @Override
    public void run(ApplicationArguments args) throws Exception {

        AbstractThread masterThread = new MasterThread(Storage.INSTANCE.getQueue());
        masterThread.start();

        AbstractThread slaveThread = new SlaveThread(Storage.INSTANCE.getQueue());
        slaveThread.start();
    }
}