tv_rename/main.cpp

#include <iostream>
#include <set>

#ifdef _WIN32

#include <fcntl.h>
#include <io.h>
#include <windows.h>

#else

#include <getopt.h>

#endif

#include "filesystem.hpp"
#include "functions.hpp"
#include "tv_rename.hpp"

#ifdef _WIN32

using char_t = wchar_t;
using string = std::wstring;

#define cerr std::wcerr
#define cout std::wcout
#define cin std::wcin

#else

using char_t = char;
using string = std::string;

#define cerr std::cerr
#define cout std::cout
#define cin std::cin

#define TEXT( a ) a

#endif

constexpr size_t DB_ADD = 0x0001;
constexpr size_t DB_REFRESH = 0x0002;
constexpr size_t DB_UPDATE = 0x0004;
constexpr size_t DB_CLEAN = 0x0008;
constexpr size_t DB_REMOVE = 0x0010;
constexpr size_t DB_PATTERN = 0x0020;

int handleArgument( char_t c, string &show, std::set< int > &seasons_num,
                    bool &change_dir, string &path, bool &trust, bool &linux,
                    string &language, string &pattern, size_t &db_flags,
                    string &db_pattern, char_t *optional, int &i ) {
    switch ( c ) {
    case 's':
        show = optional;
        i++;
        break;
    case 'n':
        parseSeasonNumbers( seasons_num, optional );
        i++;
        break;
    case 'c':
        change_dir = false;
        break;
    case 'p':
        path = optional;
        i++;
        // if path provided, assume it's correct
        change_dir = false;
        break;
    case 't':
        trust = true;
        break;
    case 'x':
        linux = true;
        break;
    case 'l':
        if ( findLanguage( optional ) ) {
            language = optional;
        } else {
            cerr << "Invalid language choice" << std::endl;
            printLangs();
            return -1;
        }
        i++;
        break;
    case '0':
        printLangs();
        return 1;
    case 'h':
        printHelp();
        return 1;
    case '1':
        pattern = optional;
        i++;
        break;
    case 'a':
        db_flags |= DB_ADD;
        break;
    case 'r':
        db_flags |= DB_REFRESH;
        break;
    case 'u':
        db_flags |= DB_UPDATE;
        break;
    case 'd':
        db_pattern = optional;
        db_flags |= DB_PATTERN;
        i++;
        break;
    case '2':
        db_flags |= DB_CLEAN;
        break;
    case '3':
        db_flags |= DB_REMOVE;
        break;
    default:
        return -1;
    }
    return 0;
}

#ifdef _WIN32

string getOptions( const char_t *option ) {
    if ( option[0] != '-' )
        return L"";
    else if ( option[1] != '-' )
        return option + 1;
    else if ( !wcscmp( option, L"--show" ) )
        return L"s";
    else if ( !wcscmp( option, L"--season" ) )
        return L"n";
    else if ( !wcscmp( option, L"--correct-path" ) )
        return L"c";
    else if ( !wcscmp( option, L"--trust" ) )
        return L"t";
    else if ( !wcscmp( option, L"--linux" ) )
        return L"x";
    else if ( !wcscmp( option, L"--lang" ) )
        return L"l";
    else if ( !wcscmp( option, L"--print-langs" ) )
        return L"0";
    else if ( !wcscmp( option, L"--name-pattern" ) )
        return L"1";
    else if ( !wcscmp( option, L"--help" ) )
        return L"h";
    else if ( !wcscmp( option, L"--db-add" ) )
        return L"a";
    else if ( !wcscmp( option, L"--db-refresh" ) )
        return L"r";
    else if ( !wcscmp( option, L"--db-update" ) )
        return L"u";
    else if ( !wcscmp( option, L"--db-name-pattern" ) )
        return L"d";
    else if ( !wcscmp( option, L"--db-clean" ) )
        return L"2";
    else if ( !wcscmp( option, L"--db-remove" ) )
        return L"3";
    return L"";
}

// there's no getopt for windows, so just use wcscmp
int parseCommandLine( string &show, std::set< int > &seasons_num, string &path,
                      bool &change_dir, string &language, string &pattern,
                      bool &linux, bool &trust, size_t &db_flags,
                      string &db_pattern, const int argc, char_t **argv ) {
    string options{};
    char_t *optional;
    for ( auto i = 1; i < argc; i++ ) {
        options = getOptions( argv[i] );
        if ( options == L"" ) {
            options = L"p";
            optional = argv[i];
        } else {
            optional = ( i < argc - 1 ) ? argv[i + 1] : nullptr;
        }
        for ( const auto &x : options ) {
            auto res = handleArgument( x, show, seasons_num, change_dir, path,
                                       trust, linux, language, pattern,
                                       db_flags, db_pattern, optional, i );
            if ( res != 0 )
                return res;
        }
    }
    return 0;
}

#else

// parse command line arguments using getopt
int parseCommandLine( string &show, std::set< int > &seasons_num, string &path,
                      bool &change_dir, string &language, string &pattern,
                      bool &linux, bool &trust, size_t &db_flags,
                      string &db_pattern, 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' },
        { "trust",           no_argument,       0, 't' },
        { "linux",           no_argument,       0, 'x' },
        { "lang",            required_argument, 0, 'l' },
        { "print-langs",     no_argument,       0, '0' },
        { "name-pattern",    required_argument, 0, '1' },
        { "db-add",          no_argument,       0, 'a' },
        { "db-refresh",      no_argument,       0, 'r' },
        { "db-update",       no_argument,       0, 'u' },
        { "db-name-pattern", required_argument, 0, 'd' },
        { "db-clean",        no_argument,       0, '2' },
        { "db-remove",       required_argument, 0, '3' },
        { "help",            no_argument,       0, 'h' },
        { 0, 0, 0, 0 }
    };

    int i{}; // this is useless, but needed for handleArgument

    while ( 1 ) {
        int option_index{ 0 };
        auto c = getopt_long( argc, argv, "s:n:cp:txl:01:arud23h", long_options,
                              &option_index );
        if ( c == -1 )
            break;
        auto res = handleArgument( c, show, seasons_num, change_dir, path,
                                   trust, linux, language, pattern, db_flags,
                                   db_pattern, optarg, i );
        if ( res != 0 )
            return res;
    }

    if ( optind < argc ) {
        path = string( argv[optind] );
        // if path provided, assume it's correct
        change_dir = false;
    }

    return 0;
}

#endif

// windows needs wmain for unicode support
#ifdef _WIN32
int wmain
#else
int main
#endif
    ( int argc, char_t **argv ) {
#ifdef _WIN32
    // set console to unicode
    _setmode( _fileno( stdout ), _O_U16TEXT );
#endif
    string show{};
    std::set< int > seasons_num{};
    bool change_dir{ true };
    bool linux{ false };
    bool trust{ false };
    size_t db_flags{};
    string path{ TEXT( "." ) };
    string language{ TEXT( "en" ) };
    string pattern{ TEXT( "%filename - %epname" ) };
    string db_pattern{};
    Curl c;

    {
        auto tmp = parseCommandLine( show, seasons_num, path, change_dir,
                                     language, pattern, linux, trust, db_flags,
                                     db_pattern, argc, argv );
        if ( tmp == -1 )
            return 1;
        else if ( tmp == 1 )
            return 0;
    }

    if ( !FSLib::isDirectory( path ) && FSLib::exists( path ) ) {
        // specified file, not directory
        auto *file_set = new std::set< string >;
        file_set->insert( path );
        size_t season_pos{};
        if ( !searchSeason( path.c_str(), season_pos ) ) {
            cerr << "Specified file does not conform to filename pattern, "
                 << "cannot rename." << std::endl;
            return 1;
        } else {
            auto season = std::stoi( path.c_str() + season_pos );
            singleSeason( path, show, season, TEXT( "" ), language, pattern,
                          linux, trust, c, file_set );
            return 0;
        }
    } else if ( !FSLib::isDirectory( path ) ) {
        change_dir = true;
    }

    if ( !db_pattern.empty() ) {
        changeDBPattern( db_pattern );
    }

    if ( db_flags & DB_REMOVE && db_flags & DB_ADD ) {
        cerr << "You can't remove and add at the same time" << std::endl;
        return 1;
    }

    if ( db_flags & DB_REMOVE ) {
        removeFromDB( FSLib::canonical( path ) );
    }

    if ( db_flags & DB_ADD ) {
        addToDB( show, path, language, linux, c );
        cout << "Added to database" << std::endl;
    }
    if ( db_flags & DB_REFRESH ) {
        refreshDB( linux, c );
        cout << "Refreshed database" << std::endl;
    }
    if ( db_flags & DB_UPDATE ) {
        updateDB( linux, c );
        cout << "Updated database" << std::endl;
    }
    if ( db_flags & DB_CLEAN ) {
        cleanDB();
        cout << "Database cleaned" << std::endl;
    }

    // if db operations happened don't continue
    if ( db_flags )
        return 0;

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

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

    if ( seasons_num.size() == 1 ) {
        singleSeason( path, show, *seasons_num.begin(), string(), language,
                      pattern, linux, trust, c );
    } else if ( seasons_num.size() != 0 ) {
        multipleSeasons( path, show, seasons_num, language, pattern, linux,
                         trust, c );
    } else {
        allSeasons( path, show, language, pattern, linux, trust, c );
    }
}