package DataStructures.Buffers;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

public class CircularBuffer {
  private char[] _buffer;
  public final int _buffer_size;
  private int _write_index = 0;
  private int _read_index = 0;
  private AtomicInteger _readable_data = new AtomicInteger(0);

  public CircularBuffer(int buffer_size) {
    if (!IsPowerOfTwo(buffer_size)) {
      throw new IllegalArgumentException();
    }
    this._buffer_size = buffer_size;
    _buffer = new char[buffer_size];
  }

  private boolean IsPowerOfTwo(int i) {
    return (i & (i - 1)) == 0;
  }

  private int getTrueIndex(int i) {
    return i % _buffer_size;
  }

  public Character readOutChar() {
    Character result = null;

    // if we have data to read
    if (_readable_data.get() > 0) {

      result = Character.valueOf(_buffer[getTrueIndex(_read_index)]);
      _readable_data.decrementAndGet();
      _read_index++;
    }

    return result;
  }

  public boolean writeToCharBuffer(char c) {
    boolean result = false;

    // if we can write to the buffer
    if (_readable_data.get() < _buffer_size) {
      // write to buffer
      _buffer[getTrueIndex(_write_index)] = c;
      _readable_data.incrementAndGet();
      _write_index++;
      result = true;
    }

    return result;
  }

  private static class TestWriteWorker implements Runnable {
    String _alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
    Random _random = new Random();
    CircularBuffer _buffer;

    public TestWriteWorker(CircularBuffer cb) {
      this._buffer = cb;
    }

    private char getRandomChar() {
      return _alphabet.charAt(_random.nextInt(_alphabet.length()));
    }

    public void run() {
      while (!Thread.interrupted()) {
        if (!_buffer.writeToCharBuffer(getRandomChar())) {
          Thread.yield();
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            return;
          }
        }
      }
    }
  }

  private static class TestReadWorker implements Runnable {
    CircularBuffer _buffer;

    public TestReadWorker(CircularBuffer cb) {
      this._buffer = cb;
    }

    @Override
    public void run() {
      System.out.println("Printing Buffer:");
      while (!Thread.interrupted()) {
        Character c = _buffer.readOutChar();
        if (c != null) {
          System.out.print(c.charValue());
        } else {
          Thread.yield();
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            System.out.println();
            return;
          }
        }
      }
    }
  }

  public static void main(String[] args) throws InterruptedException {
    int buffer_size = 1024;
    // create circular buffer
    CircularBuffer cb = new CircularBuffer(buffer_size);

    // create threads that read and write the buffer.
    Thread write_thread = new Thread(new TestWriteWorker(cb));
    Thread read_thread = new Thread(new TestReadWorker(cb));
    read_thread.start();
    write_thread.start();

    // wait some amount of time
    Thread.sleep(10000);

    // interrupt threads and exit
    write_thread.interrupt();
    read_thread.interrupt();
  }
}