#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <algorithm>
#include <sstream>


using namespace std;


class Node {
public:
    float val;
    Node *prev;
    Node *next;
    Node() {
        prev = nullptr;
        next = nullptr;
    }
    ~Node() {}
};


class List {
private:
    std::fstream file;
    Node *head, *tail;
    int count = 0;




public:
    List() {
        head = nullptr;
        tail = nullptr;


    }
    ~List() {
        Node* current = head;
        Node* next;

        while (current)
        {
            next = current->next;
            delete current;
            current = next;
        }

        head = nullptr;
    }

    void push_front(float v)
    {
        Node * p;

        p = new Node;
        p->val = v;
        p->prev = NULL;
        p->next = head;
        head = p;
        count++;
        if (p->next) p->next->prev = p;
        else tail = p;
    }

    void push_back(float v)
    {
        Node * p;

        p = new Node;
        p->val = v;
        p->next = NULL;
        p->prev = tail;
        tail = p;
        count++;
        if (p->prev) p->prev->next = p;
        else head = p;
    }
    void remove(Node * e)
    {
        count--;
        if (e->prev) e->prev->next = e->next;
        else        head = e->next;
        if (e->next) e->next->prev = e->prev;
        else        tail = e->prev;
        delete e;
    }

    void pop_front()
    {
        if (count) remove(head);
    }


    void pop_back()
    {
        if (count) remove(tail);
    }
    void partition(Node * Lw, Node * Pw)
    {
        Node * p, *i, *j;

        p = Lw->next;      // piwot
        i = p->next;
        if (i != Pw)
        {
            do            // szukamy elementów mniejszych od piwota
            {
                j = i;
                i = i->next;
                if (j->val < p->val)
                {
                    j->prev->next = j->next; // znaleziony element wyciagamy z listy
                    j->next->prev = j->prev;
                    j->next = p;             // i umieszczamy go przed piwotem
                    j->prev = p->prev;
                    p->prev = j;
                    j->prev->next = j;
                }
            } while (i != Pw);

            if (Lw->next != p) partition(Lw, p);
            if (p->next != Pw) partition(p, Pw);

        }
    }

    void quick_sort()
    {
        if (count > 1)
        {
            push_front(0);        // dodajemy lewego wartownika
            push_back(0);         // dodajemy prawego wartownika
            partition(head, tail); // tworzymy partycje
            pop_back();           // usuwamy prawego wartownika
            pop_front();          // usuwamy lewego wartownika
        }
    }

    void insertFromFile(int min, int max, std::string name) {

        file.open(name + ".txt");

        //to sprawdzenie to tymczasowe, trzeba chyba na asercje zmienic\/\/
        if (file.good())
        {
            cout << "Otwarto plik\n";
        }
        else
        {
            cout << "Nie mozna otworzyc\n";
        }
        //asercja, zeby sprawdzalo czy plik sie otworzyl i czy nazwa podana istnieje w katalogu

        float value;


        while (file>>value) { //zmienilem warunek bo mi dublowalo ostatnią  wartość z pliku

            //tutaj asercje, zeby sprawdzalo czy za wczesnie nie zostal osiagniety koniec pliku (podany zakres wiekszy niz ilosc liczb w pliku)
            //mozna np. najpierw policzyc ilosc liczb w pliku i porownac z range ale to nie jest hehe optymalne
            //no albo na biezaco sprawdzac czy sie zgadza
            //if (file.eof()) break;

            Node* newValue = new Node;


            if (value <= max && value >= min) {
                /*if (!head)
                {
                    this->count++;
                    head = newValue;
                    newValue->prev = nullptr;
                    newValue->val = value;
                    newValue->next = nullptr;
                    tail = newValue;
                }
                else
                {
                    this->count++;
                    newValue->next = head;
                    newValue->val = value;
                    newValue->prev = nullptr;
                    head->prev = newValue;
                    head = newValue;
                }*/
                this->push_front(value); //dodalem funkcje dodawania, potrzebna byla w sorcie, także góra do wywalenia
            }
        }
        //jak zwolnic pamiec po tym newValue??? bo juz sie wkurwiam ^^
        //delete[] newValue chyba, ale nie wiem xD
        file.close();


        cout << "\nPrzed sortowaniem: \n";
        this->printFromLeft();
        quick_sort();
        cout << "Posortowano quick sort'em: \n";

    }
    void printFromLeft() {

        Node* temp;
        temp = head;
        std::cout << "Lista od lewej:" << std::endl;
        while (temp)
        {
            std::cout << temp->val << std::endl;
            temp = temp->next;
        }
        std::cout << std::endl;


    }
    void printFromRight() {
        Node* temp;
        temp = tail;
        std::cout << "Lista od prawej:" << std::endl;
        while (temp)
        {
            std::cout << temp->val << std::endl;
            temp = temp->prev;
        }
        std::cout << std::endl;
    }

};



//parametry programu wpisane w formacie: "nazwa pliku" min max
int main(int argc, char *argv[]) {

    int val_min, val_max;
    if (argc >= 3)
    {
        std::istringstream iss(argv[2]);

        if (iss >> val_min) {}

        std::istringstream iss2(argv[3]);

        if (iss2 >> val_max) {}
    }
    cout << "Zakres: " << val_min << " - " << val_max << endl;
    List list;
    list.insertFromFile(val_min ,val_max, argv[1]);
    list.printFromLeft();
    list.printFromRight();



    system("pause");
    return 0;
}