Lab4task1Java

import java.util.HashSet;
import java.io.*;
import java.util.Set;
import java.util.*;

import static java.lang.Math.round;

public class Main {
    private static final int TYPE_CHOICE_CONTINUE_OR_EXIT = 1;
    private static final int TYPE_CHOICE_FUNCTION = 0;
    private static final int MIN_SALARY = 1;
    private static final int MAX_SALARY = 999999;
    private static final int MAX_NAME_LENGTH = 15;
    private static final int MAX_DEPARTMENT_NAME_LENGTH = 15;
    private static final int MAX_MONTH_LENGTH = 8;
    private static final Scanner consoleScan = new Scanner(System.in);
    private static final HashSet<String> setMonths = new HashSet<String>(Set.of("январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"));
    private static final String[] monthNameArr = {"январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"};
    static class employee {
        String name;
        String department;
        String month;
        int salary;
        //float price;

        public employee(String name, String department, String month, int salary) {
            this.name = name;
            this.department = department;
            this.month = month;
            this.salary = salary;
        }
    }

    static employee[] listOfEmployee = new employee[1];

    private static void writeTask() {
        System.out.println("--------------------------------------------------------------" +
                "\nДанная программа позволяет вести учёт заработной платы сотрудников.");
    }

    private static void print(int typeChoice) {
        if (typeChoice == TYPE_CHOICE_FUNCTION)
            System.out.println("--------------------------------------------------------------\n" +
                    "Выберите действие:\n" +
                    "1 - добавить данные в список сотрудников.\n" +
                    "2 - редактировать данные в списке сотрудников.\n" +
                    "3 - удалить данные из списка сотрудников.\n" +
                    "4 - просмотр данных в списке сотрудников.\n" +
                    "5 - вывод общей суммы выплат по каждому отделу.\n" +
                    "6 - импорт данных из файла.\n" +
                    "7 - экспорт данных в файл.\n" +
                    "0 - конец работы и выключение программы.\n" +
                    "--------------------------------------------------------------");
        else if (typeChoice == TYPE_CHOICE_CONTINUE_OR_EXIT)
            System.out.println("Повторить действие?\n" +
                    "1 - да.\n" +
                    "2 - нет.");
    }

    private static int inputNumber(int min, int max) {
        int num = 0;
        boolean isNotCorrect;
        do {
            isNotCorrect = false;
            try {
                num = Integer.parseInt(consoleScan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Вы ввели некорректные данные! Попробуйте еще:");
                isNotCorrect = true;
            }
            if (!isNotCorrect && (num < min || num > max)) {
                System.out.println("Введено значение не входящее в диапазон допустимых! Попробуйте еще:");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return num;
    }

    private static boolean checkDataString(String dataString, int maxLength) {
        boolean isIncorrect = false;
        if (dataString.length() > maxLength) {
            isIncorrect = true;
            System.out.println("Вы превысили допустимую длину!");
        }
        if (dataString.isEmpty()) {
            System.out.println("Значение не может быть пустым!");
            isIncorrect = true;
        }
        if (!isIncorrect) {
            for (int i = 0; i < dataString.length() && !isIncorrect; i++) {
                if (dataString.charAt(i) == '@') {
                    isIncorrect = true;
                    System.out.println("Строка не может содержать символ @!");
                }
            }
        }
        return isIncorrect;
    }

    private static String inputName() {
        String name;
        boolean isIncorrect;
        do {
            System.out.println("Введите фамилию сотрудника (до 15 символов):");
            name = consoleScan.nextLine();
            isIncorrect = checkDataString(name, MAX_NAME_LENGTH);
        } while (isIncorrect);
        return name;
    }

    private static String inputdDepartmentName() {
        String department;
        boolean isIncorrect;
        do {
            System.out.println("Введите название отдела (до 15 символов):");
            department = consoleScan.nextLine();
            isIncorrect = checkDataString(department, MAX_DEPARTMENT_NAME_LENGTH);
        } while (isIncorrect);
        return department;
    }

    private static String inputMonth() {
        String month;
        boolean isIncorrect;
        do {
            System.out.println("Введите название месяца (до 8 символов):");
            month = consoleScan.nextLine();
            isIncorrect = checkDataString(month, MAX_MONTH_LENGTH);
            for (int i = 0; i < 11; i++) {
                if (!(setMonths.contains(month.toLowerCase()))) {
                    isIncorrect = true;
                }
            }
        } while (isIncorrect);
        return month;
    }

    private static int inputSalary() {
        int salary;
        System.out.println("Введите сведения о зарплате (число в копейках от 1 до 999999):");
        salary = inputNumber(MIN_SALARY, MAX_SALARY);
        return salary;
    }

    private static boolean checkOnSimilarRecord(String name, String department, String month) {
        boolean isEqualRecords = false;
        for (int i = 0; i < listOfEmployee.length - 1 && !isEqualRecords; i++)
            isEqualRecords = (listOfEmployee.equals(listOfEmployee[i].name) && department.equals(listOfEmployee[i].department) && month.equals(listOfEmployee[i].month));
        return isEqualRecords;
    }

    private static void takeInfoFromFile() {
        File file;
        String path = enterInputPath();
        String currentString;
        boolean isCorrect;

        file = new File(path);
        try (Scanner fileScan = new Scanner(file)) {
            while (fileScan.hasNextLine()) {
                currentString = fileScan.nextLine();
                String[] words = currentString.split("@");
                isCorrect = !(checkOnSimilarRecord(words[0], words[1], words[2]));
                if (isCorrect) {
                    saveRecord(words[0], words[1], words[2], Integer.parseInt(words[3]));
                } else
                    System.out.println("В файле встречена запись, идентичная уже имеющимся данным!\n" + "Запись импортирована не будет.");
            }
        } catch (Exception e) {
            System.out.println("Проверьте корректность данных в файле!");
        }
    }

    private static String enterOutputPath() {
        String path;
        boolean isFileIncorrect;
        do {
            isFileIncorrect = false;
            System.out.println("Введите путь к файлу:");
            path = consoleScan.nextLine();
            File file = new File(path);

            if (file.isDirectory()) {
                System.out.println("Ошибка! Файл не найден!");
                isFileIncorrect = true;
            } else {
                try {
                    if (!file.createNewFile() && !file.canWrite()) {
                        System.out.println("Ошибка! Файл доступен только для чтения!");
                        isFileIncorrect = true;
                    }
                } catch (IOException e) {
                    System.out.println("Ошибка! Не удалось записать информацию в файл!");
                    isFileIncorrect = true;
                }
            }

        } while (isFileIncorrect);
        return path;
    }

    private static String enterInputPath() {
        String path;
        boolean isFileIncorrect;
        do {
            isFileIncorrect = false;
            System.out.println("Введите путь к файлу:");
            path = consoleScan.nextLine();
            File file = new File(path);

            if (!file.isFile()) {
                System.out.println("Файл не найден! Пожалуйста проверьте существование файла и введите путь заново");
                isFileIncorrect = true;
            }
            if (!isFileIncorrect && !file.canRead()) {
                System.out.println("Файл не может быть прочитан! Пожалуйста проверьте файл и введите путь заново");
                isFileIncorrect = true;
            }
            if (!isFileIncorrect) {
                isFileIncorrect = checkInfInFile(path);
            }
        } while (isFileIncorrect);
        return path;
    }

    private static boolean checkInfInFile(String path) {
        String currentString;
        File checkFile;
        boolean isNotCorrectName;
        boolean isNotCorrectDepartment;
        boolean isNotCorrectMonth;
        boolean isNotCorrectSalary = false;
        boolean isIncorrect = false;

        checkFile = new File(path);

        try (Scanner fileScan = new Scanner(checkFile)) {
            while (fileScan.hasNextLine() && !isIncorrect) {
                currentString = fileScan.nextLine();
                String[] words = currentString.split("@");
                if (words.length > 5) {
                    System.out.println("Некорректные данные! Убедитесь, что поля каждой записи резделены символом '@'.");
                    isIncorrect = true;
                } else {
                    isNotCorrectName = checkDataString(words[0], MAX_NAME_LENGTH);
                    isNotCorrectDepartment = checkDataString(words[1], MAX_DEPARTMENT_NAME_LENGTH);
                    isNotCorrectMonth = checkDataString(words[2], MAX_MONTH_LENGTH);
                    if ((Integer.parseInt(words[3]) < MIN_SALARY) || (Integer.parseInt(words[3]) > MAX_SALARY)) {
                        isNotCorrectSalary = true;
                    }

                    if (isNotCorrectName || isNotCorrectDepartment || isNotCorrectMonth || isNotCorrectSalary) {
                        isIncorrect = true;
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("Проверьте корректность данных в файле!");
            isIncorrect = true;
        }
        return isIncorrect;
    }

    private static void saveRecord(String name, String department, String month, int salary) {
        listOfEmployee[listOfEmployee.length - 1] = new employee(name, department, month, salary);
        listOfEmployee = Arrays.copyOf(listOfEmployee, listOfEmployee.length + 1);
        System.out.println("Запись была добавлена успешно!");
    }

    private static void enterInf() {
        String name;
        String department;
        String month;
        int salary;
        int choice;
        boolean isEqualRecord = false;
        do {
            name = inputName();
            department = inputdDepartmentName();
            month = inputMonth();
            if (listOfEmployee.length > 1)
                isEqualRecord = checkOnSimilarRecord(name, department, month);
            if (!isEqualRecord) {
                salary = inputSalary();
                saveRecord(name, department, month, salary);
            } else
                System.out.println("Данная запись уже присутствует в списке!");

            print(TYPE_CHOICE_CONTINUE_OR_EXIT);
            choice = inputNumber(1, 2);
        } while (choice != 2);
    }

    private static int inputNumOfRecord(String str) {
        int number;
        final int MIN_NUM = 1;
        lookInf();
        System.out.println("Введите номер записи, которую нужно " + str + ".");
        number = inputNumber(MIN_NUM, listOfEmployee.length - 1);
        return number - 1;
    }

    private static void correctInf() {
        String name;
        String department;
        String month;
        int salary;
        int choice;
        int numOfRecord;
        do {
            numOfRecord = inputNumOfRecord("изменить");
            name = inputName();
            department = inputdDepartmentName();
            month = inputMonth();
            salary = inputSalary();

            listOfEmployee[numOfRecord] = new employee(name, department, month, salary);
            System.out.println("Запись номер " + (numOfRecord + 1) + " была успешно изменена!");

            print(TYPE_CHOICE_CONTINUE_OR_EXIT);
            choice = inputNumber(1, 2);

        } while (choice != 2);
    }

    private static void deleteInf() {
        int numberOfRecord;
        int choice = 0;
        int recordsCount;
        do {
            numberOfRecord = inputNumOfRecord("удалить");
            recordsCount = listOfEmployee.length;
            listOfEmployee[numberOfRecord] = null;
            for (int i = numberOfRecord + 1; i < recordsCount; i++) {
                listOfEmployee[i - 1] = listOfEmployee[i];
            }
            listOfEmployee[recordsCount - 1] = null;
            listOfEmployee = Arrays.copyOf(listOfEmployee, recordsCount - 1);
            System.out.println("Запись номер " + (numberOfRecord + 1) + " была успешно удалена!");

            if (listOfEmployee.length == 1) {
                System.out.println("Список записей пуст!");
            } else {
                print(TYPE_CHOICE_CONTINUE_OR_EXIT);
                choice = inputNumber(1, 2);
            }
        } while ((choice != 2) && (listOfEmployee.length > 1));
    }

    private static void saveToFile() {
        String path = enterOutputPath();
        try (PrintWriter fileOut = new PrintWriter(path)) {
            for (int i = 0; i < listOfEmployee.length - 1; i++)
                fileOut.println(listOfEmployee[i].name + "@" + listOfEmployee[i].department + "@" + listOfEmployee[i].month + "@" + listOfEmployee[i].salary);
        } catch (Exception e) {
            System.out.println("Не удалось вывести в файл!");
        }
        System.out.println("Данные успешно выведены в файл!");
    }

    private static void lookInf() {
        for (int i = 0; i < listOfEmployee.length - 1; i++) {
            System.out.println("------------------------------" + "\nЗапись №" + (i + 1) + "\nФамилия сотрудника: " + listOfEmployee[i].name + "\nОтдел: " + listOfEmployee[i].department + "\nМесяц: " + listOfEmployee[i].month + "\nЗарплата: " + listOfEmployee[i].salary + " ------------------------------");
        }
    }

    private static void lookCompanyInfo() {   //это еще что
        for (int i = 0; i < listOfEmployee.length - 1; i++) {
            //System.out.println("------------------------------" + "\nЗапись №" + (i + 1) + "\nОтде: " + listOfEmployee[i].department + "\nНазвание устройства: " + listOfEmployee[i].name + "\nЦена: " + listOfEmployee[i].salary + " BYN" + "\n------------------------------");
        }
    }

    private static void sortList() {
        int i, k, iMin, startInd, lastInd;
        employee tempEmployee;
        int[] monthArr = new int[12];
        for (k = 0; k < listOfEmployee.length - 2; k++) {
            iMin = k;
            for (i = k + 1; i < listOfEmployee.length - 1; i++) {
                if (listOfEmployee[i].department.compareTo(listOfEmployee[iMin].department) < 0) {
                    iMin = i;
                }
            }
            tempEmployee = listOfEmployee[iMin];
            listOfEmployee[iMin] = listOfEmployee[k];
            listOfEmployee[k] = tempEmployee;
        }
        startInd = 0;
        lastInd = 0;
        for (i = 0; i < listOfEmployee.length - 1; i++) {
            if ((i + 1 > listOfEmployee.length - 2) || (listOfEmployee[i].department.compareTo(listOfEmployee[i + 1].department) != 0)) {
                lastInd = i;
                for (k = startInd; k <= lastInd; k++) {
                    if (listOfEmployee[k].month.compareTo("январь") == 0) {
                        monthArr[0] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("февраль") == 0) {
                        monthArr[1] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("март") == 0) {
                        monthArr[2] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("апрель") == 0) {
                        monthArr[3] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("май") == 0) {
                        monthArr[4] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("июнь") == 0) {
                        monthArr[5] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("июль") == 0) {
                        monthArr[6] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("август") == 0) {
                        monthArr[7] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("сентябрь") == 0) {
                        monthArr[8] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("октябрь") == 0) {
                        monthArr[9] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("ноябрь") == 0) {
                        monthArr[10] += listOfEmployee[k].salary;
                    }
                    if (listOfEmployee[k].month.compareTo("декабрь") == 0) {
                        monthArr[11] += listOfEmployee[k].salary;
                    }
                }
            }
            for (k = 0; k < 12; k++) {
                if (monthArr[k] != 0) {
                    System.out.println("------------------------------" + "\nОтдел: " + listOfEmployee[startInd].department + "\nМесяц: " + monthNameArr[k] + "\nВыплаты: " + monthArr[k] + " ------------------------------");
                }
            }
            startInd = lastInd + 1;
            for (k = 0; k < 12; k++){
                monthArr[k] = 0;
            }
        }
        /*char arr[] = .toCharArray();
        char temp;

        int i = 0;
        while (i < arr.length) {
            int j = i + 1;
            while (j < arr.length) {
                if (arr[j] < arr[i]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                j += 1;
            }
            i += 1;
        }*/
    }

    private static void workWithCatalog() {
        final int MIN_OPTION = 0, MAX_OPTION = 7;
        int num;
        do {
            print(TYPE_CHOICE_FUNCTION);
            num = inputNumber(MIN_OPTION, MAX_OPTION);
            switch (num) {
                case 1:
                    enterInf();
                    break;
                case 2:
                    if (listOfEmployee.length > 1)
                        correctInf();
                    else
                        System.out.println("Для выполнения данного действия необходимо либо ввести, либо импортировать данные.");
                    break;
                case 3:
                    if (listOfEmployee.length > 1)
                        deleteInf();
                    else
                        System.out.println("Для выполнения данного действия необходимо либо ввести, либо импортировать данные.");
                    break;
                case 4:
                    if (listOfEmployee.length > 1)
                        lookInf();
                    else
                        System.out.println("Для выполнения данного действия необходимо либо ввести, либо импортировать данные.");
                    break;
                case 5:
                    if (listOfEmployee.length > 1) {
                        sortList();
                        //lookCompanyInfo();
                    } else
                        System.out.println("Для выполнения данного действия необходимо либо ввести, либо импортировать данные.");
                    break;
                case 6:
                    takeInfoFromFile();
                    break;
                case 7:
                    if (listOfEmployee.length > 1) {
                        saveToFile();
                    } else
                        System.out.println("Для выполнения данного действия необходимо либо ввести, либо импортировать данные.");
                    break;
            }
        } while (num != 0);
    }

    public static void main(String[] args) {
        writeTask();
        workWithCatalog();
        consoleScan.close();
    }
}