/*
 *  Java Program to Implement Circular Doubly Linked List
 */

import java.util.Scanner;

/*  Class Node  */
class Node {
	protected int data;
	protected Node next, prev;

	/* Constructor */
	public Node() {
		next = null;
		prev = null;
		data = 0;
	}

	/* Constructor */
	public Node(int d, Node n, Node p) {
		data = d;
		next = n;
		prev = p;
	}

	/* Function to set link to next node */
	public void setLinkNext(Node n) {
		next = n;
	}

	/* Function to set link to previous node */
	public void setLinkPrev(Node p) {
		prev = p;
	}

	/* Function to get link to next node */
	public Node getLinkNext() {
		return next;
	}

	/* Function to get link to previous node */
	public Node getLinkPrev() {
		return prev;
	}

	/* Function to set data to node */
	public void setData(int d) {
		data = d;
	}

	/* Function to get data from node */
	public int getData() {
		return data;
	}
}

/* Class linkedList */
class linkedList {
	protected Node start;
	protected Node end;
	public int size;
	public int maxSize;

	/* Constructor */
	public linkedList() {
		start = null;
		end = null;
		size = 0;
		maxSize = 10;
	}

	/* Function to check if list is empty */
	public boolean isEmpty() {
		return start == null;
	}

	/* Function to check if list is full */
	public boolean isFull() {
		return size >= maxSize;
	}

	/* Function to get size of list */
	public int getSize() {
		return size;
	}

	/* Function to insert element at beginning */
	public void insertAtStart(int val) {
		if (size < maxSize) {
		Node nptr = new Node(val, null, null);
			if (start == null) {
				nptr.setLinkNext(nptr);
				nptr.setLinkPrev(nptr);
				start = nptr;
				end = start;
			} else {
				nptr.setLinkPrev(end);
				end.setLinkNext(nptr);
				start.setLinkPrev(nptr);
				nptr.setLinkNext(start);
				start = nptr;
			}
			size++;
		} else {
			System.out.println("\nSaraksts ir pilns! \n");
		}
	}

	/* Function to insert element at end */
	public void insertAtEnd(int val) {
		if (size < maxSize) {
			Node nptr = new Node(val, null, null);
			if (start == null) {
				nptr.setLinkNext(nptr);
				nptr.setLinkPrev(nptr);
				start = nptr;
				end = start;
			} else {
				nptr.setLinkPrev(end);
				end.setLinkNext(nptr);
				start.setLinkPrev(nptr);
				nptr.setLinkNext(start);
				end = nptr;
			}
			size++;
		} else {
			System.out.println("\nSaraksts ir pilns! \n");
		}
	}

	/* Function to insert element at position */
	public void insertAtPos(int val, int pos) {
		if (size < maxSize) {
			Node nptr = new Node(val, null, null);
			if (pos == 1) {
				insertAtStart(val);
				return;
			}
			Node ptr = start;
			for (int i = 2; i <= size; i++) {
				if (i == pos) {
					Node tmp = ptr.getLinkNext();
					ptr.setLinkNext(nptr);
					nptr.setLinkPrev(ptr);
					nptr.setLinkNext(tmp);
					tmp.setLinkPrev(nptr);
				}
				ptr = ptr.getLinkNext();
			}
			size++;
		} else {
			System.out.println("\nSaraksts ir pilns! \n");
		}
	}

	/* Function to delete node at position */
	public void deleteAtPos(int pos) {
		if (pos == 1) {
			if (size == 1) {
				start = null;
				end = null;
				size = 0;
				return;
			}
			start = start.getLinkNext();
			start.setLinkPrev(end);
			end.setLinkNext(start);
			size--;
			return;
		}
		if (pos == size) {
			end = end.getLinkPrev();
			end.setLinkNext(start);
			start.setLinkPrev(end);
			size--;
		}
		Node ptr = start.getLinkNext();
		for (int i = 2; i <= size; i++) {
			if (i == pos) {
				Node p = ptr.getLinkPrev();
				Node n = ptr.getLinkNext();
				p.setLinkNext(n);
				n.setLinkPrev(p);
				size--;
				return;
			}
			ptr = ptr.getLinkNext();
		}
	}

	/* Function to display status of list */
	public void display() {
		System.out.print("\nDivkāršsaistīts cirkulārs saraksts = ");
		Node ptr = start;
		if (size == 0) {
			System.out.print("Tukšs\n");
			return;
		}
		if (start.getLinkNext() == start) {
			System.out.print(start.getData() + " <-> " + ptr.getData() + "\n");
			return;
		}
		System.out.print(start.getData() + " <-> ");
		ptr = start.getLinkNext();
		while (ptr.getLinkNext() != start) {
			System.out.print(ptr.getData() + " <-> ");
			ptr = ptr.getLinkNext();
		}
		System.out.print(ptr.getData() + " <-> ");
		ptr = ptr.getLinkNext();
		System.out.print(ptr.getData() + "\n");
	}
}

/* Class CircularDoublyLinkedList */
public class Ld2_15 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		/* Creating object of linkedList */
		linkedList list = new linkedList();
		System.out.println("Reinis Rītiņš RDBI05 161RDB062");
		char ch;
		int choice = 0;

		/* Perform list operations */
		do {
			System.out.println("\nDivkāršsaistīta cirkulāra saraksta operācijas\n");
			System.out.println("1. Ievietot skaitli saraksta sākumā");
			System.out.println("2. Ievietot skaitli saraksta beigās");
			System.out.println("3. Ievietot skaitli sarakstā izvēlētajā pozīcijā");
			System.out.println("4. Izdzēst skaitli no izvēlētas pozīcijas sarakstā");
			System.out.println("5. Pārbaudīt, vai saraksts ir tukšs");
			System.out.println("6. Pārbaudīt, vai saraksts ir pilns");
			System.out.println("7. Pārbaudīt saraksta izmēru");

			if (scan.hasNextInt()) {
				choice = scan.nextInt();
			} else {
				choice = -1;
				scan.next();
			}
			switch (choice) {
			case 1:
				System.out.println("Ievadiet veselu skaitli, ko ievietot saraksta sākumā");
				if (scan.hasNextInt()) {
					list.insertAtStart(scan.nextInt());
					break;
				} else {
					System.out.println("Jums ir jāievada vesels skaitlis! \n ");
					scan.next();
					break;
				}
			case 2:
				System.out.println("Ievadiet veselu skaitli, ko ievietot saraksta beigās");
				list.insertAtEnd(scan.nextInt());
				break;
			case 3:
				System.out.println("Ievadiet veselu skaitli, ko ievietot sarakstā noteiktā pozīcijā");
				int num = scan.nextInt();
				System.out.println("Ievadiet pozīciju");
				int pos = scan.nextInt();
				if (pos < 1 || pos > list.getSize())
					System.out.println("Nepareiza pozīcija\n");
				else
					list.insertAtPos(num, pos);
				break;
			case 4:
				System.out.println("Ievadiet pozīciju");
				int p = scan.nextInt();
				if (p < 1 || p > list.getSize())
					System.out.println("Nepareiza pozīcija\n");
				else
					list.deleteAtPos(p);
				break;
			case 5:
				System.out.println("Vai saraksts ir tukšs? = " + list.isEmpty());
				break;
			case 6:
				if (list.isFull == true) {
					System.out.println("Vai saraksts ir pilns? = " + list.isFull());
				}
				break;
			case 7:
				System.out.println("Izmērs = " + list.getSize() + " \n");
				break;
			default:
				System.out.println("Nepareiza ievade. Lūdzu ievadiet skaitli no 1 līdz 7! \n ");
				break;
			}

			/* Display List */
			list.display();
            do {
                System.out.println("\nVai Jūs vēlaties turpināt? (Ievadiet J vai N) \n");
                ch = scan.next().charAt(0);
            } while(ch != 'n' && ch != 'N' && ch != 'j' && ch != 'J');
        } while (ch == 'J' || ch == 'j');
        scan.close();
	}
}