#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
#include <vector>
#include <Python.h>

using namespace std;



//  czyszczenie ekranu dla Windows/Linux/Unix/macOS
void clear_screen()
{
#if defined(_WIN32) || defined(_WIN64)
    system("cls");
#elif defined(__linux__) || defined(__unix__) || defined(__APPLE__)
    system("clear");
#endif
}


//  znaczniki stanu programu
enum class Stan
{
    menu,
    dodaj_zadanie,
    dodaj_kategorie,
    lista,
    wizualizacja,
    zakoncz
};
enum class Dane
{
    poprawne,
    bledne
};


//  klasy
class Zadanie
{
public:
    string tresc;
    string data;
    int dzien, miesiac, rok;
    bool zakonczone = false;
    //  konstruktor
    Zadanie() {}
    Zadanie(string _tresc, string _data)
    {
        tresc = _tresc;
        data = _data;

        string data_dane = "";
        //  DD-**-**
        data_dane = data.substr(0, 2);
        dzien = stoi(data_dane);
        //  **-MM-**
        data_dane = data.substr(3, 2);
        miesiac = stoi(data_dane);
        //  **-**-RR
        data_dane = data.substr(6, 2);
        rok = stoi(data_dane);
    }

    //  metody
    void zmien_date(string nowa_data)
    {
        data = nowa_data;
    }
    void odznacz_zadanie()
    {
        if (zakonczone)
        {
            zakonczone = false;
        }
        else
        {
            zakonczone = true;
        }
    }
    string zwroc_znacznik()
    {
        if (zakonczone)
        {
            return "x";
        }
        else
        {
            return " ";
        }
    }
};

class Kategoria: public Zadanie
{
public:
    string nazwa;
    vector<Zadanie> kategoria;
    //  konstruktor
    Kategoria(string _nazwa)
    {
        nazwa = _nazwa;
    }

    //  metody
    void dodaj_zadanie(Zadanie zadanie)
    {
        if (kategoria.size() == 0)
        {
            kategoria.push_back(zadanie);
        }
        else
        {
            //  ustawienie zadan uporzadkowanych od najwczesniejszego
            for (int i = 0; static_cast<size_t>(i) < kategoria.size(); i++)
            {
                if ((zadanie.rok < kategoria[i].rok)
                    || ((zadanie.rok == kategoria[i].rok) && (zadanie.miesiac < kategoria[i].miesiac))
                    || ((zadanie.rok == kategoria[i].rok) && (zadanie.miesiac == kategoria[i].miesiac) && (zadanie.dzien <= kategoria[i].dzien)))
                {
                    kategoria.insert(kategoria.begin() + i, zadanie);
                    break;
                }
                else if (static_cast<size_t>(i) == kategoria.size() - 1)
                {
                    kategoria.push_back(zadanie);
                    break;
                }
            }
        }
    }
    void usun_zadanie(int wybor)
    {
        kategoria.erase(kategoria.begin() + wybor);
    }
};


//  funkcje do obslugi interface'u
void wyswietl_menu(Dane dane)
{
    clear_screen();

    if (dane == Dane::poprawne)
    {
        cout << "Twoja lista zadan To-Do\n\n";
        cout << "1: Dodaj nowe zadanie\n";
        cout << "2: Dodaj nowa kategorie\n";
        cout << "3: Sprawdz liste zadan\n";
        cout << "4: Otworz wizualizacje\n";
        cout << "5: Zakoncz\n";

        cout << "\nCo chcesz wykonac? ";
    }
    else if (dane == Dane::bledne)
    {
        cout << "Niepoprawna akcja, wprowadz dane ponownie zgodnie z podanymi mozliwosciami [1, 2, 3, 4, 5].\n\n";

        cout << "1: Dodaj nowe zadanie\n";
        cout << "2: Dodaj nowa kategorie\n";
        cout << "3: Sprawdz liste zadan\n";
        cout << "4: Otworz wizualizacje\n";
        cout << "5: Zakoncz\n";

        cout << "\nWykonaj: ";
    }
}

void wyswietl_wybor_kategorii(vector<Kategoria> katalogi)
{
    clear_screen();
    cout << "[0: powrot do menu]\n\n";

    for (int i = 0; static_cast<size_t>(i) < katalogi.size(); i++)
    {
        cout << i + 1 << ". " << katalogi[i].nazwa << endl;
    }

    cout << "\nDo ktorej kategorii chcesz dodac nowe zadanie? ";
}

void wyswietl_dodawanie_zadania(vector<Kategoria> katalogi, int wybor)
{
    clear_screen();
    cout << "[0: powrot do menu]\n\n";

    cout << "Dodawanie zadania w kategorii: " << katalogi[wybor].nazwa;
}

void wyswietl_liste_zadan(vector<Kategoria> katalogi)
{
    clear_screen();
    cout << "[0: powrot do menu]\n\n";

    for (int i = 0; static_cast<size_t>(i) < katalogi.size(); i++)
    {
        cout << "\n\n";
        cout << i + 1 << ". " << katalogi[i].nazwa << ":";
        
        for (int j = 0; static_cast<size_t>(j) < katalogi[i].kategoria.size(); j++)
        {
            cout << "\n\t(" << j + 1 << ") [" << katalogi[i].kategoria[j].zwroc_znacznik() << "] " << katalogi[i].kategoria[j].data << "\t" << katalogi[i].kategoria[j].tresc;
        }
    }
}


//  zapis do plikow
void zapisz_liste_txt(vector<Kategoria> katalogi, string plik_txt)
{
    ofstream outFile(plik_txt, ofstream::trunc);

    if (outFile.is_open())
    {
        outFile << "<!DOCTYPE html>" << endl;
        outFile << "<html>" << endl;
        outFile << "<head>" << endl;
        outFile << "<title>To-Do</title>" << endl;
        outFile << "<link rel=\"icon\" type=\"image/x-icon\" href=\"lista.ico\">" << endl;
        outFile << "<link rel=\"stylesheet\" href=\"todo_list_style.css\">" << endl;
        outFile << "<link rel=\"stylesheet\" href=\"https://fonts.googleapis.com/css?family=Roboto\">" << endl;
        outFile << "</head>" << endl;

        outFile << "<body>" << endl;
        outFile << "<div class=\"container\">" << endl;
        outFile << "<h1>Twoja lista zadan To-Do</h1>" << endl;
        

        for (int i = 0; static_cast<size_t>(i) < katalogi.size(); i++)
        {
            outFile << "<div class=\"category\">" << endl;
            outFile << "<h2>" + katalogi[i].nazwa + "</h2>" << endl;

            outFile << "<ul class=\"task-list\">" << endl;

            for (int j = 0; static_cast<size_t>(j) < katalogi[i].kategoria.size(); j++)
            {
                string zadanie = "";

                zadanie += "&emsp;" + katalogi[i].kategoria[j].data;
                zadanie += "&emsp;&emsp;" + katalogi[i].kategoria[j].tresc;

                if (katalogi[i].kategoria[j].zakonczone)
                {
                    outFile << "<li class=\"completed\">" + zadanie + "</li>" << endl;
                }
                else
                {
                    outFile << "<li>" << zadanie << "</li>" << endl;
                }
            }

            outFile << "</ul>" << endl;
            outFile << "</div>" << endl;
        }

        outFile << "</div>" << endl;
        outFile << "</body>" << endl;
        outFile << "</html>" << endl;
    }

    outFile.close();
}

void zapisz_liste_html(vector<Kategoria> katalogi, string plik_txt, string plik_html)
{
    ifstream inFile(plik_txt);
    ofstream outFile(plik_html, ofstream::trunc);
    string linia;
    while (getline(inFile, linia))
    {
        outFile << linia;
    }
    inFile.close();
    outFile.close();
}






int main()
{
    Stan stan_programu = Stan::menu;
    Dane dane = Dane::poprawne;
    int wybor;

    Kategoria zadania_podstawowe("Zadania");
    //  wszystkie katalogi
    vector<Kategoria> katalogi{ zadania_podstawowe };

    //  glowna petla programu
    while (stan_programu != Stan::zakoncz)
    {
        //  menu
        if (stan_programu == Stan::menu)
        {
            //  wybor akcji
            do
            {
                wyswietl_menu(dane);
                cin >> wybor;

                if (cin.fail()
                    || wybor < 1
                    || wybor > 5)
                {
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    dane = Dane::bledne;
                }
                else if (wybor == 1)
                {
                    stan_programu = Stan::dodaj_zadanie;
                    dane = Dane::poprawne;
                }
                else if (wybor == 2)
                {
                    stan_programu = Stan::dodaj_kategorie;
                    dane = Dane::poprawne;
                }
                else if (wybor == 3)
                {
                    stan_programu = Stan::lista;
                    dane = Dane::poprawne;
                }
                else if (wybor == 4)
                {
                    stan_programu = Stan::wizualizacja;
                    dane = Dane::poprawne;
                }
                else if (wybor == 5)
                {
                    stan_programu = Stan::zakoncz;
                    dane = Dane::poprawne;
                }
            } while (dane == Dane::bledne);
        }
        //  dodaj zadanie
        else if (stan_programu == Stan::dodaj_zadanie)
        {
            //  wybor akcji
            do
            {
                wyswietl_wybor_kategorii(katalogi);
                cin >> wybor;

                if (cin.fail()
                    || wybor < 0
                    || static_cast<size_t>(wybor) > katalogi.size())
                {
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    dane = Dane::bledne;
                }
                else if (wybor == 0)
                {
                    stan_programu = Stan::menu;
                    dane = Dane::poprawne;
                }
                else
                {
                    wyswietl_dodawanie_zadania(katalogi, wybor - 1);
                    string tytul_zadania;
                    string data_zadania;

                    cout << "\n\tTytul: ";
                    getline(cin >> ws, tytul_zadania);
                    cout << "\tDeadline [DD-MM-RR]: ";
                    getline(cin >> ws, data_zadania);

                    Zadanie nowe_zadanie(tytul_zadania, data_zadania);
                    katalogi[wybor - 1].dodaj_zadanie(nowe_zadanie);
                    stan_programu = Stan::menu;
                    dane = Dane::poprawne;

                }
            } while (dane == Dane::bledne);
        }
        //  dodaj kategorie
        else if (stan_programu == Stan::dodaj_kategorie)
        {
            string tytul_kategorii;

            clear_screen();
            cout << "Tytul nowej kategorii: ";
            getline(cin >> ws, tytul_kategorii);

            Kategoria nowa_kategoria(tytul_kategorii);
            katalogi.push_back(nowa_kategoria);

            stan_programu = Stan::menu;

        }
        //  lista zadan
        else if (stan_programu == Stan::lista)
        {
            do
            {
                wyswietl_liste_zadan(katalogi);
                cout << "\n\n\n\n\n";
                cout << "1: Odznacz zadanie jako (nie)wykonane\n";
                cout << "2: Usun zadanie\n";
                cout << "3: Usun kategorie (wszystkie zadania)\n";
                cout << "4: Zmien date\n";
                cout << "5: Pozostaly czas do wykonania zadania\n";

                cout << "\nCo chcesz wykonac? ";
                cin >> wybor;

                if (cin.fail()
                    || wybor < 0
                    || wybor > 5)
                {
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                }
                //  powrot do menu
                else if (wybor == 0)
                {
                    stan_programu = Stan::menu;
                }
                //  znacznik
                else if (wybor == 1)
                {
                    int wybor_kategorii;

                    wyswietl_liste_zadan(katalogi);
                    cout << "\n\n\n\n\nZ ktorej kategorii chcesz odznaczyc zadanie? ";
                    cin >> wybor_kategorii;
                    if (cin.fail()
                        || wybor_kategorii < 1
                        || static_cast<size_t>(wybor_kategorii) > katalogi.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                        continue;
                    }
                    cout << "Ktore zadanie chcesz odznaczyc? ";
                    cin >> wybor;
                    if (cin.fail()
                        || wybor < 1
                        || static_cast<size_t>(wybor) > katalogi[wybor_kategorii - 1].kategoria.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                    else
                    {
                        if (!katalogi[wybor_kategorii - 1].kategoria.empty())
                        {
                            katalogi[wybor_kategorii - 1].kategoria[wybor - 1].odznacz_zadanie();
                        }
                    }
                }
                //  usun zadanie
                else if (wybor == 2)
                {
                    int wybor_kategorii;

                    wyswietl_liste_zadan(katalogi);
                    cout << "\n\n\n\n\nZ ktorej kategorii chcesz usunac zadanie? ";
                    cin >> wybor_kategorii;
                    if (cin.fail()
                        || wybor_kategorii < 1
                        || static_cast<size_t>(wybor_kategorii) > katalogi.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                        continue;
                    }
                    cout << "Ktore zadanie chcesz usunac? ";
                    cin >> wybor;
                    if (cin.fail()
                        || wybor < 1
                        || static_cast<size_t>(wybor) > katalogi[wybor_kategorii - 1].kategoria.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                    else
                    {
                        if (!katalogi[wybor_kategorii - 1].kategoria.empty())
                        {
                            katalogi[wybor_kategorii - 1].usun_zadanie(wybor - 1);
                        }
                    }
                }
                //  usun kategorie
                else if (wybor == 3)
                {
                    int wybor_kategorii;

                    wyswietl_liste_zadan(katalogi);
                    cout << "\n\n\n\n\nKtora kategorie chcesz usunac? ";
                    cin >> wybor_kategorii;
                    if (cin.fail()
                        || wybor_kategorii < 1
                        || static_cast<size_t>(wybor_kategorii) > katalogi.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                        continue;
                    }
                    else
                    {
                        if (wybor_kategorii == 1)
                        {
                            katalogi[wybor_kategorii - 1].kategoria.clear();
                        }
                        else
                        {
                            katalogi.erase(katalogi.begin() + wybor_kategorii - 1);
                        }
                    }
                }
                //   aktualizacja daty
                else if (wybor == 4)
                {
                    int wybor_kategorii;

                    wyswietl_liste_zadan(katalogi);
                    cout << "\n\n\n\n\nW ktorej kategorii chcesz zmienic date? ";
                    cin >> wybor_kategorii;
                    if (cin.fail()
                        || wybor_kategorii < 1
                        || static_cast<size_t>(wybor_kategorii) > katalogi.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                        continue;
                    }
                    cout << "Ktorego zadania date chcesz zmienic? ";
                    cin >> wybor;
                    if (cin.fail()
                        || wybor < 1
                        || static_cast<size_t>(wybor) > katalogi[wybor_kategorii - 1].kategoria.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                    else
                    {
                        string nowa_data;

                        cout << "Nowa data [DD-MM-RR]: ";
                        getline(cin >> ws, nowa_data);

                        katalogi[wybor_kategorii - 1].kategoria[wybor - 1].zmien_date(nowa_data);
                    }
                }
                //  Python; obliczanie czasu na wykonanie zadan
                else if (wybor == 5)
                {
                    int wybor_kategorii;

                    wyswietl_liste_zadan(katalogi);
                    cout << "\n\n\n\n\nW ktorej kategorii chcesz odczytac pozostaly czas? ";
                    cin >> wybor_kategorii;
                    if (cin.fail()
                        || wybor_kategorii < 1
                        || static_cast<size_t>(wybor_kategorii) > katalogi.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                        continue;
                    }
                    cout << "Ktore zadanie wybrac? ";
                    cin >> wybor;
                    if (cin.fail()
                        || wybor < 1
                        || static_cast<size_t>(wybor) > katalogi[wybor_kategorii - 1].kategoria.size())
                    {
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                    else
                    {
                        wyswietl_liste_zadan(katalogi);

                        Py_Initialize();
                        
                        PyObject* my_module = PyImport_ImportModule("python_modules.my_module");
                        PyErr_Print();
                        PyObject* oblicz_czas = PyObject_GetAttrString(my_module, "oblicz_czas");

                        PyObject* args = PyTuple_Pack(1, PyUnicode_FromString(katalogi[wybor_kategorii - 1].kategoria[wybor - 1].data.c_str()));

                        cout << "\n\n\n\n\n";
                        PyObject* my_result = PyObject_CallObject(oblicz_czas, args);

                        cout << "Powrot: ";
                        cin >> wybor;

                        Py_Finalize();
                    }
                    
                }
            } while (wybor != 0);
        }
        //  otwarcie wizualizacji
        else if (stan_programu == Stan::wizualizacja)
        {
            zapisz_liste_txt(katalogi, "todo_list.txt");
            zapisz_liste_html(katalogi, "todo_list.txt", "todo_list.html");

            
            // Pełna ścieżka do pliku HTML
            string plik = "todo_list.html";
            // Komenda do otwarcia pliku w domyślnej przeglądarce
            string polecenie = "start \"\" \"" + plik + "\"";
            // Uruchomienie komendy
            system(polecenie.c_str());
    

            stan_programu = Stan::menu;
        }
    }



    return 0;
}