package at.ac.tuwien.sepm.assignment.groupphase.demeter.dao;

import at.ac.tuwien.sepm.assignment.groupphase.demeter.dao.InterfacesDAO.IDishDAO;
import at.ac.tuwien.sepm.assignment.groupphase.demeter.dao.InterfacesDAO.IImageManagementDAO;
import at.ac.tuwien.sepm.assignment.groupphase.demeter.dto.Allergen;
import at.ac.tuwien.sepm.assignment.groupphase.demeter.dto.Dish;
import at.ac.tuwien.sepm.assignment.groupphase.demeter.dto.DishSearch;
import at.ac.tuwien.sepm.assignment.groupphase.demeter.dto.Ingredient;
import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
import at.ac.tuwien.sepm.assignment.groupphase.util.Category;
import at.ac.tuwien.sepm.assignment.groupphase.util.JDBCConnectionManager;
import net.jcip.annotations.NotThreadSafe;
import org.junit.*;
import org.junit.rules.ErrorCollector;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@NotThreadSafe
public class DishDAOTest {
    private static final JDBCConnectionManager jdbcConnectionManager = mock(JDBCConnectionManager.class);
    private static Connection connection;
    private static final JDBCConnectionManager errorConnectionManager = mock(JDBCConnectionManager.class);
    private static final Connection errorConnection = mock(Connection.class);
    private static final String CONNECTION_URL = "jdbc:h2:mem:;INIT=RUNSCRIPT FROM 'classpath:sql/Test.sql'";
    private static IImageManagementDAO imageManagementDAO=mock(ImageHybridDB.class);
    private static IDishDAO dishDAO;
    private static IDishDAO errorDishDAO;
    private DishSearch validSearch;

    @Rule
    public ErrorCollector err = new ErrorCollector();

    @SuppressWarnings("MagicConstant")
    @BeforeClass
    public static void init() throws SQLException, PersistenceException {
        when(jdbcConnectionManager.getConnection()).thenReturn(getConnection());
        when(errorConnection.prepareStatement(any())).thenThrow(new SQLException());
        when(errorConnection.prepareStatement(any(), any(Integer.class))).thenThrow(new SQLException());
        when(errorConnectionManager.getConnection()).thenReturn(errorConnection);
        dishDAO = new DishDAO(jdbcConnectionManager, imageManagementDAO);
        errorDishDAO=new DishDAO(errorConnectionManager, imageManagementDAO);
    }

    @AfterClass
    public static void tearDown() throws SQLException {
        if (connection != null) {
            connection.rollback();
        }
    }

    private static Connection getConnection() throws SQLException{
        if (connection == null){
            connection = DriverManager.getConnection(CONNECTION_URL, "admin", "admin");
            connection.setAutoCommit(false);
        }
        return connection;
    }

    @Before
    public void initBeforeEachTest() throws SQLException{

        if (connection != null) {
            connection.rollback();
        }
        List<Ingredient> validIngList = new ArrayList<>();
        List<Allergen> validAlgList = new ArrayList<>();
        validSearch = new DishSearch("",0d,9000d,validIngList,validAlgList);
    }


    @Test
    public void errorDishDAOConstructorTest() throws SQLException{
        when(errorConnectionManager.getConnection()).thenThrow(new SQLException());
        try {
            new DishDAO(errorConnectionManager, imageManagementDAO);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }
    @Test
    public void getAllDishesFromDBTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            assertEquals(2, dishes.size());
            assertEquals("Dish name", dishes.get(0).getName());
            assertEquals("Dish description", dishes.get(0).getDescription());
            assertEquals(Category.MAINCOURSE, dishes.get(0).getCategory());
            assertEquals(2, dishes.get(0).getListOfAllergens().size());
            assertEquals("A", dishes.get(0).getListOfAllergens().get(0).getSymbol().toString());
            assertEquals("B", dishes.get(0).getListOfAllergens().get(1).getSymbol().toString());
            assertEquals(2, dishes.get(0).getListOfIngredients().size());

            assertEquals("Second dish", dishes.get(1).getName());
            assertEquals("second description", dishes.get(1).getDescription());
            assertEquals(Category.SOUP, dishes.get(1).getCategory());
            assertEquals(2, dishes.get(1).getListOfAllergens().size());
            assertEquals("C", dishes.get(1).getListOfAllergens().get(0).getSymbol().toString());
            assertEquals("D", dishes.get(1).getListOfAllergens().get(1).getSymbol().toString());
            assertEquals(2, dishes.get(1).getListOfIngredients().size());

        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void getAllDishesException(){
        try {
            errorDishDAO.getAllDishes();
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void addNewDishTest(){

        var dish=new Dish();
        dish.setName("Dish for test");
        dish.setDescription("Description of test dish");
        dish.setPrice(10.0);
        dish.setCategory(Category.DESSERT);
        dish.setListOfAllergens(new ArrayList<>());
        dish.setListOfIngredients(new ArrayList<>());
        try {
            dishDAO.addNewDish(dish);
            var dishes=dishDAO.getAllDishes();
            assertEquals(3, dishes.size());
            assertEquals("Dish for test", dishes.get(2).getName());
            assertEquals("Description of test dish", dishes.get(2).getDescription());
            assertEquals(Category.DESSERT, dishes.get(2).getCategory());
            assertEquals(0, dishes.get(2).getListOfAllergens().size());
            assertEquals(0, dishes.get(2).getListOfIngredients().size());
        } catch (PersistenceException e) {
            err.addError(e);
        }

    }

    @Test
    public void addNewDishException(){

        try {
            var dish=new Dish();
            errorDishDAO.addNewDish(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void deleteDishTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            dishDAO.deleteDish(dishes.get(0));
            dishes=dishDAO.getAllDishes();
            assertEquals(1, dishes.size());
            assertEquals("Second dish", dishes.get(0).getName());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void deleteDishException(){
        var dish=new Dish();
        try {
            errorDishDAO.deleteDish(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }

    }

    @Test
    public void getDishIngredientsTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            var ingredients=dishDAO.getIngredients(dishes.get(0));
            assertEquals(2, ingredients.size());
            assertEquals("chicken", ingredients.get(0).getName());
            assertEquals("tomato", ingredients.get(1).getName());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void getDishIngredientsException(){
        var dish=new Dish();
        try {
            errorDishDAO.getIngredients(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }

    }

    @Test
    public void getDishAllergensTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            var allergens=dishDAO.getAllergensInDish(dishes.get(1));
            assertEquals(2, allergens.size());
            assertEquals("C", allergens.get(0).getSymbol().toString());
            assertEquals("D", allergens.get(1).getSymbol().toString());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void getDishAllergensException(){
        var dish=new Dish();
        try {
            errorDishDAO.getAllergensInDish(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }

    }

    @Test
    public void updateDishTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            var dish=dishes.get(0);
            dish.setName("Updated name");
            dish.setDescription(null);
            dish.setCategory(Category.DRINK);
            dishDAO.updateDish(dish);
            dishes=dishDAO.getAllDishes();
            assertEquals(2, dishes.size());
            assertEquals("Updated name", dishes.get(0).getName());
            assertNull(dishes.get(0).getDescription());
            assertEquals(Category.DRINK, dishes.get(0).getCategory());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void updateDishException(){
        var dish=new Dish();
        try {
            errorDishDAO.updateDish(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void deleteDishAllergensTest(){
        var DELETE_DISH_ALLERGENS_QUERY="DELETE FROM dish_allergen WHERE dish_id=?";
        try {
            var dishes=dishDAO.getAllDishes();
            dishDAO.deleteDishIngredientsAllergens(dishes.get(0), DELETE_DISH_ALLERGENS_QUERY);
            dishes=dishDAO.getAllDishes();
            assertEquals(0, dishes.get(0).getListOfAllergens().size());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void deleteDishAllergensException(){
        var dish=new Dish();
        try {
            errorDishDAO.deleteDishIngredientsAllergens(dish, "DELETE FROM dish_allergen WHERE dish_id = ?");
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void deleteDishIngredientsTest(){
        var DELETE_DISH_INGREDIENTS_QUERY="DELETE FROM dish_ingredient WHERE dish_id=?";
        try {
            var dishes=dishDAO.getAllDishes();
            dishDAO.deleteDishIngredientsAllergens(dishes.get(0), DELETE_DISH_INGREDIENTS_QUERY);
            dishes=dishDAO.getAllDishes();
            assertEquals(0, dishes.get(0).getListOfIngredients().size());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }
    @Test
    public void deleteDishIngredientsException(){
        var dish=new Dish();
        try {
            errorDishDAO.deleteDishIngredientsAllergens(dish, "DELETE FROM dish_ingredient WHERE dish_id = ?");
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void saveDishAllergensTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            var allergenList=new ArrayList<Allergen>();
            var allergen1=new Allergen();
            allergen1.setSymbol('F');
            allergen1.setName("Soya");
            allergenList.add(allergen1);
            var allergen2=new Allergen();
            allergen2.setSymbol('H');
            allergen2.setName("Nuts");
            allergenList.add(allergen2);
            dishes.get(0).setListOfAllergens(allergenList);
            dishDAO.saveDishAllergens(dishes.get(0));
            dishes=dishDAO.getAllDishes();
            assertEquals(4, dishes.get(0).getListOfAllergens().size());
            assertEquals("F", dishes.get(0).getListOfAllergens().get(2).getSymbol().toString());
            assertEquals("H", dishes.get(0).getListOfAllergens().get(3).getSymbol().toString());

        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void saveDishAllergenException(){
        var dish=new Dish();
        try {
            errorDishDAO.saveDishAllergens(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void saveDishIngredientTest(){
        try {
            var dishes=dishDAO.getAllDishes();
            var ingredientList=new ArrayList<Ingredient>();
            var ingredient1=new Ingredient();
            ingredient1.setId(3L);
            ingredient1.setName("salmon");
            ingredientList.add(ingredient1);
            var ingredient2=new Ingredient();
            ingredient2.setId(4L);
            ingredient2.setName("cucumber");
            ingredientList.add(ingredient2);
            dishes.get(0).setListOfIngredients(ingredientList);
            dishDAO.saveDishIngredients(dishes.get(0));
            dishes=dishDAO.getAllDishes();
            assertEquals(4, dishes.get(0).getListOfIngredients().size());
            assertEquals("salmon", dishes.get(0).getListOfIngredients().get(2).getName());
            assertEquals("cucumber", dishes.get(0).getListOfIngredients().get(3).getName());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void saveDishIngredientException(){
        var dish=new Dish();
        try {
            errorDishDAO.saveDishIngredients(dish);
            err.addError(new AssertionError("Persistence exception is not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }

    @Test
    public void validTotalSearch() {
        try {
            var result = dishDAO.searchDishes(validSearch);
            Assert.assertEquals(2,result.size());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void searchWithIngredients() {
        Ingredient chicken = new Ingredient(null,"chicken",false);
        Ingredient tomato = new Ingredient(null,"tomato",false);
        List<Ingredient> ingredientList = new ArrayList<>();
        ingredientList.addAll(Arrays.asList(chicken,tomato));
        validSearch.setIngredients(ingredientList);
        try {
            var result = dishDAO.searchDishes(validSearch);
            Assert.assertEquals(1,result.size());
            Assert.assertEquals("Dish name", result.get(0).getName());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void searchWithAllergens() {
        Allergen gluten = new Allergen('A', "Gluten");
        List<Allergen> allergens = new ArrayList<>();
        allergens.add(gluten);
        validSearch.setAllergens(allergens);
        try {
            var result = dishDAO.searchDishes(validSearch);
            Assert.assertEquals(1,result.size());
            Assert.assertEquals("Second dish",result.get(0).getName());
        } catch (PersistenceException e) {
            err.addError(e);
        }

    }

    @Test
    public void searchNullPricFr() {
        validSearch.setPriceFrom(null);
        try {
            var result = dishDAO.searchDishes(validSearch);
            Assert.assertEquals(2,result.size());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void searchNullPricTo() {
        validSearch.setPriceTo(null);
        try {
            var result = dishDAO.searchDishes(validSearch);
            Assert.assertEquals(2,result.size());
        } catch (PersistenceException e) {
            err.addError(e);
        }
    }

    @Test
    public void persistanceExceptionSearch() {
        try{
            errorDishDAO.searchDishes(validSearch);
            err.addError(new AssertionError("Persistence exception not thrown"));
        } catch (PersistenceException e) {
            assertEquals("java.sql.SQLException", e.getMessage());
        }
    }
}