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

import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
import at.ac.tuwien.sepm.assignment.groupphase.missioncontrol.dto.Vehicle;
import at.ac.tuwien.sepm.assignment.groupphase.missioncontrol.dto.Vehicle.ConstructionType;
import at.ac.tuwien.sepm.assignment.groupphase.missioncontrol.dto.Vehicle.Status;
import at.ac.tuwien.sepm.assignment.groupphase.missioncontrol.dto.Vehicle.VehicleType;
import at.ac.tuwien.sepm.assignment.groupphase.util.Helper;
import at.ac.tuwien.sepm.assignment.groupphase.util.JdbcTestCase;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Set;
import org.dbunit.Assertion;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.junit.Assert;
import org.junit.Test;

public class VehicleDAOTest extends JdbcTestCase {

    private VehicleDAO vehicleDAO;

    private Vehicle validUpdateVehicle =
            Vehicle.builder()
                    .hasNef(true)
                    .constructionType(ConstructionType.HOCHDACH)
                    .type(VehicleType.RTW)
                    .id(2)
                    .name("RTW-2")
                    .status(Status.ABGEMELDET)
                    .build();

    public VehicleDAOTest() throws PersistenceException {
        vehicleDAO =
                new VehicleDatabaseDAO(
                        getJdbcConnectionManager(),
                        new RegistrationDatabaseDAO(
                                getJdbcConnectionManager(),
                                new EmployeeDatabaseDAO(getJdbcConnectionManager())));
        // TODO: use Spring Dependency Injection!
    }

    @Override
    protected IDataSet getDataSet() throws Exception {
        InputStream res = getClass().getClassLoader().getResourceAsStream("vehicleTestData.xml");
        return new FlatXmlDataSetBuilder().build(res);
    }

    @Test
    public void testListVehicle() throws PersistenceException {
        Set<Vehicle> vehicles = vehicleDAO.list();

        Vehicle v1 =
                Vehicle.builder()
                        .id(1)
                        .constructionType(ConstructionType.HOCHDACH)
                        .name("RTW-1")
                        .hasNef(true)
                        .status(Status.ABGEMELDET)
                        .type(VehicleType.RTW)
                        .registrations(new ArrayList<>())
                        .build();
        Vehicle v2 =
                Vehicle.builder()
                        .id(2)
                        .constructionType(ConstructionType.MITTELHOCHDACH)
                        .name("KTW-2")
                        .hasNef(false)
                        .status(Status.FREI_WACHE)
                        .type(VehicleType.KTW)
                        .registrations(new ArrayList<>())
                        .build();
        Vehicle v3 =
                Vehicle.builder()
                        .id(3)
                        .constructionType(ConstructionType.NORMAL)
                        .name("NEF-3")
                        .hasNef(false)
                        .status(Status.FREI_FUNK)
                        .type(VehicleType.NEF)
                        .registrations(new ArrayList<>())
                        .build();

        Assert.assertTrue(vehicles.contains(v1));
        Assert.assertTrue(vehicles.contains(v2));
        Assert.assertTrue(vehicles.contains(v3));
        Assert.assertEquals(3, vehicles.size());
    }

    @Test
    public void testVehicleListNoElement() throws PersistenceException {
        Set<Vehicle> vehicles = vehicleDAO.list();

        Vehicle v1 =
                Vehicle.builder()
                        .id(30)
                        .constructionType(ConstructionType.NORMAL)
                        .name("NEF-3")
                        .hasNef(false)
                        .status(Status.FREI_FUNK)
                        .type(VehicleType.NEF)
                        .build();

        Assert.assertFalse(vehicles.contains(v1));
    }

    @Test
    public void testUpdateValid_VehicleVersion() throws Exception {
        vehicleDAO.update(validUpdateVehicle);

        String[] excludedColumnsVehicleVersion = new String[] {"ID", "NAME"};
        String tableVehicleVersion = "VEHICLEVERSION";

        ITable actualTableData =
                Helper.getActualFilteredTableData(
                        getConnection(), tableVehicleVersion, excludedColumnsVehicleVersion);

        ITable expectedTableData =
                Helper.getExpectedFilteredTableData(
                        tableVehicleVersion,
                        excludedColumnsVehicleVersion,
                        "vehicleTestUpdateExpectedData.xml");
        Assertion.assertEquals(expectedTableData, actualTableData);
    }

    @Test
    public void testUpdateValid_Vehicle() throws Exception {
        vehicleDAO.update(validUpdateVehicle);

        String[] excludedColumnsVehicleVersion = new String[] {"VERSION", "STATUS"};
        String tableVehicleVersion = "VEHICLE";

        ITable actualTableData =
                Helper.getActualFilteredTableData(
                        getConnection(), tableVehicleVersion, excludedColumnsVehicleVersion);

        ITable expectedTableData =
                Helper.getExpectedFilteredTableData(
                        tableVehicleVersion,
                        excludedColumnsVehicleVersion,
                        "vehicleTestUpdateExpectedData.xml");
        Assertion.assertEquals(expectedTableData, actualTableData);
    }

    @Test(expected = ElementNotFoundException.class)
    public void testUpdateNonExistingVehicle()
            throws PersistenceException, ElementNotFoundException {
        Vehicle nonExistentVehicle =
                Vehicle.builder()
                        .id(35)
                        .constructionType(ConstructionType.NORMAL)
                        .name("NEF-3")
                        .hasNef(false)
                        .status(Status.FREI_FUNK)
                        .type(VehicleType.NEF)
                        .build();
        vehicleDAO.update(nonExistentVehicle);
    }
}