src/main/java/ru/gitflic/classes/ConsoleView.java - master - nikolay470/algorithm_implementation

src/main/java/ru/gitflic/classes/ConsoleView.java
561 строка16 KB
nikolay94
Коммит перед сменой ОС
21 июн 2026, 19:09
21 июн 2026, 19:0924ae6bf
package ru.gitflic.classes;

import java.io.PrintStream;
import java.util.Scanner;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Arrays;

import ru.gitflic.enums.MenuItems;
import ru.gitflic.enums.ZonesTypes;
import ru.gitflic.exceptions.GoBack;

public abstract class ConsoleView {

   private static final Scanner scanner = new Scanner(System.in);
   private static String inputUser = "";
   public static final PrintStream console = System.out;

   public static MenuItems mainMenu() {
      String mainMenu = new StringBuilder().append("Выберите действие (введите номер): \n")
         .append("1) Размещение с производства \n")
         .append("2) Перемещение \n")
         .append("3) Отбор \n")
         .append("4) Компрессия \n")
         .append("5) Остатки товаров \n")
         .append("6) Выход \n")
         .toString();

      while (true) {

         console.println( mainMenu );
         console.print("Ввод: ");
         inputUser = scanner.nextLine();

         try {

            int res = Integer.parseInt( inputUser );
            if ( res > 0 && res < 7 ) {

               switch (res) {
                  case 1:
                     return MenuItems.PLACEMENT;
                  case 2:
                     return MenuItems.MOVING;
                  case 3:
                     return MenuItems.SELECTION;
                  case 4:
                     return MenuItems.COMPRESSION;
                  case 5:
                     return MenuItems.REMNANT_OF_PRODUCTS;
                  case 6:
                     return MenuItems.EXIT;
               }

            } else {
               throw new NumberFormatException("Введенное значение не корректно.");
            }

         } catch (NumberFormatException exception) {
            console.println(exception.getMessage());
         }

      }
   }

   public static MenuItems submenuSelection() throws GoBack {
      String menu = new StringBuilder().append( "Выберите действие (введите номер): \n" )
         .append("1) ЗКО коробки \n")
         .append("2) ЗКО остатки \n")
         .append("3) ЗПХ паллеты \n")
         .append("4) Вернуться \n")
         .toString();

      while (true) {

         console.println(menu);
         console.print("Ввод: ");
         inputUser = scanner.nextLine();

         try {

            int res = Integer.parseInt( inputUser );
            if (res > 0 && res < 5) {

               switch (res) {
                  case 1:
                     return MenuItems.SELECTION_BOXES;
                  case 2:
                     return MenuItems.SELECTION_REMNANT;
                  case 3:
                     return MenuItems.ZONE_PALLET_STORAGE;
                  case 4:
                     throw new GoBack();
               }

            } else {
               throw new NumberFormatException("Введенное значение некорректно.");
            }

         } catch (NumberFormatException exception) {
            console.println(exception.getMessage());
         }

      }
   }

   public static int pickUpThePalletFromAcceptance(
      HashMap<Integer, Pallet> palletsOnAcceptance) throws GoBack {

      while (true) {
         printListPalletsOnAcceptance((ArrayList<Pallet>) palletsOnAcceptance.values());
         getNumberPalletSheet();

         try {

            return checkNumberPalletSheet(palletsOnAcceptance);

         } catch (NumberFormatException exception) {
            console.println("Введенное значение не корректно.");
         }

      }
   }

   public static int pickUpPallet(ArrayList<Integer> listPalletSheets) throws GoBack {

      while (true) {

         getNumberPalletSheet();
         try {

            checkNumberPalletSheet(listPalletSheets);

         } catch (NumberFormatException exception) {
            console.println("Палет не найден.");
         }

      }
   }

   public static Address queryOnPlacementThePallet(
      Address recommendedAddress,
      int quantPlacesInCell) {

      Integer indexHall = 0;
      Integer indexRack = 1;
      Integer indexTier = 2;
      Integer indexPlace = 3;

      while (true) {

         console.println( "Введите адрес ячейки в формате 3-2-1-10" );

         if (recommendedAddress != null) {

            console.println("Рекомендуемая ячейка "
               + recommendedAddress + "\n"
               + "Осталось мест: " + quantPlacesInCell);

         }

         console.print("Ввод: ");
         inputUser = scanner.nextLine();

         try {

            return checkAddressOnValidity(
               indexHall,
               indexRack,
               indexTier,
               indexPlace);

         } catch (NumberFormatException exception) {
            console.println( "Адрес не найден" );
         }
      }
   }

   public static Address placementThePalletInCellShipment() {

      while (true) {
         console.println( "Разместите паллет в ячейку отгрузки (введите 888)" );
         inputUser = scanner.nextLine();

         try {

            int code = Integer.parseInt(inputUser);
            if (code == 888) {
               return new Address().cellShipment();
            } else {
               throw new NumberFormatException("Введен неверный код ячейки отгрузки.");
            }

         } catch (NumberFormatException e) {
            console.println(e.getMessage());
         }

      }

   }

   public static int selectionOrderOnShipment(
      HashMap<Integer, OrderOnShipment> orders) throws GoBack {

      while ( true ) {
         getNumberOrderOnShipment(orders);

         try {

            return checkNumberOfOrderOnShipment(orders);

         } catch (NumberFormatException exception) {
            console.println(exception.getMessage());
         }

      }
   }

   public static Pallet printTaskOnSelectionFromZonePalletStorage(
      OrderOnShipment order, Address currentAddress) throws GoBack {

      while (true) {

         String task = new StringBuilder()
            .append("Заказ №" + order.number + "\n")
            .append("Получатель: " + order.recipient + "\n")
            .append("Ячейка: " + currentAddress + "\n")
            .append("Номер ПЛ: " + order.fullPallets.get(currentAddress).getFirst().numberPalletSheet)
            .toString();

         console.println(task);
         getNumberPalletSheet();

         try {

            return checkNumberPalletSheet_SelectionFullPallets(order, currentAddress);

         } catch (NumberFormatException exception) {
            console.println(exception.getMessage());
         }

      }
   }

   public static Pallet printTaskOnSelectionRemnant(
      OrderOnShipment order,
      Address currentAddress) throws GoBack {

      while (true) {
         String task = new StringBuilder()
            .append("Заказ №" + order.number + "\n")
            .append("Получатель: " + order.recipient + "\n")
            .append("Ячейка: " + currentAddress + "\n")
            .append("Номер ПЛ: " + order.remnants.get(currentAddress).numberPalletSheet)
            .toString();

         console.println(task);
         getNumberPalletSheet();

         try {

            return checkNumberPalletSheet_SelectionRemnants(order, currentAddress);

         } catch (NumberFormatException ex) {
            console.println(ex.getMessage());
         }
      }
   }

   public static void printCompression( ArrayList<PrintedCell> printedCells ) {
      for ( PrintedCell cell : printedCells ) {
         console.println( cell.address + " - " + cell.getQuantPalletsInCell() + " паллет." );
      }
   }

   public static void printListPalletsOnAcceptance(
      ArrayList<Pallet> palletsOnAcceptance) {

      console.println( "Пикните паллет или введите \"назад\"" );
      int count = 1;
      for (Pallet pallet : palletsOnAcceptance) {

         console.println(count + ") " + "№ПЛ: "
            + pallet.numberPalletSheet + ",\n"
            + pallet.product.toString() + "\n");
         count++;

      }
   }

   private static int checkNumberPalletSheet(
      HashMap<Integer, Pallet> palletsOnAcceptance) throws NumberFormatException {

      int numberPalletSheet = Integer.parseInt(inputUser);
      for (Pallet pallet : palletsOnAcceptance.values()) {
         if (pallet.numberPalletSheet == numberPalletSheet) {
            return numberPalletSheet;
         }
      }
      throw new NumberFormatException();
   }

   private static int checkNumberPalletSheet(
     ArrayList<Integer> listPalletSheets) throws NumberFormatException {

      int numberPalletSheet = Integer.parseInt(inputUser);
      if (listPalletSheets.contains(numberPalletSheet)) {
         return numberPalletSheet;
      } else {
         throw new NumberFormatException();
      }
   }

   private static Pallet checkNumberPalletSheet_SelectionFullPallets(
      OrderOnShipment order, Address currentAddress) throws NumberFormatException {

      int numberPalletSheet = Integer.parseInt(inputUser);
      for (Pallet pallet : order.fullPallets.get(currentAddress)) {

         if (pallet.numberPalletSheet == numberPalletSheet) {
            return pallet;
         }

      }

      throw new NumberFormatException( "Паллет не найден в ячейке!" );
   }

   private static Pallet checkNumberPalletSheet_SelectionRemnants(
      OrderOnShipment order, Address currentAddress) throws NumberFormatException {

      int numberPalletSheet = Integer.parseInt(inputUser);
      Pallet pallet = order.remnants.get(currentAddress);

      if (pallet.numberPalletSheet == numberPalletSheet) {
         return pallet;
      } else {
         throw new NumberFormatException("Не тот паллет!");
      }
   }

   private static void getNumberPalletSheet() throws GoBack {

      console.println( "Введите номер ПЛ (\"назад\" для возврата)" );
      console.print("Ввод: ");
      inputUser = scanner.nextLine();

      if ( inputUser.equalsIgnoreCase("назад")) {
         throw new GoBack();
      }
   }

   private static Address checkOnPlacementInTheZone() throws NumberFormatException {

      switch (inputUser) {
         case "111" -> new Address(ZonesTypes.BUFFERED_ZONE);
         case "777" -> new Address().cellProblem();
         case "888" -> new Address().cellShipment();
      }

      throw new NumberFormatException();
   }

   private static boolean checkAddressForHall_3(
      Integer[] parametersAddress,
      Integer indexRack,
      Integer indexTier,
      Integer indexPlace) {

      return switch (parametersAddress[indexRack]) {
         case
            1,
            4 -> {
            if (parametersAddress[indexTier] >= 1
               && parametersAddress[indexTier] <= 7) {

               if (parametersAddress[indexPlace] >= 1
                  && parametersAddress[indexPlace] <= 18) {

                  yield true;
               }
            }
            yield false;
         }
         case
            2 -> {
            if (parametersAddress[indexTier] >= 1
               && parametersAddress[indexTier] <= 6) {

               if (parametersAddress[indexPlace] >= 1
                  && parametersAddress[indexPlace] >= 20) {

                  yield true;
               }
            }
            yield false;
         }
         default ->
            false;
      };

   }

   private static boolean checkAddressForHall_4(
      Integer[] parametersAddress,
      Integer indexRack,
      Integer indexTier,
      Integer indexPlace) {

      return switch (parametersAddress[indexRack]) {
         case
            1, 2, 3, 4, 5, 6, 7, 8 -> {

            if (parametersAddress[indexTier] >= 1
               && parametersAddress[indexTier] <= 6) {

               if (parametersAddress[indexPlace] >= 1
                  && parametersAddress[indexPlace] <= 27) {

                  yield true;
               }
            }

            yield false;
         }

         default ->
            false;
      };

   }

   private static boolean checkAddressForHall_1(
      Integer[] parametersAddress,
      Integer indexRack,
      Integer indexTier,
      Integer indexPlace) {

      return switch (parametersAddress[indexRack]) {

         case
            1, 2, 3, 4, 5, 6, 7 -> {

            if (parametersAddress[indexTier] >= 1
               && parametersAddress[indexTier] <= 5) {

               if (parametersAddress[indexPlace] >= 1
                  && parametersAddress[indexPlace] <= 31) {

                  yield true;
               }
            }
            yield false;
         }

         case
            8, 9, 10, 11 -> {

            if (parametersAddress[indexTier] >= 1
               && parametersAddress[indexTier] <= 4) {

               if (parametersAddress[indexPlace] >= 1
                  && parametersAddress[indexPlace] <= 31) {

                  yield true;
               }
            }
            yield false;
         }

         default ->
            false;
      };
   }

   private static Address checkAddressOnValidity(
      Integer indexHall,
      Integer indexRack,
      Integer indexTier,
      Integer indexPlace) throws NumberFormatException {

      Integer[] parametersAddress =
         Arrays.stream(inputUser.replace(" ", "").split("-"))
            .mapToInt(Integer::parseInt).boxed()
            .toArray(Integer[]::new);

      boolean addressIsValid = false;

      if ((parametersAddress[indexHall] >= 1 && parametersAddress[indexHall] <= 4)
         && (parametersAddress[indexRack] >= 1 && parametersAddress[indexRack] <= 11)
         && (parametersAddress[indexTier] >= 1 && parametersAddress[indexTier] <= 7)
         && (parametersAddress[indexPlace] >= 1 && parametersAddress[indexPlace] <= 31)) {

         if (parametersAddress[indexHall] == 3) {

            addressIsValid = checkAddressForHall_3(
               parametersAddress,
               indexRack,
               indexTier,
               indexPlace);

         } else if (parametersAddress[indexHall] == 4) {

            addressIsValid = checkAddressForHall_4(
               parametersAddress,
               indexRack,
               indexTier,
               indexPlace);

         } else if (parametersAddress[indexHall] == 1) {
            addressIsValid = checkAddressForHall_1(
               parametersAddress,
               indexRack,
               indexTier,
               indexPlace);
         }

         if (addressIsValid) {

            return new Address(
               parametersAddress[indexHall],
               parametersAddress[indexRack],
               parametersAddress[indexTier],
               parametersAddress[indexPlace]);

         } else {
            throw new NumberFormatException();
         }

      } else {
         return checkOnPlacementInTheZone();
      }
   }

   private static void getNumberOrderOnShipment(
      HashMap<Integer, OrderOnShipment> orders) throws GoBack {

      console.println( "Выберите заказ (введите номер заказа) или введите \"назад\":" );

      for ( OrderOnShipment orderOnShipment : orders.values() ) {
         console.println("№" + orderOnShipment.number + " получатель: " + orderOnShipment.recipient);
      }

      console.print("Ввод: ");
      inputUser = scanner.nextLine();

      if ( inputUser.equalsIgnoreCase("назад")) {
         throw new GoBack();
      }
   }

   private static int checkNumberOfOrderOnShipment(
      HashMap<Integer, OrderOnShipment> orders) throws NumberFormatException {

      int numberOrder = Integer.parseInt(inputUser);
      if (orders.containsKey(numberOrder)) {
         return numberOrder;
      }
      throw new NumberFormatException("Заказ не найден в списке.");
   }
}