/*
 
  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;
      }
    }
  }
}