GseTDDUebungKCLR/src/main/java/hhn/temp/project/provider/SimpleDatabaseManager.java

package hhn.temp.project.provider;

import hhn.temp.project.Task;
import hhn.temp.project.TaskState;
import hhn.temp.project.Worker;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.*;
import java.util.*;

public class SimpleDatabaseManager implements DatabaseManager {

  private Connection connection;

  private final static Path INSERT_TASK = Path.of("resources/sql/InsertTaskTable.sql");
  private final static Path DELETE_TASK = Path.of("resources/sql/DeleteTaskTable.sql");
  private final static Path SELECT_TASK = Path.of("resources/sql/SelectTaskTable.sql");
  private final static Path UPDATE_TASK = Path.of("resources/sql/UpdateTaskTable.sql");
  private final static Path COUNT_ALL_TASK = Path.of("resources/sql/CountAllFieldsTask.sql");
  private final static Path SELECT_ALL_TASK = Path.of("resources/sql/SelectAllFieldsTask.sql");
  private final static Path SELECT_TASK_BY_ID = Path.of("resources/sql/SelectTaskById.sql");
  private final static Path INSERT_WORKER = Path.of("resources/sql/InsertWorkerTable.sql");
  private final static Path DELETE_WORKER = Path.of("resources/sql/DeleteWorkerTable.sql");
  private final static Path SELECT_WORKER = Path.of("resources/sql/SelectWorkerTable.sql");
  private final static Path UPDATE_WORKER = Path.of("resources/sql/UpdateWorkerTable.sql");
  private final static Path COUNT_ALL_WORKER = Path.of("resources/sql/CountAllFieldsWorker.sql");
  private final static Path SELECT_ALL_WORKER = Path.of("resources/sql/SelectAllFieldsWorker.sql");
  private final static Path SELECT_WORKER_BY_ID = Path.of("resources/sql/SelectWorkerById.sql");

  public enum QueryMode {
    INSERT_TASK,
    SELECT_TASK,
    UPDATE_TASK,
    DELETE_TASK,
    SELECT_ALL_TASK,
    SELECT_TASK_BY_ID,
    COUNT_ALL_TASK,
    INSERT_WORKER,
    SELECT_WORKER,
    UPDATE_WORKER,
    DELETE_WORKER,
    COUNT_ALL_WORKER,
    SELECT_ALL_WORKER,
    SELECT_WORKER_BY_ID,
  }

  public String loadFile(QueryMode queryMode) throws IOException {
    switch (queryMode) {
      case INSERT_TASK -> {
        return Files.readString(INSERT_TASK);
      }
      case SELECT_TASK -> {
        return Files.readString(SELECT_TASK);
      }
      case DELETE_TASK -> {
        return Files.readString(DELETE_TASK);
      }
      case UPDATE_TASK -> {
        return Files.readString(UPDATE_TASK);
      }
      case COUNT_ALL_TASK -> {
        return Files.readString(COUNT_ALL_TASK);
      }
      case SELECT_ALL_TASK -> {
        return Files.readString(SELECT_ALL_TASK);
      }
      case SELECT_TASK_BY_ID -> {
        return Files.readString(SELECT_TASK_BY_ID);
      }
      case INSERT_WORKER -> {
        return Files.readString(INSERT_WORKER);
      }
      case SELECT_WORKER -> {
        return Files.readString(SELECT_WORKER);
      }
      case DELETE_WORKER -> {
        return Files.readString(DELETE_WORKER);
      }
      case UPDATE_WORKER -> {
        return Files.readString(UPDATE_WORKER);
      }
      case COUNT_ALL_WORKER -> {
        return Files.readString(COUNT_ALL_WORKER);
      }
      case SELECT_ALL_WORKER -> {
        return Files.readString(SELECT_ALL_WORKER);
      }
      case SELECT_WORKER_BY_ID -> {
        return Files.readString(SELECT_WORKER_BY_ID);
      }
      default -> {
        return "";
      }
    }
  }

  private TaskState integerToTaskState(final int in) {
    return in == 1 ? TaskState.FINISHED : TaskState.IN_PROGRESS;
  }

  private int taskStateToInteger(final TaskState taskState) {
    return taskState == TaskState.FINISHED ? 1 : 0;
  }

  @Override
  public void saveTask(final Task task) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.INSERT_TASK);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setInt(1, task.getTaskId());
      preparedStatement.setString(2, task.getName());
      preparedStatement.setString(3, task.getDescription());
      preparedStatement.setInt(4, task.getWorkerId());
      preparedStatement.setInt(5, taskStateToInteger(task.getTaskState()));
      preparedStatement.execute();
    }
  }

  @Override
  public void saveTasks(final Collection<Task> tasks) throws SQLException {
    for (Task task : tasks) {
      saveTask(task);
    }
  }

  @Override
  public void saveWorker(final Worker worker) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.INSERT_WORKER);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setInt(1, worker.getId());
      preparedStatement.setString(2, worker.getName());
      preparedStatement.execute();
    }
  }

  @Override
  public void saveWorkers(final Collection<Worker> workers) throws SQLException {
    for (Worker worker : workers) {
      saveWorker(worker);
    }
  }

  @Override
  public void updateTask(final int taskId, final Task newTaskObject) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.UPDATE_TASK);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setString(1, newTaskObject.getName());
      preparedStatement.setString(2, newTaskObject.getDescription());
      preparedStatement.setInt(3, taskStateToInteger(newTaskObject.getTaskState()));
      preparedStatement.setInt(4, taskId);
      preparedStatement.execute();
    }
  }

  @Override
  public void updateWorker(final int workerId, final Worker newWorkerObject) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.UPDATE_WORKER);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setInt(1, newWorkerObject.getId());
      preparedStatement.setString(2, newWorkerObject.getName());
      preparedStatement.setInt(3, workerId);
      preparedStatement.execute();
    }
  }

  @Override
  public void deleteTask(final int taskId) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.DELETE_TASK);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setInt(1, taskId);
      preparedStatement.execute();
    }
  }

  @Override
  public void deleteWorker(final int workerId) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.DELETE_WORKER);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return;
    }
    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
      preparedStatement.setInt(1, workerId);
      preparedStatement.execute();
    }
  }

  @Override
  public Collection<Task> getTasks() throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.SELECT_ALL_TASK);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return null;
    }

    Collection<Task> tasks = new ArrayList<>();

    try (Statement statement = connection.createStatement();
         ResultSet rs = statement.executeQuery(query);) {

      while (rs.next()) {
            int taskId = rs.getInt("taskid");
            String name = rs.getString("name");
            String description = rs.getString("description");
            int workerId = rs.getInt("workerid");
            TaskState taskState = integerToTaskState(rs.getInt("taskstate"));

            Task task = new Task(taskId, workerId, name, description);
            task.setTaskState(taskState);

            tasks.add(task);
      }

    }

    return tasks;
  }

  @Override
  public Collection<Worker> getWorkers() throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.SELECT_ALL_WORKER);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return null;
    }

    Collection<Worker> workers = new ArrayList<>();

    try (Statement statement = connection.createStatement();
         ResultSet rs = statement.executeQuery(query);) {

      while (rs.next()) {
        int workerId = rs.getInt("workerid");
        String name = rs.getString("name");

        Worker worker = new Worker(name, workerId);

        workers.add(worker);
      }

    }

    return workers;
  }

  @Override
  public Task getTaskByTaskId(final int taskId) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.SELECT_TASK_BY_ID);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return null;
    }

    try (PreparedStatement statement = connection.prepareStatement(query);) {

      statement.setInt(1, taskId);

      ResultSet rs = statement.executeQuery();

      while (rs.next()) {
        int taskId1 = rs.getInt("taskid");
        String name = rs.getString("name");
        String description = rs.getString("description");
        int workerId = rs.getInt("workerid");
        TaskState taskState = integerToTaskState(rs.getInt("taskstate"));

        Task task = new Task(taskId1, workerId, name, description);
        task.setTaskState(taskState);

        return task;
      }

    }

    return null;
  }

  @Override
  public Worker getWorkerByWorkerId(final int workerId) throws SQLException {
    String query;
    try {
      query = loadFile(QueryMode.SELECT_WORKER_BY_ID);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return null;
    }

    try (PreparedStatement statement = connection.prepareStatement(query);) {

      statement.setInt(1, workerId);

      ResultSet rs = statement.executeQuery();

      while (rs.next()) {
        int workerId1 = rs.getInt("workerid");
        String name = rs.getString("name");

        Worker worker = new Worker(name, workerId1);

        return worker;
      }

    }

    return null;
  }

  @Override
  public int getTotalNumberOfTasks() throws SQLException {
    String query = "";
    try {
      query = loadFile(QueryMode.COUNT_ALL_TASK);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return -1;
    }
    try (Statement statement = connection.createStatement();
         ResultSet rs = statement.executeQuery(query);) {

      if (rs.next()) {
        return rs.getInt("total");
      }
    }

    return 0;
  }

  @Override
  public int getTotalNumberOfWorkers() throws SQLException {
    String query = "";
    try {
      query = loadFile(QueryMode.COUNT_ALL_WORKER);
    } catch (IOException e) {
      System.err.println(e.getStackTrace());
      return -1;
    }
    try (Statement statement = connection.createStatement();
         ResultSet rs = statement.executeQuery(query);) {

      if (rs.next()) {
        return rs.getInt("total");
      }
    }

    return 0;
  }

  public void clearDatabase() throws SQLException {
    try (Statement statement = connection.createStatement()) {
      statement.execute("TRUNCATE TABLE Task");
      statement.execute("TRUNCATE TABLE Worker");
    }
  }

  @Override
  public void connect() throws SQLException {
    connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/sql7810540?user=sql7810540&password=mXdJCFtDZz");
  }

  @Override
  public void close() throws SQLException {
    connection.close();
  }
}