#include "LL2.h"
#include <iostream>
#include <cstring>
#include <assert.h>
#include <fstream>
using namespace std;

LL::LL()
{
  Head = NULL;
  Tail = NULL;
}


LL::LL(const LL & obj)
{
  Head = NULL;
  Tail = NULL;

  Node * p = obj.Head;
  while(p != NULL){
    InsertAtEnd(p->Item->Name, p->Item->Age);
    p = p->Next;
  }
}


LL::~LL()
{
  DestroyList();
}

void LL::SaveList(char * defFile)
{
  ofstream write;
  Node * curr = Head;
  write.open(defFile);
  if(!write)
  {
    cerr << "Error opening file...\n";
    return;
  }

  while (curr != NULL)
  {
    write << curr->Item->Name << "|" << curr->Item->Age << endl;
    curr = curr->Next;
  }
  write.close();
}

void LL::OpenFile(char * File)
{

  ifstream read;
  read.open(File);
  if(!read)
  {
    cerr << "Couldn't find the file.\n";
    return;
  }

  Node * temp;
  char * Name;
  int Age;

  while(read.peek() != EOF)
  {
    temp = new Node;
    Name = new char[35];
    read.get(Name, 35, '|');
    read.get();
    read >> Age;

    temp->Item = new ItemType(Name, Age);
    InsertNodeAtEnd(temp);
    read.ignore(100, '\n');
  }
  read.close();
}

void LL::InsertAtFront(char * Name, int Age)
{
  Node * newNode = new Node;
  newNode->Item = new ItemType(Name, Age);
  newNode->Next = NULL;
  newNode->Prev = NULL;
  InsertNodeAtFront(newNode);
}


void LL::InsertAtEnd(char * Name, int Age)
{
  Node * newNode = new Node;
  newNode->Item = new ItemType(Name, Age);
  newNode->Next = NULL;
  newNode->Prev = NULL;
  InsertNodeAtEnd(newNode);
}


void LL::InsertNodeAtFront(Node * newNode)
{
  newNode->Next = NULL;
  newNode->Prev = NULL;
  if (Head == NULL)
  {
    Head = newNode;
    Tail = newNode;
  }
  else
  {
    newNode->Next = Head;
    Head->Prev = newNode;
    Head = newNode;
  }
}


void LL::InsertNodeAtEnd(Node * newNode)
{
  newNode->Next = NULL;
  newNode->Prev = NULL;
  if (Head == NULL)
  {
    cout << "inserting at front...\n";
    Head = newNode;
    Tail = newNode;
    Head->Next = NULL;
    Head->Prev = NULL;
  }
  else
  {
    newNode->Prev = Tail;
    Tail->Next = newNode;
    Tail = newNode;
  }
}

void LL::Delete(char * Name, int Age)
{
  Node * delNode = new Node;
  delNode->Item = new ItemType(Name, Age);
  delNode->Next = NULL;
  delNode->Prev = NULL;
  DeleteNode(delNode);
}

void LL::DeleteNode(Node * delNode)
{
    Node * curr = SearchNode(delNode);

    if(curr == NULL)
    {
      cout << "Didn't find the info in the list.\n";
      return;
    }
    else
    {
      if (curr->Next == NULL)
      {
        cout << "node to delete was at the end of the list.\n";
        curr->Prev->Next = NULL;
        Tail = curr->Prev;
      }
      else if(curr->Prev == NULL)
      {
        cout << "node to delete was in the Head node.\n";
        Head = curr->Next;
        curr->Next->Prev = NULL;
      }
      else
      {
        cout << "node to delete was in the middle of the list somewhere.\n";
        curr->Prev->Next = curr->Next;
        curr->Next->Prev = curr->Prev;
      }
      delete curr->Item->Name;
      delete curr;
    }
}


void LL::DisplayNodes() const
{
  Node * curr;
  curr = Head;
  while (curr != NULL)
  {
    cout << curr->Item->Name << " " << curr->Item->Age << endl;
    curr = curr->Next;
  }
}

void LL::DestroyList()
{
  Node * curr, *prev;

  if (!Head)
  {
    return;
  }
  curr = Head;
  while(curr)
  {
    prev = curr;
    curr = curr->Next;
    delete prev;
    if (curr == NULL)
    {
      break;
    }
  }

  Head = NULL;
  Tail = NULL;
}

void LL::SortList_Ascend()
{
  Node * temp;
  Node * curr, * save;
  curr = save = Head;
  if (Head == NULL)
  {
    cout << "Linked list is empty\n";
    return;
  }
  else
  {
    for (curr = Head; (curr != NULL); curr = curr->Next)
    {
      for (save = curr->Next; (save != NULL); save = save->Next)
      {
        if (strcmp(curr->Item->Name, save->Item->Name) > 0)
        {
          temp = new Node;
          temp->Item = new ItemType(save->Item->Name, save->Item->Age);
          strcpy(save->Item->Name, curr->Item->Name);
          save->Item->Age = curr->Item->Age;
          strcpy(curr->Item->Name, temp->Item->Name);
          curr->Item->Age = temp->Item->Age;
        }
      }
    }
    cout << "The linked list is now sorted in ascending order!\n";
  }
}

void LL::SortList_Descend()
{
  Node * temp;
  Node * curr, * save;
  curr = save = Head;
  if (Head == NULL)
  {
    cout << "Linked list is empty\n";
    return;
  }
  else
  {
    for (curr = Head; (curr != NULL); curr = curr->Next)
    {
      for (save = curr->Next; (save != NULL); save = save->Next)
      {
        if (strcmp(curr->Item->Name, save->Item->Name) < 0)
        {
          temp = new Node;
          temp->Item = new ItemType(save->Item->Name, save->Item->Age);
          strcpy(save->Item->Name, curr->Item->Name);
          save->Item->Age = curr->Item->Age;
          strcpy(curr->Item->Name, temp->Item->Name);
          curr->Item->Age = temp->Item->Age;
        }
      }
    }
    cout << "The linked list is now sorted in descending order!\n";
  }
}


void LL::ReverseList()
{
  Node * temp;
  Node * curr, * save;
  curr = save = Head;
  if (Head == NULL)
  {
    cout << "The linked list is empty.\n";
    return;
  }
  else
  {
    save = NULL;
    while (curr != NULL)
    {
      temp = save;
      save = curr;
      curr = curr->Next;
      save->Next = temp;
    }
    Head = save;
    cout << "The linked list is now reversed!\n";
  }
}


LL::Node * LL::Search(char * Name, int Age)
{
  Node * srchNode = new Node;
  srchNode->Item = new ItemType(Name, Age);
  srchNode->Next = NULL;
  srchNode->Prev = NULL;
  SearchNode(srchNode);
}

LL::Node * LL::SearchNode(Node * srchNode)
{
  Node * curr;
  if(Head == NULL)
  {
    cout << "The list is empty\n";
  }
  else
  {
    cout << "head is not NULL...searching...\n";
    curr = Head;
    while(curr != NULL)
    {
      if((strcmp(curr->Item->Name, srchNode->Item->Name)==0) &&
                (curr->Item->Age == srchNode->Item->Age))
      {
        cout << "Found the info in the list...\n";
        break;
      }
      curr = curr->Next;
    }

    if(curr != NULL)
    {
      return curr;
    }
    else
    {
      cout << "Info not in the list.\n";
      return NULL;
    }
  }
}