package BLOCK41DEMO;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.io.*;
import java.io.File;
import java.io.IOException;
public class Main {
    record Worker(String name, int detailsInMonday, int detailsInTuesday, int detailsInWednesday, int detailsInThursday, int detailsInFriday, int detailsInSaturday) implements Serializable{}
    static Scanner scan = new Scanner(System.in);
    static int bufIndex;

    static String getName(){
        System.out.println("Введи имя рабочего:");
        return scan.nextLine();
    }

    static int getDetailsInSomeDay(String day){
        boolean isIncorrect;
        int detailsInDay;
        detailsInDay = 0;
        do {
            System.out.println("Введи количество деталей за " + day + " :");
            isIncorrect = false;
            try {
                detailsInDay = Integer.parseInt(scan.nextLine());
            } catch (Exception e) {
                isIncorrect = true;
                System.out.println("Введите число!.");
            }
            if ((((detailsInDay < 0) || (detailsInDay > 1000000000))) && !isIncorrect) {
                System.out.println("Количество деталей должно быть в диапазоне от 0 до 1000000000");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return detailsInDay;
    }

    static int enterSizeOfArray(){
        int sizeOfArray;
        sizeOfArray = 0;
        boolean isIncorrect;
        do {
            System.out.println("Введите количество рабочих: ");
            isIncorrect = false;
            try {
                sizeOfArray = Integer.parseInt(scan.nextLine());
            } catch (Exception e) {
                isIncorrect = true;
                System.out.println("Количество рабочих должно быть числом.");
            }
            if ((((sizeOfArray < 1) || (sizeOfArray > 10000))) && !isIncorrect) {
                System.out.println("Количество рабочих должно быть в диапазоне от 1 до 10000");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return sizeOfArray;
    }

    static void createArrayOfRecordsFromConsole() throws IOException, ClassNotFoundException {
        int sizeOfArray;
        sizeOfArray = enterSizeOfArray();
        Worker[] worker = new Worker[sizeOfArray];
        for(int i = 0; i < sizeOfArray; ++i){
            worker[i] = new Worker (getName(), getDetailsInSomeDay("понедельник"), getDetailsInSomeDay("вторник"), getDetailsInSomeDay("среду"), getDetailsInSomeDay("четверг"), getDetailsInSomeDay("пятницу"), getDetailsInSomeDay("субботу"));
        }
        writeArrayOfRecords(worker);
    }

    static void writeArrayOfRecordsToFile(Worker[] worker) throws IOException, ClassNotFoundException {
        String path;
        path = readPath();
        FileOutputStream fos = new FileOutputStream(path);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(worker);
        System.out.println("Файл успешно сохранён!");
        oos.close();
        fos.close();
        writeArrayOfRecords(worker);
    }

    static String readPath(){
        String path;
        boolean isIncorrect;
        isIncorrect = true;
        do {
            System.out.println("Введите абсолютный путь к файлу ");
            path = scan.nextLine();
            File fileOfRecords = new File(path);
            if (!fileOfRecords.exists()) {
                System.out.println("Файл не найден");
            }
            else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return path;
    }

    static void readArrayOfRecordsFromFile() throws IOException, ClassNotFoundException {
        boolean isIncorrect;
        String path;
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        do {
            isIncorrect = false;
            try {
                path = readPath();
                fis = new FileInputStream(path);
                ois = new ObjectInputStream(fis);
            }catch (Exception e){
                System.out.println("Ошибка! Проверьте файл!");
                isIncorrect = true;
            }
        }while(isIncorrect);
        Worker[] worker = (Worker[])ois.readObject();
        fis.close();
        ois.close();
        writeArrayOfRecords(worker);
    }

    static int readMenuOf3Item() {
        int menuItem;
        menuItem = 0;
        boolean isIncorrect;
        do {
            isIncorrect = false;
            try{
                menuItem = Integer.parseInt(scan.nextLine());
            } catch (Exception e) {
                System.out.println("Введите число!");
                isIncorrect = true;
            }
            if ((menuItem != 1) && (menuItem != 2) && (menuItem != 3)) {
                System.out.println("Введите одно из предложенных чисел!");
                isIncorrect = true;
            }
        }while(isIncorrect);
        return menuItem;
    }

    static void showWorkerAndDetailsOnWeek(Worker[] worker) {
        searchingWorker(worker);
        int sum;
        sum = worker[bufIndex].detailsInMonday + worker[bufIndex].detailsInTuesday + worker[bufIndex].detailsInWednesday + worker[bufIndex].detailsInThursday + worker[bufIndex].detailsInFriday + worker[bufIndex].detailsInSaturday;
        System.out.println(worker[bufIndex].name + " собрал " + sum + " деталей за шестидневную неделю.");
    }

    static void searchingWorker(Worker[] worker) {
        boolean isNotFind;
        int i;
        String userWorker;
        System.out.println("Введите фамилию рабочего:");
        do{
            isNotFind = true;
            userWorker = scan.nextLine();
            i = 0;
            while((i < worker.length) && (isNotFind)){
                if (userWorker.equals(worker[i].name)) {
                    bufIndex = i;
                    isNotFind = false;
                }
                ++i;
            }
            if (isNotFind)
                System.out.println("Рабочий с такой фамилией не найден! Введите другую фамилию!");
        }while(isNotFind);
    }

    static void showBestWorker(Worker[] worker) {
        int maxPerformance;
        String bestDay;
        String bestWorkman;
        int bufIndex;
        int index;
        maxPerformance = 0;
        bufIndex = 0;
        bestWorkman = "";
        int[] ArrayOfSumOfProducts = new int[worker.length];
        for (int i = 0; i < worker.length; ++i){
            ArrayOfSumOfProducts[i] = worker[i].detailsInMonday + worker[i].detailsInTuesday + worker[i].detailsInWednesday + worker[i].detailsInThursday + worker[i].detailsInFriday + worker[i].detailsInSaturday;
        }
        for (int i = 1; i < worker.length; ++i){
            if ((ArrayOfSumOfProducts[i-1] > ArrayOfSumOfProducts[i]) && (ArrayOfSumOfProducts[i-1] > maxPerformance)){
                bestWorkman = worker[i-1].name;
                maxPerformance = ArrayOfSumOfProducts[i-1];
                bufIndex = i - 1;
            }
        }
        if (worker[bufIndex].detailsInMonday > worker[bufIndex].detailsInTuesday){
            bestDay = "Понедельник";
            index = worker[bufIndex].detailsInMonday;
        }else{
            bestDay = "Вторник";
            index = worker[bufIndex].detailsInTuesday;
        }
        if (index < worker[bufIndex].detailsInWednesday){
            bestDay = "Среда";
            index = worker[bufIndex].detailsInTuesday;
        }
        if (index < worker[bufIndex].detailsInThursday){
            bestDay = "Четверг";
            index = worker[bufIndex].detailsInThursday;
        }
        if (index < worker[bufIndex].detailsInFriday) {
            bestDay = "Пятница";
            index = worker[bufIndex].detailsInFriday;
        }
        if (index < worker[bufIndex].detailsInSaturday) {
            bestDay = "Суббота";
        }
        System.out.println("Сборщик-рекордсмен - " + bestWorkman + ". Он собрал " + maxPerformance + " деталей за неделю! День высшей производительности: "+ bestDay);
    }

    static void selectMenuOfOutputItem(int menuItem, Worker[] worker) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> showWorkerAndDetailsOnWeek(worker);
            case 2 -> showBestWorker(worker);
            case 3 -> showMenu(worker);
        }
    }

    static void showMenuOfOutput(Worker[] worker) throws IOException, ClassNotFoundException {
        System.out.println("Выберете один из пунктов меню для продолжения:");
        System.out.println("1. Сборщик и детали за неделю.");
        System.out.println("2. Сборщик-рекордсмен.");
        System.out.println("3. Назад.");
        int menuItem;
        menuItem = readMenuOf4Item();
        selectMenuOfOutputItem(menuItem, worker);
    }

    static int readIndex(int maxIndex)
    {
        int index;
        index = 0;
        boolean IsNotCorrect;
        do {
            System.out.println("Введите индекс поля, с которым нужно совершить выбранное действие: ");
            IsNotCorrect = false;
            try {
                index = Integer.parseInt(scan.nextLine());
            } catch (Exception e) {
                IsNotCorrect = true;
                System.out.println("Введите целое число!");
            }
            if ((((index < 1) || (index > maxIndex+1))) && !IsNotCorrect) {
                System.out.println("Индекс должен находится в преедлах от 0 до количество элементов записи!");
                IsNotCorrect = true;
            }
        } while (IsNotCorrect);
        return index-1;
    }

    static void changeRecordField(Worker[] worker) throws IOException, ClassNotFoundException {
        int index;
        index = readIndex(worker.length);
        worker[index] = new Worker (getName(), getDetailsInSomeDay("понедельник"), getDetailsInSomeDay("вторник"), getDetailsInSomeDay("среду"), getDetailsInSomeDay("четверг"), getDetailsInSomeDay("пятницу"), getDetailsInSomeDay("субботу"));
        writeArrayOfRecords(worker);
    }

    static void addRecordField(Worker[] worker) throws IOException, ClassNotFoundException {
        ArrayList<Worker> workerArrayList = new ArrayList<>();
        Collections.addAll(workerArrayList, worker);
        Worker workman = new Worker (getName(), getDetailsInSomeDay("понедельник"), getDetailsInSomeDay("вторник"), getDetailsInSomeDay("среду"), getDetailsInSomeDay("четверг"), getDetailsInSomeDay("пятницу"), getDetailsInSomeDay("субботу"));
        workerArrayList.add(workman);
        worker = workerArrayList.toArray(new Worker[workerArrayList.size()]);
        writeArrayOfRecords(worker);
    }

    static void deleteRecordField(Worker[] worker) throws IOException, ClassNotFoundException {
        ArrayList<Worker> workerArrayList = new ArrayList<>();
        Collections.addAll(workerArrayList, worker);
        int index = readIndex(worker.length);
        workerArrayList.remove(index);
        worker = workerArrayList.toArray(new Worker[workerArrayList.size()]);
        writeArrayOfRecords(worker);
    }

    static boolean isChangeDataCorrect(int maxIndex, String path) throws IOException {
        int index;
        index = 0;
        boolean isCorrect;
        FileReader fread = new FileReader(path);
        Scanner fscan = new Scanner(fread);
        isCorrect = true;
        while(fscan.hasNextLine() && isCorrect) {
            try {
                index = Integer.parseInt(fscan.nextLine());
            } catch (Exception e) {
                isCorrect = false;
            }
            if ((((index < 1) || (index > maxIndex + 1))) && isCorrect) {
                isCorrect = false;
            }
            fscan.nextLine();
            int i = 0;
            while (i < 6 && isCorrect) {
                try {
                    index = Integer.parseInt(fscan.nextLine());
                } catch (Exception e) {
                    isCorrect = false;
                }
                ++i;
            }
        }
        fread.close();
        return isCorrect;
    }

    static void changeRecordFieldByFile(Worker[] worker) throws IOException, ClassNotFoundException {
        int index;
        String path = readPath();
        if (isChangeDataCorrect(worker.length, path)) {
            String nameOfWorker;
            int quantityOfDetailsOnMonday;
            int quantityOfDetailsOnTuesday;
            int quantityOfDetailsOnWednesday;
            int quantityOfDetailsOnThursday;
            int quantityOfDetailsOnFriday;
            int quantityOfDetailsOnSaturday;
            FileReader fread = new FileReader(path);
            Scanner fscan = new Scanner(fread);
            while(fscan.hasNextLine()) {
                index = Integer.parseInt(fscan.nextLine());
                --index;
                nameOfWorker = fscan.nextLine();
                quantityOfDetailsOnMonday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnTuesday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnWednesday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnThursday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnFriday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnSaturday = Integer.parseInt(fscan.nextLine());
                worker[index] = new Worker(nameOfWorker, quantityOfDetailsOnMonday, quantityOfDetailsOnTuesday, quantityOfDetailsOnWednesday, quantityOfDetailsOnThursday, quantityOfDetailsOnFriday, quantityOfDetailsOnSaturday);
            }
            writeArrayOfRecords(worker);
        }else{
            System.out.println("Ошибка чтения! Проверьте файл!");
        }
        writeArrayOfRecords(worker);
    }

    static boolean isAddDataCorrect(String path) throws IOException {
        boolean isCorrect;
        int i;
        FileReader fread = new FileReader(path);
        Scanner fscan = new Scanner(fread);
        isCorrect = true;
        while(fscan.hasNextLine() && isCorrect) {
            fscan.nextLine();
            i = 0;
            while (i < 6 && isCorrect) {
                try {
                    Integer.parseInt(fscan.nextLine());
                }catch (Exception e) {
                    isCorrect = false;
                }
                ++i;
            }
        }
        fread.close();
        return isCorrect;
    }

    static void addRecordFieldByFile(Worker[] worker) throws IOException, ClassNotFoundException {
        String path = readPath();
        if (isAddDataCorrect(path)) {
            String nameOfWorker;
            int quantityOfDetailsOnMonday;
            int quantityOfDetailsOnTuesday;
            int quantityOfDetailsOnWednesday;
            int quantityOfDetailsOnThursday;
            int quantityOfDetailsOnFriday;
            int quantityOfDetailsOnSaturday;
            FileReader fread = new FileReader(path);
            Scanner fscan = new Scanner(fread);
            ArrayList<Worker> workerArrayList = new ArrayList<>();
            Collections.addAll(workerArrayList, worker);
            while(fscan.hasNextLine()) {
                nameOfWorker = fscan.nextLine();
                quantityOfDetailsOnMonday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnTuesday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnWednesday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnThursday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnFriday = Integer.parseInt(fscan.nextLine());
                quantityOfDetailsOnSaturday = Integer.parseInt(fscan.nextLine());
                Worker workman = new Worker(nameOfWorker, quantityOfDetailsOnMonday, quantityOfDetailsOnTuesday, quantityOfDetailsOnWednesday, quantityOfDetailsOnThursday, quantityOfDetailsOnFriday, quantityOfDetailsOnSaturday);
                workerArrayList.add(workman);
                worker = workerArrayList.toArray(new Worker[workerArrayList.size()]);
            }
        }else{
            System.out.println("Ошибка чтения! Проверьте файл!");
        }
            writeArrayOfRecords(worker);
    }

    static boolean isDeleteDataCorrect(int maxIndex, String path) throws IOException {
        boolean isCorrect;
        int deleteIndex;
        FileReader fread = new FileReader(path);
        Scanner fscan = new Scanner(fread);
        isCorrect = true;
        deleteIndex = 0;
        while(fscan.hasNextLine() && isCorrect) {
            try {
                deleteIndex = Integer.parseInt(fscan.nextLine());
            } catch (Exception e) {
                isCorrect = false;
            }
            if ((((deleteIndex < 1) || (deleteIndex > maxIndex+1))) && isCorrect)
                isCorrect = false;
        }
        fread.close();
        return isCorrect;
    }

    static void deleteRecordFieldByFile(Worker[] worker) throws IOException, ClassNotFoundException {
        String path = readPath();
        if (isDeleteDataCorrect(worker.length, path)) {
            FileReader fread = new FileReader(path);
            Scanner fscan = new Scanner(fread);
            int deleteIndex;
            int i;
            ArrayList<Worker> workerArrayList = new ArrayList<>();
            Collections.addAll(workerArrayList, worker);
            i = 0;
            while(fscan.hasNextLine()) {
                deleteIndex = Integer.parseInt(fscan.nextLine());
                if (i>0)
                    deleteIndex = deleteIndex - i;
                workerArrayList.remove(deleteIndex-1);
                worker = workerArrayList.toArray(new Worker[workerArrayList.size()]);
                ++i;
            }
        }else {
            System.out.println("Ошибка чтения! Проверьте файл!");
        }
        writeArrayOfRecords(worker);
    }

    static void selectMenuOfChangingManuallyItem(int menuItem, Worker[] worker) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> changeRecordField(worker);
            case 2 -> addRecordField(worker);
            case 3 -> deleteRecordField(worker);
            case 4 -> showMenuOfChanging(worker);
        }
    }

    static void showMenuOfChangingManually(Worker[] worker) throws IOException, ClassNotFoundException {
        int menuItem;
        System.out.println("Выберете один из пунктов меню для продолжения:");
        System.out.println("1. Изменить.");
        System.out.println("2. Добавить.");
        System.out.println("3. Удалить.");
        System.out.println("4. Назад.");
        menuItem = readMenuOf3Item();
        selectMenuOfChangingManuallyItem(menuItem, worker);
    }

    static void selectMenuOfChangingByFileItem(int menuItem, Worker[] worker) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> changeRecordFieldByFile(worker);
            case 2 -> addRecordFieldByFile(worker);
            case 3 -> deleteRecordFieldByFile(worker);
            case 4 -> showMenuOfChanging(worker);
        }
    }

    static void showMenuOfChangingByFile(Worker[] worker) throws IOException, ClassNotFoundException {
        int menuItem;
        System.out.println("Выберете один из пунктов меню для продолжения:");
        System.out.println("1. Изменить.");
        System.out.println("2. Добавить.");
        System.out.println("3. Удалить.");
        System.out.println("4. Назад.");
        menuItem = readMenuOf4Item();
        selectMenuOfChangingByFileItem(menuItem, worker);
    }

    static void selectMenuOfChangingItem(int menuItem, Worker[] worker) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> showMenuOfChangingManually(worker);
            case 2 -> showMenuOfChangingByFile(worker);
            case 3 -> showMenu(worker);
        }
    }

    static void showMenuOfChanging(Worker[] worker) throws IOException, ClassNotFoundException {
        int menuItem;
        System.out.println("Выберете один из пунктов меню для продолжения:");
        System.out.println("1. Вручную.");
        System.out.println("2. С помощью файла.");
        System.out.println("3. Назад.");
        menuItem = readMenuOf4Item();
        selectMenuOfChangingItem(menuItem, worker);
    }

    static void selectMenuItem(int menuItem, Worker[] worker) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> showMenuOfOutput(worker);
            case 2 -> showMenuOfChanging(worker);
            case 3 -> writeArrayOfRecordsToFile(worker);
            case 4 -> showMainMenu();
        }
    }

    static void showMenu(Worker[] bufRecord) throws IOException, ClassNotFoundException {
        int menuItem;
        System.out.println("Выберете один из пунктов меню для продолжения:");
        System.out.println("1. Вывести.");
        System.out.println("2. Корректировка записей.");
        System.out.println("3. Сохранить таблицу в файл.");
        System.out.println("4. Назад.");
        menuItem = readMenuOf4Item();
        selectMenuItem(menuItem, bufRecord);
    }

    static void writeArrayOfRecords(Worker[] bufRecord) throws IOException, ClassNotFoundException {
        System.out.println("№"+" "+"Фамилия"+" "+"Понедельник"+" "+"Вторник"+" "+"Среда"+" "+"Четверг"+" "+"Пятница"+" "+"Суббота");
        for (int i = 0; i < bufRecord.length; ++i) {
            System.out.println((i+1) +" "+bufRecord[i].name +"\t\t"+ bufRecord[i].detailsInMonday +"\t\t\t"+ bufRecord[i].detailsInTuesday +"\t\t"+ bufRecord[i].detailsInWednesday +"\t\t"+ bufRecord[i].detailsInThursday +"\t\t"+ bufRecord[i].detailsInFriday +"\t\t"+ bufRecord[i].detailsInSaturday);
        }
        showMenu(bufRecord);
    }

    static int readMenuOf4Item() {
        int menuItem;
        boolean isNotCorrect;
        menuItem = 0;
        do {
            isNotCorrect = false;
            try {
                menuItem = Integer.parseInt(scan.nextLine());
            } catch (Exception e) {
                System.out.println("Введите число!");
                isNotCorrect = true;
            }
            if ((menuItem != 1) && (menuItem != 2) && (menuItem != 3)&& (menuItem != 4)) {
                System.out.println("Введите одно из предложенных чисел!");
                isNotCorrect = true;
            }
        }while(isNotCorrect);
        return menuItem;
    }

    static void showMainMenu() throws IOException, ClassNotFoundException {
        int menuItem;
        do {
            System.out.println("Выберете один из пунктов меню для продолжения:");
            System.out.println("1. Загрузить запись из файла.");
            System.out.println("2. Создать новую запись.");
            System.out.println("3. О программе.");
            System.out.println("4. Помощь.");
            menuItem = readMenuOf4Item();
            selectMainMenuItem(menuItem);
        }while(menuItem == 3 || menuItem == 4);
    }

    static void showInformationAboutProgram() {
        System.out.println("Сведения о количестве изделий, собранных сборщиками цеха за неделю:");
        System.out.println("- фамилия сборщика;");
        System.out.println("- количество изделий, собираемых им ежедневно в течение шестидневной недели,");
        System.out.println("т.е. раздельно - в понедельник, вторник и т.д.");
        System.out.println("Вывести фамилию сборщика и общее количество деталей,");
        System.out.println("собранное им за неделю,");
        System.out.println("фамилию сборщика, собравшего наибольшее число изделий, и день,");
        System.out.println("когда он достиг наивысшей производительности труда.");
        System.out.println("В программе также реализованы следующие функции:");
        System.out.println("•ввод записей;");
        System.out.println("•корректировка записей;");
        System.out.println("•удаление записей;");
        System.out.println("•просмотр записей на экране.");
        System.out.println();
    }

    static void showHelpInfo(){
        System.out.println("!Открывать можно только сохранённые ранее данной программой таблцы записей!");
        System.out.println("Корректировка таблицы с помощью файла:");
        System.out.println("Для изменения содержимого ячеек: Корректировка записей -> С помощью файла -> Изменить.");
        System.out.println("(в файле должны содержаться(на каждой новой строчке):");
        System.out.println("индекс изменяемой ячейки, новая фамилия и кол-во деталей за каждый день);");
        System.out.println("Для добавления ячеек: Корректировка записей -> С помощью файла -> Добавить.");
        System.out.println("(в файле должны содержаться(на каждой новой строчке): фамилия и кол-во деталей за каждый день);");
        System.out.println("Для удаления(функция доступна для 2+ сборщиков) ячеек: Корректировка записей -> С помощью файла -> Удалить.");
        System.out.println("(в файле должны содержаться(на каждой новой строчке):индекс удаляемой ячейки).");
        System.out.println();
    }

    static void selectMainMenuItem(int menuItem) throws IOException, ClassNotFoundException {
        switch (menuItem) {
            case 1 -> readArrayOfRecordsFromFile();
            case 2 -> createArrayOfRecordsFromConsole();
            case 3 -> showInformationAboutProgram();
            case 4 -> showHelpInfo();
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        showMainMenu();
    }
}