/*

  This Source Code Form is subject to the terms of the Mozilla Public

  License, v. 2.0. If a copy of the MPL was not distributed with this

  file, You can obtain one at http://mozilla.org/MPL/2.0/.

  Copyright (C) 2011 Michael Möller <mmoeller@openhardwaremonitor.org>

*/

using System;

using System.Collections;

using System.Collections.Generic;

namespace OpenHardwareMonitor.Collections {

  public class RingCollection<T> : IEnumerable<T> {

    private T[] array;

    // first item of collection

    private int head;

    // index after the last item of the collection

    private int tail;

    // number of items in the collection

    private int size;

    public RingCollection() : this(0) { }

    public RingCollection(int capacity) {

      if (capacity < 0)

        throw new ArgumentOutOfRangeException("capacity");

      this.array = new T[capacity];

      this.head = 0; 

      this.tail = 0;

      this.size = 0;

    }

    public int Capacity {

      get {

        return array.Length;

      }

      set {

        T[] newArray = new T[value];

        if (size > 0) {

          if (head < tail) {

            Array.Copy(array, head, newArray, 0, size);

          } else {

            Array.Copy(array, head, newArray, 0, array.Length - head);

            Array.Copy(array, 0, newArray, array.Length - head, tail);

          }

        }

        this.array = newArray;

        this.head = 0;

        this.tail = size == value ? 0 : size;

      }

    }

    public void Clear() {

      // remove potential references 

      if (head < tail) {

        Array.Clear(array, head, size);

      } else {

        Array.Clear(array, 0, tail);

        Array.Clear(array, head, array.Length - head);

      }

      this.head = 0;

      this.tail = 0;

      this.size = 0;

    }

    public void Append(T item) {

      if (size == array.Length) {

        int newCapacity = array.Length * 3 / 2;

        if (newCapacity < array.Length + 8)

          newCapacity = array.Length + 8;

        Capacity = newCapacity;

      }

      array[tail] = item;

      tail = tail + 1 == array.Length ? 0 : tail + 1;

      size++;

    }

    public T Remove() {

      if (size == 0)

        throw new InvalidOperationException();

      T result = array[head];

      array[head] = default(T);

      head = head + 1 == array.Length ? 0 : head + 1;

      size--;

      return result;

    }

    public int Count {

      get {

        return size;

      }

    }

    public T this[int index] {

      get {

        if (index < 0 || index >= size)

          throw new IndexOutOfRangeException();

        int i = head + index;

        if (i >= array.Length)

          i -= array.Length;

        return array[i];

      }

      set {

        if (index < 0 || index >= size)

          throw new IndexOutOfRangeException();

        int i = head + index;

        if (i >= array.Length)

          i -= array.Length;

        array[i] = value;

      }

    }

    public T First {

      get {

        if (size == 0)

          throw new InvalidOperationException();

        return array[head];

      }

      set {

        if (size == 0)

          throw new InvalidOperationException();

        array[head] = value;

      }

    }

    public T Last {

      get {

        if (size == 0)

          throw new InvalidOperationException();

        return array[tail == 0 ? array.Length - 1 : tail - 1];

      }

      set {

        if (size == 0)

          throw new InvalidOperationException();

        array[tail == 0 ? array.Length - 1 : tail - 1] = value;

      }

    }

    IEnumerator<T> IEnumerable<T>.GetEnumerator() {

      return new RingCollection<T>.Enumerator(this);

    }

    IEnumerator IEnumerable.GetEnumerator() {

      return new RingCollection<T>.Enumerator(this);

    }

    private struct Enumerator : IEnumerator<T>, IEnumerator {

      private RingCollection<T> collection;

      private int index;

      public Enumerator(RingCollection<T> collection) {

        this.collection = collection;

        this.index = -1;

      }

      public void Dispose() {

        this.index = -2;

      }

      public void Reset() {

        this.index = -1;

      }

      public T Current {

        get {

          if (index < 0)

            throw new InvalidOperationException();

          return collection[index];

        }

      }

      object IEnumerator.Current {

        get {

          if (index < 0)

            throw new InvalidOperationException();

          return collection[index];

        }

      }

      public bool MoveNext() {

        if (index == -2)

          return false;

        index++;

        if (index == collection.size) {

          index = -2;

          return false;

        }

        return true;

      }

    }

  }

}