package appointmentplanner.customlist;

import java.util.Iterator;

import appointmentplanner.customlist.api.CustomLinkedList;

public class CustomLinkedListImpl<T> implements CustomLinkedList<T> {

  CustomLinkedListNode<T> head = null;

  @Override
  public Iterator<T> iterator() {
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException("Unimplemented method 'iterator'");
  }

  @Override
  public void add(T item) {
    CustomLinkedListNode<T> newNode = new CustomLinkedListNode<>(item);

    CustomLinkedListNode<T> oldHead = head;

    head = newNode;

    if (oldHead != null) {
      head.setNext(oldHead);
    }
  }

  private static enum ItemPosition {
    AFTER, BEFORE, CURRENT
  }

  private CustomLinkedListNode<T> traverseFind(CustomLinkedListNode<T> currentNode, T item, ItemPosition position) {

    CustomLinkedListNode<T> nextNode = currentNode.getNext();

    switch (position) {

      case CURRENT:

        if (currentNode.getItem().equals(item)) {
          return currentNode;
        }

        break;

      case BEFORE:

        if (nextNode == null) {
          return null;
        }

        if (nextNode.getItem().equals(item)) {
          return currentNode;
        }

        break;

      case AFTER:

        if (nextNode == null) {
          return null;
        }

        if (currentNode.getItem().equals(item)) {
          return nextNode;
        }

        break;

      default:
        return null;
    }

    if (nextNode == null) {
      return null;
    }

    return traverseFind(nextNode, item, position);
  }

  @Override
  public void remove(T item) {

    CustomLinkedListNode<T> nodeToRemove = traverseFind(head, item, ItemPosition.CURRENT);

    if (nodeToRemove == null) {
      return;
    }

    if (nodeToRemove == head) {
      head = head.getNext();
      return;
    }

    CustomLinkedListNode<T> beforeNode = traverseFind(head, item, ItemPosition.BEFORE);

    if (nodeToRemove.getNext() == null) {
      beforeNode.setNext(null);
      return;
    }

    beforeNode.setNext(nodeToRemove.getNext());

  }

  @Override
  public void insertAfter(T reference, T item) {
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException("Unimplemented method 'insertAfter'");
  }

  @Override
  public void insertBefore(T reference, T item) {
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException("Unimplemented method 'insertBefore'");
  }

  @Override
  public T getAfter(T reference) {

    // head represents the last inserted item thus making enrire list in reverse
    // order
    CustomLinkedListNode<T> node = traverseFind(head, reference, ItemPosition.BEFORE);
    return node == null ? null : node.getItem();
  }

  @Override
  public T getBefore(T reference) {

    // head represents the last inserted item thus making enrire list in reverse
    // order
    CustomLinkedListNode<T> node = traverseFind(head, reference, ItemPosition.AFTER);
    return node == null ? null : node.getItem();
  }

  @Override
  public boolean contains(T item) {
    return traverseFind(head, item, ItemPosition.CURRENT) != null ? true : false;
  }

  private int recursiveSizeCalc(CustomLinkedListNode<T> node, int count) {
    if (node == null) {
      return 0;
    }

    if (node.getNext() == null) {
      return count;
    }

    return recursiveSizeCalc(node.getNext(), count + 1);

  }

  @Override
  public int size() {
    return recursiveSizeCalc(this.head, 1);
  }

}