#include <algorithm>
#include <iostream>
#include <string.h>
#include "functions.hpp"
#include <map>
#include <set>
#include <string>
#include <sstream>
#include <getopt.h>
#include <vector>
#include "filesystem.hpp"

void singleSeason( const std::string &path, const std::string &show, int season, std::string url );
void multipleSeasons( const std::string &path, const std::string &show, const std::set<int> seasons );
void allSeasons( const std::string &path, const std::string &show );

std::string language{"en"};
bool trust{false};
bool linux{false};
Curl c; // global so the connection doesn't close at every function

std::map<std::string, std::string> languages{
    {"en", "English"}, {"sv", "Svenska"}, {"no", "Norsk"}, {"da", "Dansk"}, {"fi", "Suomeksi"},
    {"nl", "Nederlands"}, {"de", "Deutsch"}, {"it", "Italiano"}, {"es", "Español"}, {"fr", "Français"},
    {"pl", "Polski"}, {"hu", "Magyar"}, {"el", "Greek"}, {"tr", "Turkish"}, {"ru", "Russian"},
    {"he", "Hebrew"}, {"ja", "Japanese"}, {"pt", "Portuguese"}, {"zh", "Chinese"}, {"cs", "Czech"},
    {"sl", "Slovenian"}, {"hr", "Croatian"}, {"ko","Korea"}
};

void printLangs() {
    for( const auto &x : languages ) {
        std::cout << x.first << " - " << x.second << std::endl;
    }
}

void parseSeasonNumbers(std::set<int> &seasons_num, const char *argument) {
    size_t pos{0};

    while(!isdigit(argument[pos]) && argument[pos] != '\0')
        pos++;

    if( argument[pos] == '\0' ) {
        seasons_num.clear();
        return;
    }

    int temp;
    std::istringstream iss(&optarg[pos]);
    while(iss >> temp) {
        seasons_num.insert(temp);
    }
}

bool parseCommandLine(std::string &show, std::set<int> &seasons_num, std::string &path, bool &change_dir, int argc, char **argv) {
    static struct option long_options[] = {
        {"show",            required_argument,  0, 's' },
        {"season",          required_argument,  0, 'n' },
        {"correct-path",    no_argument,        0, 'c' },
        {"show-path",       required_argument,  0, 'p' },
        {"trust",           no_argument,        0, 't' },
        {"linux",           no_argument,        0, 'x' },
        {"lang",            required_argument,  0, 'l' },
        {"print-langs",     no_argument,        0,  0  },
        {"help",            no_argument,        0, 'h' },
        {0,         0,                  0,  0 }
    };

    while(1) {
        int option_index{0};
        auto c = getopt_long(argc, argv, "s:n:cp:txl:0h", long_options, &option_index);
        if( c == -1 )
            break;
        switch(c) {
            case 's':
                show = optarg;
                break;
            case 'n':
                parseSeasonNumbers(seasons_num, optarg);
                break;
            case 'c':
                change_dir = false;
                break;
            case 'p':
                path = std::string(optarg);
                // if path provided, assume it's correct
                change_dir = false;
                break;
            case 't':
                trust = true;
                break;
            case 'x':
                linux = true;
                break;
            case 'l':
                if( languages.find(optarg) != languages.end() ) {
                    language = optarg;
                } else {
                    std::cerr << "Invalid language choice" << std::endl;
                    printLangs();
                    return false;
                }
                break;
            case '0':
                printLangs();
                return true;
            case 'h':
                printHelp();
                return true;
            default:
                return false;
        }
    }

    return true;
}

int main(int argc, char** argv) {
    std::string show{};
    std::set<int> seasons_num;
    std::string path{"."};
    bool change_dir{true};

    if( !parseCommandLine(show, seasons_num, path, change_dir, argc, argv) )
        return 1;

    if( !FSLib::isDirectory(path) )
        change_dir = true;

    while( change_dir ) {
        if( !FSLib::isDirectory(path) ) {
            std::cout << "This directory doesn't exist, please insert a correct path: " << std::endl;
            std::getline(std::cin, path);
            continue;
        }
        std::cout << "Is this the right directory? " << FSLib::canonical(path) << std::endl;
        std::string response;
        std::cin >> response;
        std::cin.ignore(1,'\n');
        std::cin.clear();
        if ( response[0] == 'y' || response[0] == 'Y' ) {
            change_dir = false;
        } else {
            std::cout << "Insert correct path:" << std::endl;
            std::getline(std::cin, path);
        }
    }

    if( show.empty() ) {
        auto pos = show.find_last_of('/');
        if( pos != std::string::npos )
            show = show.substr(++pos);
        std::cout << "Is this the right show name? " << show << std::endl;
        std::string response;
        std::cin >> response;
        std::cin.ignore(1, '\n');
        std::cin.clear();
        if( response[0] != 'y' && response[0] != 'Y' ) {
            std::cout << "Insert the correct show name: " << std::endl;
            std::getline(std::cin, show);
        }
    }

    if( seasons_num.size() == 1 ) {
        singleSeason(path, show, *seasons_num.begin(), "");
    } else if ( seasons_num.size() != 0 ) {
        multipleSeasons(path, show, seasons_num);
    } else {
        allSeasons(path, show);
    }
}

void parseEpisodeNames( const std::string &season_code, std::vector<std::string> &episodes) {
    size_t pos = 0;
    while( true ) {
        pos = season_code.find("ge=\"" + language + "\" ", pos);
        if( pos != std::string::npos ) {
            pos+= 17;
            while( isspace(season_code[pos]) )
                pos++;
            auto end = season_code.find("<", pos);
            end--;
            while( isspace(season_code[end]) )
                end--;
            end++;
            episodes.push_back(season_code.substr(pos, end - pos));
        } else {
            break;
        }
    }
}

void singleSeason( const std::string &path, const std::string &show, int season, std::string url) {
    if( url.empty() )
        url = getDefUrl(show, language, c);
    url += "/seasons/" + std::to_string(season);
    //get source code of season's page
    auto season_code = c.execute(url);
    //remove newlines
    season_code.erase(std::remove_if(season_code.begin(), season_code.end(), [](char x) {return x == '\r' || x == '\n';}), season_code.end());
    //first 900 chars or so are useless to us
    season_code = season_code.substr(900);
    //get only the episode names
    auto pos = season_code.find("\"translations\"");
    if( pos != std::string::npos ) {
        season_code = season_code.substr(pos);
        pos = season_code.find("table");
        if( pos != std::string::npos )
            season_code = season_code.substr(0,pos);
        else
            return;
    } else {
        return;
    }

    std::vector<std::string> episodes;
    //get episode names in all languages
    parseEpisodeNames(season_code, episodes);

    if( episodes.empty() )
        return;

    std::set<std::string> files;
    std::set<std::string> renamed_files;
    std::vector<std::string> renamed_episodes;

    renamed_episodes.resize(episodes.size());
    findSeason(files, season, path);

    if( files.empty() )
        return;

    for( const auto &x : files ) {
        auto last = x.find_last_of("/");
        std::string name;
        std::string dir;
        if( last == static_cast<size_t>(-1) ) {
            name = x;
            dir = ".";
        } else {
            name = x.substr(last+1);
            dir = x.substr(0, last);
        }
        unsigned long num;
        if( searchSpecificSeason(x.c_str(), pos, std::to_string(season)) ) {
            num = atoi(x.c_str()+pos);
        } else {
            continue;
        }
        num -= 1;
        if( num < episodes.size() ) {
            auto pos = name.find_last_of('.');
            name.insert(pos, " - " + episodes[num]);
            if( !linux ) {
                season_code.erase(std::remove_if(name.begin(), name.end(), [](char x) {return x == '?' || x == '"' || x == '\\' || x == '|' || x == '*';}), season_code.end());
                size_t max{name.size()};
                for( size_t i = 0; i < max ; i++ ) {
                    if( name[i] == '<' ) {
                        name[i] = 'i';
                        name.insert(i+1, "s less than");
                        max += 11;
                    } else if ( name[i] == '>' ) {
                        name[i] = 'i';
                        name.insert(i+1, "s more than");
                        max += 11;
                    } else if ( name[i] == ':' ) {
                        name[i] = ' ';
                        name.insert(i+1, 1, '-');
                        max++;
                    }
                }
            }
            renamed_files.insert(dir + "/" + name);
            renamed_episodes[num] = name;
        }
    }

    for(auto renamed = renamed_files.begin(); renamed != renamed_files.end(); ++renamed) {
        std::cout << *renamed << std::endl;
    }

    if( !trust ) {
        std::cout << "Does this seem ok? (y/n) ";
        std::string response;
        std::cin >> response;
        std::cin.clear();
        std::cin.ignore(1, '\n');
        if( response[0] != 'y' && response[0] != 'Y' )
            return;
    }

    auto orig = files.begin();

    for(auto renamed = renamed_files.begin(); renamed != renamed_files.end(); ++renamed) {
        FSLib::rename(*orig, *renamed);
        ++orig;
    }
}

void multipleSeasons( const std::string &path, const std::string &show, const std::set<int> seasons) {
    auto url = getDefUrl(show, language, c);
    for( const auto &x : seasons ) {
        singleSeason( path, show, x, url);
    }
}

void allSeasons( const std::string &path, const std::string &show) {
    std::set<int> seasons;
    //get all season number from this directory and subdirectories
    iterateFS(seasons, path);
    multipleSeasons( path, show, seasons);
}