/// Definition for singly-linked list.
public class ListNode<ValueType> {
  public var val: ValueType?
  public var next: ListNode?
  public let id = UUID()
  public init(_ val: ValueType?) {
    self.val = val
    self.next = nil
  }
}

class RingBuffer<ValueType> {

  private var writeNode: ListNode<ValueType>
  private var readNode: ListNode<ValueType>

  init?(size: Int) {
    guard size > 1 else { return nil }

    let headNode = ListNode<ValueType>(nil)
    var currentNode: ListNode = headNode

    for _ in 1..<size {
      currentNode.next = ListNode(nil)
      currentNode = currentNode.next!
    }
    currentNode.next = headNode

    writeNode = headNode
    readNode = headNode
  }

  func insert(val: ValueType) {
    if writeNode.val != nil { // overwrite val
      readNode = writeNode.next!
    }
    writeNode.val = val
    writeNode = writeNode.next!
  }

  func pop() -> ValueType? {
    if let val = readNode.val {
      readNode.val = nil
      readNode = readNode.next!
      return val
    } else {
      return nil
    }
  }

  func getBufferString() -> String {
    var currentNode = readNode
    var bufferString = ""

    repeat {
      if !bufferString.isEmpty { bufferString += "->" }
      let val = currentNode.val == nil ? "EMPTY" : "\(currentNode.val!)"
      bufferString += val
      currentNode = currentNode.next!
    } while currentNode.id != readNode.id

    bufferString += "⏎"

    return bufferString
  }

  func currentBuffer() -> ValueType? {
    return readNode.val
  }

  func nextBuffer() -> ValueType? {
    return readNode.next!.val
  }

}