#include <iostream>
#include "ListT.h"

using namespace std;

struct NodeT {
    int data;
    NodeT * next;
};

ListT::ListT(){
    size = 0;
    head = nullptr;
    current = nullptr;
}

void DeleteList(NodeT * &  head) {
    NodeT * tmp;

    while(head != nullptr) {
       tmp   = head;
       head = head->next;
       delete tmp;
    }
}

NodeT * CopyList(NodeT * src){
    NodeT * travel{nullptr};
    NodeT * tmp{nullptr};
    NodeT * tail{nullptr};
    NodeT * head{nullptr};

    while (travel != nullptr) {
        tmp = new NodeT;
        tmp->data = travel->data;
        tmp ->next = nullptr;
        if (head == nullptr) {
            head = tmp;
        } else {
            tail->next = tmp;
        }
        tail = tmp;
        travel=travel->next;
    }

    return head;
}

ListT & ListT::operator =(const ListT & src){

    if (this != &src) {
        size = src.size;
        DeleteList(head);
        head = CopyList(src->head);
    }

    return *this;
}

ListT::ListT(const ListT & src) {

    head = nullptr;
    travel = src.head;
    head = CopyList(src.head);
    size = src.size;
}


ListT::~ListT(){
    DeleteList(head);
}

void ListT::Insert(int i){
    NodeT * tmp{nullptr};
    NodeT * seek{nullptr}, 
          * tail{nullptr};

    tmp = new(NodeT);
    tmp->data = i;
    tmp->next = nullptr;
    size++;

    if (head == nullptr or head->data > i) {
        tmp->next = head;
        head = tmp;
    } else {
        seek = head->next;
        tail = head;
        while (seek != nullptr and seek->data < i) {
           tail = seek;
           seek = seek->next;
        }
        tail ->next = tmp;
        tmp->next = seek;
    }
}
/*
void ListT::Delete2(int i) {
    NodeT * tmp{nullptr};
    NodeT * seek{nullptr},
          * tail{nullptr};
   
    if (head != nullptr) {
       if (head->data == i) {
          tmp = head;
          head = head->next;
          delete tmp;
          size--;
       } else {
          tail = head;
          seek = tail->next;

          while( seek != nullptr and seek->data != i){
              tail = seek;
              seek = seek->next;
          }
         
          if(seek != nullptr) { 
              tail->next = seek->next;
              delete seek;
              size--;
          }
           
       }
   }
}
*/

void ListT::Delete(int i){
    NodeT * tmp,
          *tail;

    if (head != nullptr) {
       if (head->data == i) {
          tmp = head;
          head = tmp->next;
          delete tmp;
          size --;
       } else {
          tmp = head->next;
          tail = head;
          while(tmp != nullptr and tmp->data != i) {
             tail = tmp;
             tmp = tmp->next;
          }
          if (tmp != nullptr) {
              tail->next = tmp->next;
              delete tmp;
              size--;
          }
       }
      
    }
}

bool ListT::IsPresent(int i){
    NodeT * tmp{head};
    //tmp = head;
    while (tmp != nullptr and tmp->data != i) {
        tmp = tmp -> next;
    }
    
    return tmp != nullptr;
}


int ListT::Size(){
     return size;
}


void ListT::Home(){
    current = head;
}

bool ListT::IsLast(){
    return current == nullptr;
}

void ListT::Next(){
    if (current != nullptr) {
       current = current->next;
    }
}

int ListT::Current(){
    if (current != nullptr) {
       return current->data;
    }
    return -1;
}