package project;
import hhn.temp.project.Main;
import hhn.temp.project.Task;
import hhn.temp.project.TaskManager;
import hhn.temp.project.TaskStatus;
import hhn.temp.project.expections.*;
import hhn.temp.project.provider.MySql;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import static org.junit.jupiter.api.Assertions.*;

public class BadCaseTaskTest {

  private TaskManager taskManager;
  private String user = "hhn";
  private String password = "!9oSmhsiwYO.m)_x";
  private String db = "hhn";
  private String host = "home.luithardt.cloud";
  private String port = "3555";

  @BeforeEach
  public void setup() {
    Main main = new Main();

  }

  @Test
  @DisplayName("Create a new TaskManager and test Connecton")
  public void assertCreateNewTaskManager() {
    assertThrows(SQLNoConectionException.class,() -> taskManager = new TaskManager("deep", "deep", db, host, port));
    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(null, "deep", db, host, port));
    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, null, db, host, port));
    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, null, host, port));
    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, db, null, port));
    assertThrows(NullPointerException.class,() -> taskManager = new TaskManager(user, password, db, host, null));


  }

  @Test
  @DisplayName("Assert an IllegalArgumentException when you create a new Task with no or wrong Name, Description")
  public void assertExceptionOnCreateNewTask() {
    taskManager = new TaskManager(user, password, db, host, port);
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask("", null));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask(null, ""));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask(null, null));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask("", ""));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask("", "test"));
    assertThrows(IllegalArgumentException.class,() -> taskManager.createTask("ä#eadsew2", "test"));

    assertDoesNotThrow(() -> taskManager.resetTest());

  }

  @Test
  @DisplayName("Assert an IllegalArgumentException when you create a new Task with the same Name of a exits Task")
  public void assertExceptionOnCreateNewTaskWithExitsName() {
    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    assertDoesNotThrow(() -> taskManager.createTask(name, description));
    assertThrows(TaskAlreadyExistsException.class, () -> taskManager.createTask(name, description));

    assertDoesNotThrow(() -> taskManager.resetTest());

  }

  @Test
  @DisplayName("Assert an IllegalArgumentException when you edit a exits Task")
  public void assertExceptionOnEditATask() {
    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    Task task = taskManager.createTask(name, description);

    assertThrows(IllegalArgumentException.class, () -> task.setDescription(null));
    assertThrows(IllegalArgumentException.class, () -> task.setStatus(null));

    assertDoesNotThrow(() -> taskManager.resetTest());


  }

    @Test
    @DisplayName("Assert an IllegalArgumentException when calling a non-Existing Task")
    public void assertExceptionOnCallingANonextistingTask (){
      taskManager = new TaskManager(user, password, db, host, port);
      String wrongName = "Manager";
      String name = "Name";
      String description = "Description";
      Task task = taskManager.createTask(name, description);

      assertThrows(IllegalArgumentException.class, () -> taskManager.getTask(wrongName));
      assertThrows(IllegalArgumentException.class, () -> taskManager.getTask(23));

      assertDoesNotThrow(() -> taskManager.resetTest());

    }

  @Test
  @DisplayName("Assert an IllegalArgumentException when delete a existing Task with wrong arguments")
  public void assertExceptionOnDeletingTask (){
    taskManager = new TaskManager(user, password, db, host, port);
    String wrongName = "Manager";
    String name = "Name";
    String description = "Description";
    Task task = taskManager.createTask(name, description);

    assertThrows(IllegalArgumentException.class, () -> taskManager.deleteTask(null));
    assertThrows(IllegalArgumentException.class, () -> taskManager.deleteTask(""));
    assertThrows(IllegalArgumentException.class, () -> taskManager.deleteTask(wrongName));

    assertDoesNotThrow(() -> taskManager.resetTest());

  }

  @Test
  @DisplayName("Get a Exeption by setWorker and getWorker")
  public void assertExeptionBySetAndGetAuthorOfATask() {
    taskManager = new TaskManager(user, password, db, host, port);
    String name = "Name";
    String description = "Description";
    String workerName = "worker";

    Task task = taskManager.createTask(name, description);
    assertThrows(TaskHasNoWorkerException.class, () -> task.getWorker());
    assertThrows(IllegalArgumentException.class, () -> task.setWorker(null));
    assertThrows(IllegalArgumentException.class, () -> task.setWorker(""));
    assertThrows(IllegalArgumentException.class, () -> task.setWorker("ewrgi43rfoiw2öa#-"));

    assertDoesNotThrow(() -> taskManager.resetTest());

  }


  // MYSQL FILE TESTS


  @Test
  @DisplayName("Assert SQLNoConectionException when connect fails")
  public void assertSQLNoConectionExceptionOnConnect() {
    MySql mySql = new MySql("wrongUser", "wrongPassword", "wrongDb", host, port);
    assertThrows(SQLNoConectionException.class, mySql::connect);
  }

  @Test
  @DisplayName("Assert NullPointerException when reset without connect")
  public void assertNullPointerExceptionOnReset() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, mySql::reset);
  }

  @Test
  @DisplayName("Assert NullPointerException when createTask without connect")
  public void assertNullPointerExceptionOnCreateTask() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.createTask("Task", "Description"));
  }

  @Test
  @DisplayName("Assert NullPointerException when existTask(name) without connect")
  public void assertNullPointerExceptionOnExistTaskByName() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.existTask("Task"));
  }

  @Test
  @DisplayName("Assert NullPointerException when existTask(id) without connect")
  public void assertNullPointerExceptionOnExistTaskById() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.existTask(1));
  }

  @Test
  @DisplayName("Assert NullPointerException when deleteTask without connect")
  public void assertNullPointerExceptionOnDeleteTask() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.deleteTask("Task"));
  }

  @Test
  @DisplayName("Assert NullPointerException when updateDescription without connect")
  public void assertNullPointerExceptionOnUpdateDescription() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.updateDescription(1, "Desc"));
  }

  @Test
  @DisplayName("Assert NullPointerException when updateStatus without connect")
  public void assertNullPointerExceptionOnUpdateStatus() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.updateStatus(1, TaskStatus.OPEN));
  }

  @Test
  @DisplayName("Assert NullPointerException when updateWorker without connect")
  public void assertNullPointerExceptionOnUpdateWorker() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.updateWorker(1, "Worker"));
  }

  @Test
  @DisplayName("Assert NullPointerException when getTask(id) without connect")
  public void assertNullPointerExceptionOnGetTaskById() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.getTask(1));
  }

  @Test
  @DisplayName("Assert NullPointerException when getTask(name) without connect")
  public void assertNullPointerExceptionOnGetTaskByName() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, () -> mySql.getTask("Task"));
  }

  @Test
  @DisplayName("Assert NullPointerException when getTaskList without connect")
  public void assertNullPointerExceptionOnGetTaskList() {
    MySql mySql = new MySql(user, password, db, host, port);
    assertThrows(NullPointerException.class, mySql::getTaskList);
  }

  @Test
  @DisplayName("Assert TaskNotExistsException when getTask(id) finds no task")
  public void assertTaskNotExistsExceptionOnGetTaskById() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();
    mySql.reset();

    assertThrows(
            TaskNotExistsException.class,
            () -> mySql.getTask(9999)
    );
  }

  @Test
  @DisplayName("Assert TaskNotExistsException when getTask(name) finds no task")
  public void assertTaskNotExistsExceptionOnGetTaskByName() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();
    mySql.reset();

    assertThrows(
            TaskNotExistsException.class,
            () -> mySql.getTask("does-not-exist")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when getTask(id) causes SQLException")
  public void assertSQLStatmentExceptionOnGetTaskById()  {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.getTask(1)
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when getTask(name) causes SQLException")
  public void assertSQLStatmentExceptionOnGetTaskByName()  {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));
    assertThrows(
            SQLStatmentException.class,
            () -> mySql.getTask("Task")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when getTaskList causes SQLException")
  public void assertSQLStatmentExceptionOnGetTaskList()  {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            mySql::getTaskList
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when existTask causes SQLException")
  public void assertSQLStatmentExceptionOnExistTask() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.existTask(1)
    );
  }
  @Test
  @DisplayName("Assert SQLStatmentException when existTask causes SQLException")
  public void assertSQLStatmentExceptionOnExistTaskWithString() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.existTask("adada")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when updateDescription causes SQLException")
  public void assertSQLStatmentExceptionOnUpdateDescription() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.updateDescription(1, "desc")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when updateStatus causes SQLException")
  public void assertSQLStatmentExceptionOnUpdateStatus() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.updateStatus(1, TaskStatus.OPEN)
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when updateWorker causes SQLException")
  public void assertSQLStatmentExceptionOnUpdateWorker() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.updateWorker(1, "worker")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when deleteTask causes SQLException")
  public void assertSQLStatmentExceptionOnDeleteTask()  {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.deleteTask("task")
    );
  }

  @Test
  @DisplayName("Assert SQLStatmentException when createTask causes SQLException")
  public void assertSQLStatmentExceptionOnCreateTask() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();

    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(
            SQLStatmentException.class,
            () -> mySql.createTask("Task", "Description")
    );
  }
  @Test
  @DisplayName("Assert SQLStatmentException when reset causes SQLException")
  void assertSQLStatmentExceptionOnReset() {
    MySql mySql = new MySql(user, password, db, host, port);
    mySql.connect();
    assertDoesNotThrow(() ->closeConnectionViaReflection(mySql));

    assertThrows(SQLStatmentException.class, mySql::reset);
  }

  private void closeConnectionViaReflection(MySql mySql) throws Exception {
    Field connectionField = MySql.class.getDeclaredField("connection");
    connectionField.setAccessible(true);
    Connection connection = (Connection) connectionField.get(mySql);
    connection.close();
  }



}