Lab_5_1

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

class Node {
    int data;
    Node next;

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}

class LinkedList {
    public Node head;

    public LinkedList(Node head) {
        this.head = head;
    }

    public void insertNode(int value) {
        Node newNode = new Node(value, null);
        if (head.next == null) {
            head.next = newNode;
        } else {
            Node currentNode = head.next;
            while (true) {
                if (currentNode.next == null) {
                    currentNode.next = newNode;
                    return;
                } else {
                    currentNode = currentNode.next;
                }
            }
        }
    }

    public boolean deleteNode(int value)
    {
        Node curr = head.next;
        if (curr == null) {
            System.out.println("Данный список пуст!");
            return true;
        }
        if (curr.data == value) {
            head.next = curr.next;
            return true;
        }
        while (curr.next != null) {
            if (curr.next.data == value) {
                curr.next = curr.next.next;
                return true;
            }
            curr = curr.next;
        }
        if (curr.data == value) {
            curr = null;
            return true;
        }
        return false;
    }

    public void printList()
    {
        Node curr = head.next;
        if (curr != null) {
            while (curr != null)
            {
                System.out.print(curr.data + " ");
                curr = curr.next;
            }
        } else {
            System.out.print("В списке не найдено элементов!");
        }
    }
}

public class Main {

    static final int MAX_OPERATION_COUNT = 4;
    static final int MIN_OPERATION_COUNT = 0;
    static final int MIN_DATA = -9999;
    static final int MAX_DATA = 9999;
    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {
        Node head = new Node(0, null);
        LinkedList list = new LinkedList(head);
        writeTask();
        System.out.println("Получить записи из файла? 1 - да, 2 - нет");
        int choice = chooseInputOutputMethod();
        if (choice == 1) {
            addListFromFile(list);
            System.out.print("Текущий список: ");
            list.printList();
            System.out.println();
        }
        boolean isContinue = true;
        do {
            choice = chooseOperation();
            switch (choice) {
                case 1:
                    list = addNewElement(list);
                    System.out.print("Текущий список: ");
                    list.printList();
                    System.out.println();
                    break;
                case 2:
                    list = deleteElement(list);
                    System.out.print("Текущий список: ");
                    list.printList();
                    System.out.println();
                    break;
                case 3:
                    list = changeList(list);
                    System.out.print("Текущий список: ");
                    list.printList();
                    System.out.println();
                    break;
                case 4:
                    saveListToFile(list);
                    break;
                case 0:
                    isContinue = false;
                    break;
            }
        } while (isContinue);
        scan.close();
    }

    public static void writeTask() {
        System.out.println("Данная программа работает с односвязным списком.");
        System.out.println("Список операций: 1. Добавление нового элемента.");
        System.out.println("                 2. Удаление элемента.");
        System.out.println("                 3. Добавление после каждого элемента списка предшествующую ему часть.");
        System.out.println("                 4. Сохранение списка в файл.");
        System.out.println("                 0. Завершение работы.");
    }

    public static int chooseOperation() {
        int choice = 0;
        boolean isNotCorrect;
        do {
            System.out.println("Введите номер операции, которую необходимо выполнить.");
            isNotCorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                isNotCorrect = true;
                System.out.println("Некорректно введён номер операции. Повторите попытку.");
            }
            if ((!isNotCorrect) && (choice > MAX_OPERATION_COUNT || choice < MIN_OPERATION_COUNT)) {
                isNotCorrect = true;
                System.out.println("Введён неправильный номер операции. Он должен быть от " + MIN_OPERATION_COUNT + " до " + MAX_OPERATION_COUNT + ". Повторите попытку.");
            }
        } while (isNotCorrect);
        return choice;
    }

    public static LinkedList addNewElement(LinkedList list) {
        boolean isNotCorrect;
        int data = 0;
        do {
            isNotCorrect = false;
            System.out.println("Введите элемент, добавляемый в список (от -9999 до 9999)");
            try {
                data = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                isNotCorrect = true;
                System.out.println("Некорректно введено число");
            }
            if ((!isNotCorrect) && (data < MIN_DATA || data > MAX_DATA)) {
                isNotCorrect = true;
                System.out.println("Значение элемента должно быть от " + MIN_DATA + " до " + MAX_DATA);
            }
        } while (isNotCorrect);
        list.insertNode(data);
        return list;
    }

    public static LinkedList deleteElement(LinkedList list) {
        boolean isNotCorrect;
        int data = 0;
        do {
            isNotCorrect = false;
            System.out.println("Введите элемент, удаляемый из дерева (от -9999 до 9999)");
            try {
                data = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                isNotCorrect = true;
                System.out.println("Некорректно введено число");
            }
            if ((!isNotCorrect) && (data < MIN_DATA || data > MAX_DATA)) {
                isNotCorrect = true;
                System.out.println("Номер формата должен быть от " + MIN_DATA + " до " + MAX_DATA);
            }
        } while (isNotCorrect);
        if (!(list.deleteNode(data))) {
            System.out.println("Удаляемый элемент не найден в списке!");
        }
        return list;
    }

    public static LinkedList copyList(Node head) {
        Node curr = new Node(head.next.data, head.next.next);
        Node newStart = new Node(0, null);
        LinkedList newList = new LinkedList(newStart);
        while (curr != null) {
            newList.insertNode(curr.data);
            curr = curr.next;
        }
        return newList;
    }

    public static Node replaceElement(Node prev, Node next, int value) {
        Node temp = new Node(value, next);
        prev.next = temp;
        return prev;
    }

    public static LinkedList changeList(LinkedList oldList) {
        if (oldList.head.next != null) {
            LinkedList newList = copyList(oldList.head);
            Node newStart = new Node(0, newList.head.next);
            Node newElement = new Node(newStart.next.data, newStart.next.next);
            Node curr = oldList.head.next;
            Node temp;
            Node interimNode;
            int newData;
            while (curr != null && newElement != null) {
                temp = oldList.head.next;
                newData = oldList.head.next.data;
                while (temp != curr) {
                    newElement = replaceElement(newElement, newElement.next, newData);
                    newElement = newElement.next;
                    temp = temp.next;
                    if (temp != curr) {
                        newData = temp.data;
                    }
                }
                curr = curr.next;
                newElement = newElement.next;
            }
            return newList;
        } else {
            System.out.println("В списке нет элементов!");
            return oldList;
        }
    }

    public static int chooseInputOutputMethod() {
        boolean isNotCorrect;
        int choice = 0;
        do {
            isNotCorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Число введено некорректно. Повторите попытку...");
                isNotCorrect = true;
            }
            if ((!isNotCorrect) && (choice != 1) && (choice != 2)) {
                System.out.print("Введите либо 1, либо 2. Ваш выбор: ");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return choice;
    }

    public static String takePathToFile() {
        String path;
        boolean isNotCorrect;
        do {
            isNotCorrect = false;
            System.out.println("Введите путь к файлу: ");
            path = scan.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                System.out.println("Не удалось найти файл по заданному пути. Повторите попытку...");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return path;
    }

    public static LinkedList addListFromFile(LinkedList oldList) {
        String path;
        boolean isNotCorrect;
        boolean isEmpty = true;
        int element;
        Node head = new Node(0, null);
        LinkedList list = new LinkedList(head);
        do {
            list = oldList;
            path = takePathToFile();
            isNotCorrect = false;
            try (Scanner fileReader = new Scanner(new File(path))) {
                try {
                    while (fileReader.hasNextLine()) {
                        element = Integer.parseInt(fileReader.nextLine());
                        if ((!isNotCorrect) && (element < MIN_DATA || element > MAX_DATA)) {
                            isNotCorrect = true;
                            System.out.println("Значение элемента должно быть от " + MIN_DATA + " до " + MAX_DATA);
                        }
                        if (!isNotCorrect) {
                            list.insertNode(element);
                            isEmpty = false;
                        }
                    }
                } catch (NumberFormatException e) {
                    isNotCorrect = true;
                    System.out.println("Некорректно введено одно из значений в файле. Попробуйте заново.");
                }
            } catch (IOException e) {
                isNotCorrect = true;
                System.out.println("Не выходит получить данные из файла. Попробуйте ещё раз.");
            }
            if ((!isNotCorrect) && (isEmpty)) {
                isNotCorrect = true;
                System.out.println("Введён пустой файл. Попробуйте ещё раз.");
            }
        } while (isNotCorrect);
        System.out.println("Список получен");
        return list;
    }

    public static void saveListToFile(LinkedList list) {
        Node curr = list.head.next;
        int element;
        if (curr != null) {
            System.out.print("Требуется файл для записи ответа. ");
            String path = takePathToFile();
            boolean isNotCorrect;
            do {
                isNotCorrect = false;
                try (FileWriter fileWriter = new FileWriter(new File(path))) {
                    while (curr != null) {
                        element = curr.data;
                        fileWriter.write(element + "\n");
                        curr = curr.next;
                    }
                } catch (IOException ex) {
                    isNotCorrect = true;
                    System.out.print("Произошла ошибка записи в файл. ");
                }
                if (isNotCorrect) {
                    System.out.println("Повторите попытку...");
                    path = takePathToFile();
                }
            } while (isNotCorrect);
            System.out.println("Список сохранён в файл!");
        } else {
            System.out.println("Текущий список пуст!");
        }
    }
}