Файловый менеджер

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;
 
/**
 * Главный класс программы - является точкой запуска программы.
 */
public class FileManager {
    /**
     * Константа - строка приветствия.
     */
    private static final String WELCOME = "Вас приветствует программа <FileManager>...";
 
    /**
     * Сокращённое название программы. Используется для вывода в начале строки.
     */
    private static final String PREFIX = "FM";
 
    /**
     * Ссылка на объект Input - класс работы с консолью;
     */
    private final Input input;
 
    /**
     * Ссылка на объект Parser - класс для перевода строки, введённой пользователем в
     * данные для программы.
     */
    private final Parser parser;
 
    /**
     * Конструктор для класса FileManager.
     *
     * @param input  - ссылка на объект Input;
     * @param parser - ссылка на объект Parser;
     */
    private FileManager(Input input, Parser parser) {
        this.input = input;
        this.parser = parser;
    }
 
    /**
     * Точка запуска программы.
     *
     * @param args - параметры при запуске программы (не нужны);
     */
    public static void main(String[] args) {
        new FileManager(new Input(), new Parser()).init();
    }
 
    /**
     * Главный метод для работы программы и пользователя.
     */
    private void init() {
        System.out.println(WELCOME);
        String read;
        Command command = null;
        if (this.parser != null && this.input != null) {
            while (command == null || !EOption.EXIT.equals(command.getKey())) {
                read = this.input.readConsole(getLine());
                command = this.parser.parseInput(read);
                if (command != null) {
                    command.getKey().getOption().execute(command.getSrcPath(), command.getDestPath());
                }
            }
        }
    }
 
    /**
     * Начальное значение каждой строки (путь в данный момент> )
     *
     * @return начальное значение длястроки ввода команд;
     */
    private String getLine() {
        return String.format("%s : %s> ", PREFIX, Util.getPath());
    }
}
 
//####################################################################################################
 
/**
 * Вспомогательный класс для хранения рабочего каталога
 * и проверки пути.
 */
class Util {
    /**
     * Рабочий каталог.
     * По умолчанию выбирается место запуска проекта (программы).
     */
    private static String path = System.getProperty("user.dir");
 
    /**
     * Геттер для Path.
     *
     * @return рабочий каталог;
     */
    static String getPath() {
        return path;
    }
 
    /**
     * Сеттер для Path.
     *
     * @param path - устанавливает рабочий каталог;
     */
    static void setPath(String path) {
        Util.path = path;
    }
 
    /**
     * Метод проверяет путь и возвращает корректный.
     * или null
     *
     * @param path - путь для проверки;
     * @return корректный путь или null;
     */
    static String getFullPath(String path) {
        String correctPath = null;
        if (path != null && !path.equals(".")) {
            File file = new File(path);
            if (file.getParent() != null) {
                correctPath = file.exists() ? path : null;
            } else {
                if (isTom(path)) {
                    correctPath = new File(path.toUpperCase() + File.separator).getPath();
                } else {
                    File aFile = new File(Util.path, path);
                    correctPath = aFile.exists() ? aFile.getPath() : null;
                }
            }
        }
        return correctPath;
    }
 
    /**
     * Метод проверяет, является ли путь Томом (Диском).
     *
     * @param path - путь;
     * @return true или false;
     */
    private static boolean isTom(String path) {
        boolean result = false;
        if (path != null) {
            File file = new File(path.toUpperCase() + File.separator);
            for (File tom : File.listRoots()) {
                if (tom.getPath().toUpperCase().equals(file.getPath())) {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }
}
 
//####################################################################################################
 
/**
 * Класс Parser - для парсинга ввода пользователя в команды и аттрибуты.
 */
class Parser {
    /**
     * Т.к. двойная ковычка используется в синтаксисе языка, как выделение строки
     * то это константа переводит код Unicode в эту ковычку.
     */
    private static final char QUOTE = (char) 34;
 
    /**
     * Метод парсит строку, введённую пользователем, в объект Command.
     *
     * @param input - строка для парсинга;
     * @return объект типа Command;
     */
    Command parseInput(String input) {
        Command command = null;
        String[] array = getArrayAttributes(input);
        if (array.length > 0) {
            EOption key = getKey(array[0]);
            if (key != null) {
                String srcPath = getStringByIndex(array, 1);
                String destPath = getStringByIndex(array, 2);
                if (key.getOption().checkPaths(srcPath, destPath)) {
                    command = new Command(key, srcPath, destPath);
                } else {
                    System.out.println(key.getOption().messageError(srcPath, destPath));
                }
            } else if (input.trim().length() != 0) {
                System.out.printf("ОШИБКА: %s%s%s не является командой программы...%s%s",
                        QUOTE, input, QUOTE, System.lineSeparator(), System.lineSeparator());
            }
        }
        return command;
    }
 
    /**
     * Метод возвращает из массива строку по индексу с проверкой.
     * Если индекс не удовлетворяет, то вернёт null;
     *
     * @param array - массив;
     * @param index - индекс;
     * @return данные из массива по индексу или null:
     */
    private String getStringByIndex(String[] array, int index) {
        String result = null;
        if (array != null && array.length > index && index >= 0) {
            result = array[index].trim();
        }
        return result;
    }
 
    /**
     * Прверяет наличие двойных ковычек в данных.
     * Т.к. если путь до файла илидиректории имеет в названии пробелы,
     * то следует этот путь помещать в двойные ковычки.
     *
     * @param line - строка для проверки двойных ковычек;
     * @return true - если ковычки присутствуют или false;
     */
    private boolean isQuotes(String line) {
        return line != null && line.length() != line.replaceAll(Character.toString(QUOTE), "").length();
    }
 
    /**
     * Метод проверяет входящие данные, являются ли они командой программы
     * и если да, то возвращает enum этой команды.
     *
     * @param key - ключ для проверки;
     * @return enub команды;
     */
    private EOption getKey(String key) {
        EOption eOption = null;
        if (key != null) {
            for (EOption options : EOption.values()) {
                Option option = options.getOption();
                if (option != null && key.toUpperCase().equals(option.getKey().toUpperCase())) {
                    eOption = options;
                    break;
                }
            }
        }
        return eOption;
    }
 
    /**
     * Метод разделяет строку с данными команды на массив атрибутов.
     *
     * @param line - строка с командой;
     * @return массив аттрибутов;
     */
    private String[] getArrayAttributes(String line) {
        String[] array = new String[0];
        if (line != null) {
            if (isQuotes(line)) {
                String newLine = "";
                String temp = "";
                for (int index = 0; index < line.length(); index++) {
                    if (line.charAt(index) == QUOTE) {
                        if (temp.trim().length() > 0) {
                            newLine = newLine.concat(temp.trim()).concat(System.lineSeparator());
                            temp = "";
                        }
                    } else {
                        temp = temp.concat(Character.toString(line.charAt(index)));
                    }
                }
                temp = temp.trim();
                if (temp.length() > 0) {
                    newLine = newLine.concat(temp);
                }
                array = newLine.split(System.lineSeparator());
 
            } else {
                array = line.trim().split("\\s+");
            }
        }
        return array;
    }
}
 
//####################################################################################################
 
/**
 * Класс Command - модель для хранения команды и параметров.
 */
class Command {
    /**
     * переменная команды (ключа).
     */
    private EOption key;
 
    /**
     * начальный путь.
     */
    private String srcPath;
 
    /**
     * конечный путь
     */
    private String destPath;
 
    /**
     * Геттер для Key.
     *
     * @return значение Key;
     */
    EOption getKey() {
        return key;
    }
 
    /**
     * Геттер для SrcPath.
     *
     * @return значение SrcPath;
     */
    String getSrcPath() {
        return srcPath;
    }
 
    /**
     * Геттер для DestPath.
     *
     * @return значение DestPath;
     */
    String getDestPath() {
        return destPath;
    }
 
    /**
     * Конструктор для класса-модели Command.
     *
     * @param key      - команда;
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     */
    Command(EOption key, String srcPath, String destPath) {
        this.key = key;
        this.srcPath = srcPath;
        this.destPath = destPath;
    }
}
 
//####################################################################################################
 
/**
 * Класс для чтения консоли (ввод пользователя).
 */
class Input {
    /**
     * Объект Scanner для работы сконсолью.
     */
    private final Scanner read;
 
    /**
     * Дефолтный конструктор класса Input.
     */
    Input() {
        this.read = new Scanner(System.in);
    }
 
    /**
     * Метод читает консоль и возвращает данные из неё.
     *
     * @param text - текст, предшествующий вводу;
     * @return строку данных;
     */
    String readConsole(String text) {
        System.out.print(text);
        return this.read.nextLine().trim();
    }
}
 
//####################################################################################################
 
/**
 * Абстрактный класс для представления команд в консоли как объектов.
 */
abstract class Option implements Comparable<Option> {
    /**
     * Константа - кол-во пробелов до "ключа".
     */
    private static final int TAB_KEY = 6;
 
    /**
     * Константа - кол-во пробелов после "ключа" с учётом символов.
     */
    private static final int TAB_EXAMPLE = 10;
 
    /**
     * Константа - кол-во пробелов после "примера" с учётом символов.
     */
    private static final int TAB_INFO = 60;
 
    /**
     * Переменная хранит команду для консоли.
     */
    private final String key;
 
    /**
     * Переменная хранит пример использования команды.
     */
    private final String example;
 
    /**
     * Переменная хранит описание команды для вывода описания команды.
     */
    private final String info;
 
    /**
     * Геттер для переменной key.
     *
     * @return возвращает название команды;
     */
    String getKey() {
        return key;
    }
 
    /**
     * Конструктор для абстрактного класса Option.
     *
     * @param key     - название команды;
     * @param example - пример её использования;
     * @param info    - описание команды;
     */
    Option(String key, String example, String info) {
        this.key = key;
        this.example = example;
        this.info = info;
    }
 
    /**
     * Метод выполняет действие для данной команды.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    abstract void execute(String srcPath, String destPath);
 
    /**
     * Проверка путей для команды.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true - пути корректные или false;
     */
    public boolean checkPaths(String srcPath, String destPath) {
        return srcPath == null && destPath == null;
    }
 
    /**
     * Метод возвращает строку ошибки для данного объекта.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return строку ошибки;
     */
    public String messageError(String srcPath, String destPath) {
        return String.format("ОШИБКА: Команда %s не имеет дополнительных параметров.%s", this.key, System.lineSeparator());
    }
 
    /**
     * Метод возвращает строку с нужным кол-вом пробелов до text.
     *
     * @param tabs - кол-во пробелов, которые требуются;
     * @return строку из пробелов;
     */
    String getTabsBefore(int tabs) {
        return String.format(String.format("%s%d%s", "%", tabs > 0 ? tabs : 0, "s"), "");
    }
 
    /**
     * Метод возвращает строку с нужным кол-вом пробелов после text.
     *
     * @param tabs - кол-во пробелов, которые требуются;
     * @return строку из пробелов;
     */
    private String getTabsAfter(String text, int tabs) {
        return String.format(String.format("%s-%d%s", "%", tabs > 0 ? tabs : 0, "s"), text);
    }
 
    /**
     * Метод возвращает информацию о команде. (используется для вывода информации
     * о ней в Help.
     *
     * @return информацию о команде;
     */
    @Override
    public String toString() {
        return String.format("%s%s : %s - %s;",
                getTabsBefore(TAB_KEY),
                getTabsAfter(this.key, TAB_EXAMPLE),
                getTabsAfter(String.format("[example : %s]", this.example), TAB_INFO),
                this.info);
    }
 
    /**
     * Используется для сортировки класса.
     * Так же используем сортировку команд при вывод их командой HELP.
     *
     * @param o - объект такого же типа илинаследников;
     * @return -1 - меньше o, 0 - равен o, 1 - больше o;
     */
    @Override
    public int compareTo(Option o) {
        return this.key.compareTo(o.key);
    }
}
 
//####################################################################################################
 
/**
 * Enum EOption - список всех команд программы.
 */
enum EOption {
    /**
     * Получаем список директории.
     */
    LIST(new List("LIST", "LIST или LIST [путь]", "выводит список директорий и файлов")),
 
    /**
     * Получаем информацию директории или файла.
     */
    INFO(new Info("INFO", "INFO или INFO [путь]", "выводит информацию о директории или файле")),
 
    /**
     * Переходим в другую директорию.
     */
    CD(new Cd("CD", "CD [директория], CD [путь] или CD ..]", "позволяет перейти в другую директорию")),
 
    /**
     * Копируем файл или директорию.
     */
    COPY(new Copy("COPY", "COPY [начальный путь] [конечный путь]", "позволяет копировать файлы или директории")),
 
    /**
     * Создаём директорию.
     */
    CREATE_DIR(new CreateDir("CREATE_DIR", "CREATE_DIR [директория] или CREATE_DIR [путь]", "позволяет создать директорию")),
 
    /**
     * Удаляем директорию или файл.
     */
    DELETE(new Delete("DELETE", "DELETE [директория (файл)] или DELETE [путь]", "позволяет удалить файл илидиректорию")),
 
    /**
     * Перемещаем директорию или файл.
     */
    MOVE(new Move("MOVE", "MOVE [начальный путь] [конечный путь]", "позволяет переместить директорию или файл")),
 
    /**
     * Перемещаем директорию или файл.
     */
    RENAME(new Rename("RENAME", "RENAME [начальный путь] [конечный путь]", "позволяет переименовать директорию или файл")),
 
    /**
     * Выводим информацию о командах программы.
     */
    HELP(new Help("HELP", "HELP", "выводит информацию о всех командах программы")),
 
    /**
     * Выходим из программы.
     */
    EXIT(new Exit("EXIT", "EXIT", "завершаем работу файлового менеджера"));
 
    /**
     * Ссылка на объект - модель команд.
     */
    private final Option option;
 
    /**
     * Геттер - возвращает ссылку на объект Option.
     *
     * @return ссылку на Option;
     */
    public Option getOption() {
        return option;
    }
 
    /**
     * Конструктор для enum EOption.
     *
     * @param option - ссылка на объект - модель команд программы;
     */
    EOption(Option option) {
        this.option = option;
    }
}
 
//####################################################################################################
 
/**
 * Команда EXIT.
 */
class Exit extends Option {
    /**
     * Конструктор для класса Exit.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Exit(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Выводим сообщение о завершении программы.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        System.out.println("Close <FileManager>...");
    }
}
 
//####################################################################################################
 
/**
 * Команда LIST
 */
class List extends Option {
    /**
     * Константа - табуляция по умолчанию.
     */
    private static final int DEFAULT_TAB = 4;
 
    /**
     * Константа - название типа файла.
     */
    private static final String DIR = "ПАПКА";
 
    /**
     * Константа - название типа файла.
     */
    private static final String FILE = "ФАЙЛ";
 
    /**
     * Константа - максимальная длинна имени файла (директории).
     * Если имя будет превышать, то по константе имя обрежется.
     */
    private static final int MAX_SYMBOLS = 75;
 
    /**
     * Конструктор для класса List.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    List(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод выводит на экран все файлы в каталоге.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        String path = Util.getPath();
        System.out.printf("%s%sСодержимое директории [%s] :%s",
                System.lineSeparator(), super.getTabsBefore(DEFAULT_TAB), path, System.lineSeparator());
        System.out.println();
        File[] files = new File(path).listFiles();
        if (files != null) {
            Arrays.sort(files, (o1, o2) -> o1.isDirectory() ?
                    o2.isDirectory() ? o1.getName().compareTo(o2.getName()) : -1
                    : o2.isDirectory() ? 1 : o1.getName().compareTo(o2.getName()));
            int max = getMaxName(files);
            max = max > MAX_SYMBOLS ? MAX_SYMBOLS : max;
            int amountFiles = 0;
            int amountDir = 0;
            String typeFile;
            for (File file : files) {
                String formatName = String.format(String.format("%s-%d.%d%s", "%", max + 5, max, "s"), file.getName());
                if (file.isDirectory()) {
                    typeFile = DIR;
                    amountDir++;
                } else {
                    typeFile = FILE;
                    amountFiles++;
                }
                System.out.printf("%s<%s>%s", formatName, typeFile, System.lineSeparator());
            }
            System.out.printf("%sНайдено: %d файл(-ов); %d папок;%s", System.lineSeparator(), amountFiles,
                    amountDir, System.lineSeparator());
        }
        System.out.println();
    }
 
    /**
     * Получаем длину самого большого имени.
     *
     * @param files - массив файлов;
     * @return число - самое длинное имя;
     */
    private int getMaxName(File[] files) {
        int result = -1;
        if (files != null) {
            for (File file : files) {
                int temp = file.getName().length();
                if (temp > result) {
                    result = temp;
                }
            }
        }
        return result;
    }
}

//####################################################################################################
 
/**
 * Команда INDO
 */
class Info extends Option {
    /**
     * Конструктор для класса INFO.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Info(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Выводим информацию о файлах и каталогах.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        StringBuilder sb = new StringBuilder(System.lineSeparator());
        sb.append(String.format("%-55s", "ИМЯ"))
                .append(String.format("%-15s", "ТИП")).
                append(String.format("%-15s", "РАЗМЕР")).
                append(String.format("%-25s", "ДАТА СОЗДАНИЯ")).
                append(String.format("%-25s", "ДАТА ИЗМЕНЕНИЯ"));
        sb.append(System.lineSeparator()).append(System.lineSeparator());
 
        File[] files = new File(Util.getPath()).listFiles();
        if (files != null) {
            Arrays.sort(files, (o1, o2) -> o1.isDirectory() ?
                    o2.isDirectory() ? o1.getName().compareTo(o2.getName()) : -1
                    : o2.isDirectory() ? 1 : o1.getName().compareTo(o2.getName()));
            for (File file : files) {
                sb.append(String.format("%-55.50s", file.getName()));
                sb.append(String.format("%-15s", file.isDirectory() ? "<ПАПКА>" : "<ФАЙЛ>"));
                sb.append(String.format("%-15s", getFileSize(file)));
                try {
                    BasicFileAttributes attr = Files.getFileAttributeView(file.toPath(), BasicFileAttributeView.class).readAttributes();
                    SimpleDateFormat sf = new SimpleDateFormat("dd.MM.yyyy HH:mm");
 
                    sb.append(String.format("%-25s", sf.format(new Date(attr.creationTime().toMillis()))));
                    sb.append(String.format("%-25s", sf.format(new Date(attr.lastModifiedTime().toMillis()))));
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
                sb.append(System.lineSeparator());
            }
        }
        System.out.println(sb.toString());
    }
 
    /**
     * Метод возвращает размер файла в виде отформатированной строки.
     *
     * @param file - файл или директория;
     * @return - строку (размер файла);
     */
    private String getFileSize(File file) {
        String result;
        double size = file.length();
        if (size / 1024 < 1) {
            result = String.format("%.1f %s", size, "bytes");
        } else {
            size /= 1024;
            if (size / 1024 < 1) {
                result = String.format("%.1f %s", size, "kb");
            } else {
                result = String.format("%.1f %s", size / 1024, "mb");
            }
        }
        return result;
    }
}
 
//####################################################################################################
 
/**
 * Команда CD.
 */
class Cd extends Option {
    /**
     * Конструктор для класса Cd.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Cd(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод переходит в выбранную директорию.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        srcPath = srcPath.trim();
        if (srcPath.equals("..")) {
            String back = new File(Util.getPath()).getParent();
            if (back != null) {
                Util.setPath(back);
            }
        } else {
            String path = Util.getFullPath(srcPath);
            if (path != null) {
                Util.setPath(path);
            }
        }
    }
 
    /**
     * Метод для проверки параметров.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true или false;
     */
    @Override
    public boolean checkPaths(String srcPath, String destPath) {
        return srcPath != null && destPath == null && checkParameter(srcPath);
    }
 
    /**
     * Метод для проверки введённого параметра для команды.
     *
     * @param parameter - параметр для проверки;
     * @return true или false;
     */
    private boolean checkParameter(String parameter) {
        parameter = parameter != null ? parameter.trim() : null;
        return parameter != null && (parameter.equals("..") || Util.getFullPath(parameter) != null);
    }
 
    /**
     * Метод возвращает строку с информацией об ошибке команды.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return строку с информацией об ошибке;
     */
    @Override
    public String messageError(String srcPath, String destPath) {
        String result;
        if (destPath != null || srcPath == null) {
            result = String.format("ОШИБКА: Команда %s должен иметь один параметр.%s",
                    super.getKey(), System.lineSeparator());
        } else {
            result = String.format("ОШИБКА: параметр [%s] для %s некорректный.%s", srcPath,
                    super.getKey(), System.lineSeparator());
        }
        return result;
    }
}
 
//####################################################################################################
 
/**
 * Команда CREATE_DIR
 */
class CreateDir extends Cd {
    /**
     * Конструктор для класса CreateDir.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    CreateDir(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод создаёт папку по пути.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        srcPath = srcPath.trim();
        File file = new File(srcPath).getParent() == null ?
                new File(Util.getPath(), srcPath) :
                new File(srcPath);
        if (file.mkdir()) {
            System.out.printf("Папка [%s] по пути [%s] успешно создана!%s", file.getName(), file.getParent(), System.lineSeparator());
        } else {
            System.out.printf("Папка [%s] по пути [%s] не создана!%s", file.getName(), file.getParent(), System.lineSeparator());
        }
    }
 
    /**
     * Метод для проверки параметров.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true или false;
     */
    @Override
    public boolean checkPaths(String srcPath, String destPath) {
        return srcPath != null && destPath == null && checkParameter(srcPath);
    }
 
    /**
     * Метод проверяет, есть ли в строке точка.
     *
     * @param str - строка для проверки;
     * @return true или false;
     */
    private boolean isPoint(String str) {
        return str != null && str.contains(".");
    }
 
    /**
     * Метод для проверки введённого параметра для команды.
     *
     * @param parameter - параметр для проверки;
     * @return true или false;
     */
    public boolean checkParameter(String parameter) {
        boolean result;
        parameter = parameter != null ? parameter.trim() : null;
        if (result = parameter != null && !isPoint(parameter)) {
            String parent = new File(parameter).getParent();
            result = parent == null || new File(parent).exists();
                    }
        return result;
    }
}
 
//####################################################################################################
 
/**
 * Команда RENAME
 */
class Rename extends Move {
    /**
     * Конструктор для класса Rename.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Rename(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод переименовывет файл иликаталог.
     *
     * @param srcPath - начальный путь;
     * @param destPath - конечный путь;
     */
    @Override
    void execute(String srcPath, String destPath) {
        srcPath = Util.getFullPath(srcPath);
        if (srcPath != null) {
            File srcFile = new File(srcPath);
            String parent = srcFile.getParent();
            if (parent != null) {
                if (srcFile.renameTo(new File(parent, destPath))) {
                    System.out.println("Переименование прошло успешно!");
                } else {
                    System.out.println("Переименование не удалось!");
                }
            }
        }
    }
 
    /**
     * Метод проверяет параметры на коректность.
     *
     * @param src - первый параметр;
     * @param dest - второй параметр;
     * @return true или false$
     */
    @Override
    public boolean checkParameters(String src, String dest) {
        return Util.getFullPath(src) != null && new File(dest).getParent() == null && isFile(src) == isFile(dest);
    }
}
 
//####################################################################################################
 
/**
 * Команда COPY.
 */
class Copy extends Option {
    /**
     * Конструктор для класса Copy.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Copy(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод копирует файлы или папки.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        srcPath = Util.getFullPath(srcPath.trim());
        if (srcPath != null) {
            if (destPath != null) {
                File dest = new File(destPath);
                if (dest.getParent() == null) {
                    dest = new File(Util.getPath(), destPath);
                }
                if (!dest.getPath().equals(srcPath)) {
                    File src = new File(srcPath);
                    if (src.isFile()) {
                        try {
                            Files.copy(src.toPath(), dest.toPath());
                            System.out.println("Файл успешно скопирован.");
                        } catch (IOException e) {
                            System.out.println("Не удалось скопировать файл.");
                        }
                    } else {
                        if (copyDir(src, dest, true)) {
                            System.out.printf("Директория [%s] успешно скопирована!%s", src.getPath(), System.lineSeparator());
                        }
                    }
                }
            }
        }
    }
 
    /**
     * Рекурсивный метод для копирования директорий.
     *
     * @param src  - начальный каталог;
     * @param dest - коненый каталог;
     * @param bool - переменная для слежения полного копирования;
     * @return true - всё скопировалось или false;
     */
    private boolean copyDir(File src, File dest, boolean bool) {
        if (src != null && src.isDirectory()) {
            if (dest.mkdir()) {
                File[] files = src.listFiles();
                if (files != null) {
                    for (File file : files) {
                        if (file.isDirectory()) {
                            copyDir(file, new File(dest.getPath(), file.getName()), bool);
                        } else {
                            try {
                                Files.copy(file.toPath(), new File(dest.getPath(), file.getName()).toPath());
                            } catch (IOException e) {
                                bool = false;
                                System.out.printf("Не удалось скопировать файл [%s];%s",
                                        file.getPath(), System.lineSeparator());
                            }
                        }
                    }
                }
            }
        }
        return bool;
    }
 
    /**
     * Метод проверяет входные параметры.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true или false;
     */
    @Override
    public boolean checkPaths(String srcPath, String destPath) {
        return srcPath != null && destPath != null && checkParameters(srcPath, destPath);
    }
 
    /**
     * Метод проверяет является ли путь - файлом.
     *
     * @param path - путь дляпроверки;
     * @return true или false;
     */
    private boolean isFile(String path) {
        return path != null && path.contains(".");
    }
 
    /**
     * Является ли путь - томом (диском).
     *
     * @param tom - строка для проверки;
     * @return true или false;
     */
    private boolean isTom(String tom) {
        return tom != null && tom.contains(":");
    }
 
    /**
     * Метод проверяет пути для команды.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true или false;
     */
    private boolean checkParameters(String srcPath, String destPath) {
        boolean result = false;
        srcPath = Util.getFullPath(srcPath);
        if (srcPath != null) {
            if (destPath != null) {
                if (isFile(srcPath) == isFile(destPath)) {
                    File dest = new File(destPath);
                    if (!(result = dest.exists())) {
                        if (dest.getParent() != null) {
                            result = new File(dest.getParent()).exists();
                        } else {
                            result = !isTom(destPath);
                        }
                    }
                }
            }
        }
        return result;
    }
 
    /**
     * Метод возращает строку с ошибкой, если параметры неудовлетворительны.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return сообщение ошибки;
     */
    @Override
    public String messageError(String srcPath, String destPath) {
        String result;
        if (destPath == null || srcPath == null) {
            result = String.format("ОШИБКА: Команда %s должна иметь два параметра.%s",
                    super.getKey(), System.lineSeparator());
        } else {
            result = String.format("ОШИБКА: параметры [%s, %s] для %s некорректные.%s", srcPath, destPath,
                    super.getKey(), System.lineSeparator());
        }
        return result;
    }
}
 
//####################################################################################################
 
/**
 * Команда MOVE
 */
class Move extends Copy {
    /**
     * Конструктор для класса Move.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Move(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод перемещает файл или каталог.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        File srcFile = new File(Util.getFullPath(srcPath));
        String destFile = Util.getFullPath(destPath);
        if (srcFile.isDirectory()) {
            if (moveFiles(srcFile, new File(destFile, srcFile.getName()), true)) {
                System.out.println("Все файлы успешно перемещены!");
            }
        } else {
            System.out.printf("Файл [%s] %s.%s", srcFile.getName(),
                    srcFile.renameTo(new File(destFile, srcFile.getName())) ? "успешно перемещён" : "не был перемещён",
                    System.lineSeparator());
        }
    }
 
    /**
     * Пекурсионный метод для переноса каталога с данными.
     *
     * @param src - откуда;
     * @param dest - куда;
     * @param result - переменная для отслеживания итогового результата;
     * @return true или false;
     */
    private boolean moveFiles(File src, File dest, boolean result) {
        if (src.isDirectory()) {
            if (dest.mkdir()) {
                File[] files = src.listFiles();
                if (files != null) {
                    for (File file : files) {
                        if (file.isDirectory()) {
                            File dir = new File(dest.getPath(), file.getName());
                            result = moveFiles(file, dir, result);
                        } else {
                            try {
                                Files.move(src.toPath(), new File(dest.getPath(), file.getName()).toPath());
                            } catch (IOException e) {
                                result = false;
                                System.out.printf("Не удалось переместить файл [%s];%s",
                                        file.getPath(), System.lineSeparator());
                            }
                        }
                    }
                }
            } else {
                System.out.printf("Не удалось создать папку [%s].%s", dest.getPath(), System.lineSeparator());
                result = false;
            }
        }
        return result;
    }
 
    /**
     * Метод проверяет, является ли путь файлом.
     *
     * @param path - путь;
     * @return true или false;
     */
    boolean isFile(String path) {
        return path != null && path.contains(".");
    }
 
    /**
     * Проверка параметров на корректность.
     *
     * @param srcPath  - начальный путь;
     * @param destPath - конечный путь;
     * @return true или false;
     */
    @Override
    public boolean checkPaths(String srcPath, String destPath) {
        return srcPath != null && destPath != null && checkParameters(srcPath, destPath);
    }
 
    /**
     * По сути тоже самый метод, что и выше, с некоторыми дополнительными проверками.
     *
     * @param src - начальный путь;
     * @param dest - конечный путь;
     * @return true или false;
     */
    public boolean checkParameters(String src, String dest) {
        return Util.getFullPath(src) != null && !isFile(dest) && Util.getFullPath(dest) != null;
    }
}
 
//####################################################################################################
 
/**
 * Команда DELETE.
 */
class Delete extends CreateDir {
    /**
     * Конструктор для класса Delete.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Delete(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод удаляет все данные по заданному пути.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        srcPath = srcPath.trim();
        File file = new File(Util.getFullPath(srcPath));
        if (file.isFile()) {
            System.out.printf("Файл [%s] по пути [%s] %s!%s", file.getName(), file.getParent(),
                    file.delete() ? "успешно удалён" : "не удалён", System.lineSeparator());
        } else {
            System.out.printf("%s%s", removeDirectory(file) ? "Все данные успешно удалены." : "Не все данные были удалены...",
                    System.lineSeparator());
        }
    }
 
    /**
     * Рекурсионный метод удалениявсех данных в каталоге.
     *
     * @param directory - каталог (папка) для удаления;
     * @return true - если все данные удалены или false;
     */
    private boolean removeDirectory(File directory) {
        boolean result;
        File[] files = directory.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    removeDirectory(file);
                } else {
                    if (!file.delete()) {
                        System.out.printf("   ОШИБКА УДАЛЕНИЯ ФАЙЛА: %s;%s", file.getPath(), System.lineSeparator());
                    }
                }
            }
        }
        if (!(result = directory.delete())) {
            System.out.printf("   ОШИБКА УДАЛЕНИЯ ПАПКИ: %s;%s", directory.getPath(), System.lineSeparator());
        }
        return result;
    }
 
    /**
     * Проверка параметра для команды.
     *
     * @param parameter - параметр для проверки;
     * @return true или false;
     */
    @Override
    public boolean checkParameter(String parameter) {
        parameter = parameter != null ? parameter.trim() : null;
        return parameter != null && Util.getFullPath(parameter) != null;
    }
}
 
//####################################################################################################
 
/**
 * Класс для команды HELP.
 */
class Help extends Option {
    /**
     * Константа - кол-во пробелов в начале строки.
     */
    private static final int DEFAULT_TABS = 3;
 
    /**
     * Конструктор для класса Help.
     *
     * @param key     - команда;
     * @param example - пример использования;
     * @param info    - описание команды;
     */
    Help(String key, String example, String info) {
        super(key, example, info);
    }
 
    /**
     * Метод выводит список команд для программы в консоль.
     *
     * @param srcPath  - начальный путь к файлу (директории);
     * @param destPath - конечный путь к файлу (директории);
     */
    @Override
    void execute(String srcPath, String destPath) {
        String separator = System.lineSeparator();
        System.out.printf("Программа <FileManager> - простой файловый менеджер.%s%s", separator, separator);
        System.out.printf("%sКоманды для работы с файлами:%s", super.getTabsBefore(DEFAULT_TABS), separator);
        EOption[] commands = EOption.values();
        Option[] options = new Option[commands.length];
        for (int index = 0; index < options.length; index++) {
            options[index] = commands[index].getOption();
        }
        Arrays.sort(options);
        for (Option option : options) {
            System.out.printf("%s%s", option, separator);
        }
        System.out.printf("%s%s* - команды можно водить в любом регистре.%s%s",
                separator, super.getTabsBefore(DEFAULT_TABS), separator, separator);
    }
}