package week2;

import java.util.Random;
import java.util.stream.IntStream;

public class Week2 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Starting");

        Data data = new Data();

        Thread t1 = new Thread(new NumberProducer(data, 1, 50), "Generator_1_50");
        Thread t2 = new Thread(new NumberProducer(data, 100, 500), "Generator_100_500");
        Thread t3 = new Thread(new NumberConsumer(data), "NumberConsumer");
        Thread t4 = new Thread(new MyLogger(data, t1, t2, t3), "Logger");
        t4.setDaemon(true);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

        Thread.sleep(30_000);

        t1.interrupt();
        t2.interrupt();
        t3.interrupt();

        System.out.println("Done");
    }

    static class Data {
        private volatile Integer number = null;

        public Integer getNumber(){
            return number;
        }

        public synchronized Integer read() throws InterruptedException {
            while (number == null) {
                wait();
            }

            var tmp = number;
            number = null;
            notifyAll();

            return tmp;
        }

        public synchronized void write(Integer number) throws InterruptedException {
            while (this.number != null) {
                wait();
            }

            this.number = number;
            notifyAll();
        }
    }

    static class NumberProducer implements Runnable {
        private Data data;
        private Integer lowerBound;
        private Integer upperBound;
        private Random random;

        public NumberProducer(Data data, Integer lowerBound, Integer upperBound) {
            this.data = data;
            this.lowerBound = lowerBound;
            this.upperBound = upperBound;
            random = new Random();
        }

        @Override
        public void run() {
            try {
                while (true) {
                    var number = random.nextInt(upperBound - lowerBound) + lowerBound + 1;
                    data.write(number);
                }
            } catch (InterruptedException e) {
                System.err.println("[" + Thread.currentThread().getName() + "] interrupted");
                Thread.currentThread().interrupt();
            }
        }
    }

    static class NumberConsumer implements Runnable {

        private Data data;

        public NumberConsumer(Data data) {
            this.data = data;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    var number = data.read();
                    System.out.println("[" + Thread.currentThread().getName() + "] - " + IntStream.rangeClosed(1, number).sum());
                    Thread.sleep(1_000);
                }
            } catch (InterruptedException e) {
                System.err.println("[" + Thread.currentThread().getName() + "] interrupted");
                Thread.currentThread().interrupt();
            }
        }
    }

    static class MyLogger implements Runnable {

        private Data data;
        private Thread[] threads;

        public MyLogger(Data data, Thread... threads) {
            this.data = data;
            this.threads = threads;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("Number: " + data.getNumber());
                    for (var thread : threads) {
                        System.out.println("[" + thread.getName() + "] " + thread.getState());
                    }
                    System.out.println("===================");
                    Thread.sleep(1_000);
                }
            } catch (InterruptedException e) {
                throw new IllegalStateException(e);
            }
        }
    }
}