Commands.cpp

#include "Commands.h"

// SORT BY SIZE FUNCTIONS
bool Commands::compareSizeAscending(const Item* lhs, const Item* rhs) {
    return lhs->getSize() < rhs->getSize();
}
bool Commands::compareSizeDescending(const Item* lhs, const Item* rhs) {
    return lhs->getSize() > rhs->getSize();
}
void Commands::sortSize(std::vector<Item*>& contents, const std::vector<std::string>& input) {
    if (input.size() == 1) {

        sort(contents.begin(), contents.end(), compareSizeAscending);
        std::cout << "Sorted by size in ascending order" << std::endl;
    }
    else if (input[1] == "/r") {
        sort(contents.begin(), contents.end(), compareSizeDescending);
        std::cout << "Sorted by size in descending order" << std::endl;
    }
}

// SORT BY NAME FUNCTIONS
bool Commands::compareNameAscending(const Item* lhs, const Item* rhs) {
    return lhs->getName() < rhs->getName();
}
bool Commands::compareNameDescending(const Item* lhs, const Item* rhs) {
    return lhs->getName() > rhs->getName();
}
void Commands::sortName(std::vector<Item*>& contents, const std::vector<std::string>& input) {
    if (input.size() == 1) {
        sort(contents.begin(), contents.end(), compareNameAscending);
        std::cout << "Sorted alphabetically in ascending order" << std::endl;
    }
    else if (input[1] == "/r") {
        sort(contents.begin(), contents.end(), compareNameDescending);
        std::cout << "Sorted alphabetically in descending order" << std::endl;
    }
}

// MKFILE FUNCTION
void Commands::createFile(std::vector<Item*>& contents, const std::vector<std::string>& input) {
    
    if (input.size() == 1 || input.size() > 2) {
        std::cout << "Invalid filename entered. Filenames cannot include spaces" << std::endl;
        return;
    }
    auto check = find_if(contents.begin(), contents.end(), [&](Item* const x) {
        // same principle as the folder checker
        File* f = dynamic_cast<File*>(x);
        return f != nullptr && x->getName() == input[1];
        });

    if (check == contents.end()) {
        time_t t = time(0);
        tm now;
        localtime_s(&now, &t);
        srand(time(NULL));
        int random = rand() % 1000;
        contents.push_back(new File(input[1], now, random));
        std::cout << input[1] << " created succesfully" << std::endl;
    }
    else {
        std::cout << "File already exists" << std::endl;
    }
}

void Commands::createFolder(std::vector<Item*>& contents, const std::vector<std::string>& input, Folder* parent) {
    if (input.size() == 1 || input.size() > 2) {
        std::cout << "Invalid Folder name entered. Names cannot include spaces" << std::endl;
        return;
    }
    auto check = find_if(contents.begin(), contents.end(), [&](Item* const x) {
        // perform a cast to ensure that it is of type Folder
        Folder* f = dynamic_cast<Folder*>(x);
        // if the cast was successful (x is of Folder* type)
        // AND if the name matches the input value, the folder must already exist
        // if no object is found that matches both checks, the iterator returns the last iterator (beyond end of vector range)
        return f != nullptr && x->getName() == input[1];
        });
    // if check is last iterator, meaning nothing was found
    if (check == contents.end()) {
        time_t t = time(0);
        tm now;
        localtime_s(&now, &t);
        contents.push_back(new Folder(input[1], now, 0, parent));
    }
    else {
        std::cout << "Directory already exists" << std::endl;
    }
}

void Commands::showDirectory(Folder* current) {

    // lambda function based off of tutorial 6's list manipulation
    int files = 0;                                      // counters for number of files, folders
    int folders = 0;
    __int64 contents = 0;                               // initialising variable for total files' size
    const auto& currentDirectory = current->getContents();

    std::for_each(currentDirectory.cbegin(), currentDirectory.cend(), [&](Item* x) {       // & used to access variables outside the scope of the lambda
        if (x != nullptr) {
            x->printDetails();                              // print all details of every object, regardless of type
            //dynamic_cast<File*>(x) ? files++ : folders++;   // performs a cast with ternary counter if(file)++ else folder++
            x->isFile() ? files++ : folders++;
            contents += x->getSize();                       // summation size of all files in current directory
        }
        });

    std::cout << "\t" << files << " File(s)\t" << contents << " bytes" << std::endl;
    std::cout << "\t" << folders << " Dir(s)" << std::endl;
}

void Commands::deleteItem(Folder* current, const std::vector<std::string>& input) {
    if (input.size() > 1) {
        std::vector<Item*>& contents = current->editContents();
        // check to see if the item exists in the vector
        auto check = find_if(contents.begin(), contents.end(), [&](Item* const x) { return x->getName() == input[1]; });

        // if check is not the iterator to the end of the vector
        if (check != contents.end()) {
            contents.erase(check);
            std::cout << input[1] << " was sucesfully deleted" << std::endl;
        }
        else {
            std::cout << input[1] << " could not be found." << std::endl;
        }
    }
    else {
        std::cout << "Please enter file or directory name to delete" << std::endl;
    }
}