#include "Directory.h"

#include <list>
#include <stdexcept>

#include "CreateAction.h"
#include "DeleteAction.h"
#include "ReadAction.h"
#include "SearchAction.h"
#include "Utilities.h"

Directory::Directory(const std::string &name,  Directory* parent)
    : File(name, parent), files(std::list<std::shared_ptr<File>>()) { }

File& Directory::operator[](std::list<std::string> path) {
    if (path.empty()) {
        return *this;
    }

    std::shared_ptr<File> file = find(path.front()); // searches the folder/file

    if (file == nullptr) {
        throw std::runtime_error(Utilities::FileNotFoundMsg());
    }

    path.pop_front(); // removes the path we were at
    return (*file)[path];
}

const File& Directory::operator[](std::list<std::string> path) const // the same as above
{
    if (path.empty()) { return *this; }

    std::shared_ptr<File> file = find(path.front());

    if (file == nullptr) { throw std::runtime_error(Utilities::FileNotFoundMsg()); }

    path.pop_front();
    return (*file)[path];
}

std::unique_ptr<Action> Directory::CreateCreateAction(WriteRequest& request) {
    return std::unique_ptr<Action>(
        new CreateAction(request.name, request.type, request.linesVector, *this)
    );
}

std::unique_ptr<Action> Directory::CreateDeleteAction(WriteRequest& request) {
    return std::unique_ptr<Action>(
        new DeleteAction(*this, request.name)
    );
}

std::unique_ptr<Action> Directory::CreateReadAction(ReadRequest& request) const {
    std::vector<std::string> vector;
    for (const std::shared_ptr<File>& file : files) {
        vector.push_back(" - " + file->getName());
    }
    return std::unique_ptr<Action>(
        new ReadAction(request.hostPath, vector, request.isCout)
    );
}

std::unique_ptr<Action> Directory::CreateWriteAction(WriteRequest& request) {
    throw std::runtime_error(Utilities::TypeErrorMsg());
}

std::unique_ptr<Action> Directory::CreateSearchAction(SearchRequest &request) const
{
    std::vector<std::string> linesToPrint;

    SearchRequest sendDown = {
        request.searchTerm,
        true,
        request.comesFromCreateSearchAction
            ? request.printingVector
            : linesToPrint,
        request.pathFromLocation + "/" + getName()
    };

    for (const std::shared_ptr<File>& file : files)
    {
        file->CreateSearchAction(sendDown);
    }

    return request.comesFromCreateSearchAction
        ? nullptr
        : std::unique_ptr<Action>(new SearchAction(sendDown.printingVector));
}

bool Directory::canBeDeleted() const {
    return files.empty();
}

void Directory::addFile(std::shared_ptr<File> file) {
    for (const std::shared_ptr<File>& temp : files) {
        if (temp->getName() == file-> getName()) {
            throw std::runtime_error(Utilities::commandErrorMsg());
        }
    }
    files.push_back(file);
}

void Directory::removeFile(const std::string& name) {
    for (auto it = files.begin(); it != files.end(); ++it) {
        if ((*it)->getName() == name) {
            if ((*it)->canBeDeleted()) {
                files.erase(it);
                return;
            }
            throw std::runtime_error(Utilities::DirectoryNotEmptyMsg());
        }
    }
    throw std::runtime_error(Utilities::FileNotFoundMsg());
}

std::shared_ptr<File> Directory::find(const std::string &name) const
{
    for (const std::shared_ptr<File>& file : files)
    {
        if (file->getName() == name) {
            return file;
        }
    }

    return nullptr;
}