using System;

public class Program

{

    public static void Main()

    {

        // TODO try to break it here...

        RingBuffer<int> testBuf = new RingBuffer<int>(5);

        testBuf.PushFront(1);

        testBuf.PushBack(0);

        // should be 5,4,3,2,1

        while(testBuf.Count > 0) {

            Console.WriteLine(testBuf.PopBack());   

        }

        Console.WriteLine("=============");

        testBuf.PushFront(1);

        testBuf.PushFront(2);

        testBuf.PushFront(3);

        testBuf.PushFront(4);

        testBuf.PushFront(5);

        testBuf.PushFront(6);

        testBuf.PushFront(7);

        // should be 7,6,5,4,3

        while(testBuf.Count > 0) {

            Console.WriteLine(testBuf.PopFront());  

        }

        Console.WriteLine("=============");

        testBuf.PushFront(1);

        testBuf.PushFront(2);

        testBuf.PushFront(3);

        testBuf.PushFront(4);

        testBuf.PushFront(5);

        testBuf.PushBack(-1);

        testBuf.PushBack(-2);

        // should be 3,2,1,-1,-2

        while(testBuf.Count > 0) {

            Console.WriteLine(testBuf.PopBack());   

        }

        Console.WriteLine("=============");

    }

}

​

​

public class RingBuffer<T>  {

​

    T[] Array;

    int MaxCap;

    int count;

    int FrontIndex = -1;

    int BackIndex = -1;

​

    // create private variables to solve

    public RingBuffer(int capacity) {

        Array = new T[capacity];

        MaxCap = capacity;

    }

​

    /// Adds this entry to the front of the buffer

    public void PushFront2(T val) {

        if(count != MaxCap){

            if(FrontIndex != count-1){

                //Console.WriteLine("Writing at " + FrontIndex);

                Array[FrontIndex+1] = val;

                FrontIndex++;

                count++;

            }else{

                //Console.WriteLine("Writing looparound at 0");

                FrontIndex = 0;

                BackIndex++;

                Array[0] = val;

                count++;

            }

        }else{

            //Console.WriteLine("Writing full looparound at 0");

            BackIndex++;

            FrontIndex = 0;

            Array[0] = val;

        }

    }

    public void PushFront(T val) {

        FrontIndex++;

        if(FrontIndex == MaxCap) FrontIndex = 0;

        if(FrontIndex == BackIndex) BackIndex++;

        if(BackIndex == MaxCap || BackIndex == -1) BackIndex = 0;

        Array[FrontIndex] = val;

        if(count < MaxCap) count ++;

    }

    public void PushBack(T val) {

        BackIndex--;

        if(BackIndex < 0)

            BackIndex = MaxCap - 1;

        if(FrontIndex == BackIndex)

            FrontIndex--;

        if(FrontIndex < 0)

            FrontIndex = MaxCap - 1;

        Array[BackIndex] = val;

        if(count != MaxCap)

            count++;

    }

​

    /// Gets the Front entry of the buffer

    public T Front() {

        if(count == 0)

            throw new System.Exception("Can't access an empty array");

        return Array[FrontIndex];

    }

    /// Removes the Front entry from the buffer, and returns it

    public T PopFront() {

        if(count == 0)

            throw new System.Exception("Can't access an empty array");

        if(FrontIndex != 0){

            //Console.WriteLine("Popping at " + FrontIndex);

            FrontIndex--;

            count--;

            return Array[FrontIndex+1];

        }else{

            //Console.WriteLine("Popping2 at " + FrontIndex);

            FrontIndex = count-1;

            count--;

            return Array[0];

        }

    }

    public T PopBack() {

        if(count == 0)

            throw new System.Exception("Can't access an empty array");

        T val = Array[BackIndex];

        if(FrontIndex==BackIndex) {

            BackIndex = -1;

            FrontIndex = -1;

        } else {

            BackIndex++;

            if(BackIndex >= MaxCap) BackIndex = 0;

        }

        count--;

        return val;

    }

​

    /// Adds this entry to the back of the buffer

    public void PushBack2(T val) {

        if(BackIndex != 0){

            BackIndex--;

            Array[BackIndex] = val;

        }else{

            BackIndex = FrontIndex+1;

            Array[0] = val;

            count++;

        }

    }

    /// Gets the Back entry of the buffer

    public T Back() {

        if(count == 0)

            throw new System.Exception("Can't access an empty array");

        return Array[BackIndex];

    }

    //TODO - implement

    ///      resets the buffer back to start state

    public void Clear() {

        FrontIndex = -1;

        BackIndex = -1;

    }

    /// <summary>

    /// At the specified 0-based index from Front.  At(0) is the Front.  At(Count-1) is the Back.

    /// 

    /// </summary>

    /// <param name="index">Index.</param>

    public T At(int index) {

        if(index >= count)

            throw new System.IndexOutOfRangeException();

        return Array[index];

    }

​

    /// <summary>

    /// Gets the count of entries in the buffer

    /// </summary>

    /// <value>The count.</value>

    public int Count {

        get {

            return count;

        }

    }

}