import org.junit.Assert;
import org.junit.Test;
import ro.utcn.sd.business.UserBusiness;
import ro.utcn.sd.dao.*;
import ro.utcn.sd.entities.Car;
import ro.utcn.sd.entities.ParkingLot;
import ro.utcn.sd.entities.Request;
import ro.utcn.sd.entities.User;

import java.util.*;

public class UserBusinessTest {

    private UserDao mockUserDao = mockUserDao(new ArrayList<>());
    private CarDao mockCarDao = mockCarDao(new ArrayList<>());
    private RequestDao mockRequestDao = mockRequestDao(new ArrayList<>());
    private DaoFactory mockFactory = mockDaoFactory(mockUserDao, mockCarDao, mockRequestDao);
    private UserBusiness subject = new UserBusiness(mockFactory);


    @Test
    public void testRegisterUser() {
        // given


        // when:
        subject.register("test@email.com", "password");

        // then:
        Assert.assertEquals("test@email.com", mockUserDao.find(1).getEmail());
        Assert.assertEquals("password", mockUserDao.find(1).getPassword());
    }

    @Test
    public void testAddCar(){
        //given
        subject.register("test@email.com", "password");

        //when:
        subject.addCar(mockUserDao.find(1), new Date(), "B314ZDA");

        //then:
        Assert.assertEquals("B314ZDA", mockCarDao.find(1).getVin());
    }

    @Test
    public void testRemoveCar(){
        //given
        subject.register("test@email.com", "password");

        //when:
        subject.addCar(mockUserDao.find(1), new Date(), "B314ZDA");
        subject.removeCar(mockUserDao.find(1), mockCarDao.find(1));

        //then:
        Assert.assertNull(mockCarDao.find(1));
    }

    @Test
    public void testMakeRequest(){
        //given
        subject.register("test@email.com", "password");
        subject.addCar(mockUserDao.find(1), new Date(), "B314ZDA");
        HashSet<ParkingLot> lots = new HashSet<>();
        lots.add(new ParkingLot());

        //when:
        subject.makeRequest(mockUserDao.find(1), mockCarDao.find(1), lots);

        //then:
        Assert.assertFalse(mockRequestDao.find(1).isStatus());
    }

    @Test
    public void testDeleteRequest(){
        //given
        subject.register("test@email.com", "password");
        subject.addCar(mockUserDao.find(1), new Date(), "B314ZDA");
        HashSet<ParkingLot> lots = new HashSet<>();
        lots.add(new ParkingLot());
        subject.makeRequest(mockUserDao.find(1), mockCarDao.find(1), lots);

        //when:
        subject.deleteRequest(mockUserDao.find(1), mockCarDao.find(1));

        //then:
        Assert.assertNull(mockRequestDao.find(1));
    }

    @Test
    public void testShowRequests(){
        //given
        subject.register("test@email.com", "password");
        subject.addCar(mockUserDao.find(1), new Date(), "B232AER");
        HashSet<ParkingLot> lots = new HashSet<>();
        lots.add(new ParkingLot());
        subject.makeRequest(mockUserDao.find(1), mockCarDao.find(1), lots);
        subject.makeRequest(mockUserDao.find(1), mockCarDao.find(1), lots);

        //when:
        int nr = subject.showRequests(mockUserDao.find(1)).size();

        //then:
        Assert.assertEquals(2, nr);
    }

    @Test
    public void testUpdateRequest(){
        //given
        subject.register("test@email.com", "password");
        subject.addCar(mockUserDao.find(1), new Date(), "B232AER");
        HashSet<ParkingLot> lots = new HashSet<>();
        lots.add(new ParkingLot());
        subject.makeRequest(mockUserDao.find(1), mockCarDao.find(1), lots);

        Car newC = new Car();
        newC.setVin("B222LER");
        newC.setItp_date(new Date());
        newC.setUser(mockUserDao.find(1));

        //when:
        subject.updateRequest(mockRequestDao.find(1), newC, lots);
        int nr = mockRequestDao.findAllRequests(mockUserDao.find(1).getUser_id()).size();

        //then:
        Assert.assertEquals(1, nr);
        Assert.assertEquals("B222LER", mockRequestDao.find(1).getCar().getVin());
    }


    private DaoFactory mockDaoFactory(UserDao mockUserDao, CarDao mockCarDao, RequestDao mockRequestDao) {
        return new DaoFactory() {

            @Override
            public CarDao getCarDao() {
                return mockCarDao;
            }

            @Override
            public UserDao getUserDao() {
                return mockUserDao;
            }

            @Override
            public RequestDao getRequestDao() {
                return mockRequestDao;
            }

            @Override
            public ParkingLotDao getParkingLotDao() {
                return null;
            }

            @Override
            public ParkingSpotDao getParkingSpotDao() {
                return null;
            }
        };
    }

    private UserDao mockUserDao(ArrayList<User> users){
        return new UserDao(){

            @Override
            public User find(long id) {
                return users.stream().filter(user -> user.getUser_id() == id).findAny().get();
            }

            @Override
            public void delete(User toDelete) {
                users.remove(toDelete);
            }

            @Override
            public void update(User toUpdate) {

            }

            @Override
            public void insert(User toCreate) {
                toCreate.setUser_id(1);
                users.add(toCreate);
            }
        };
    }

    private CarDao mockCarDao(ArrayList<Car> cars){
        return new CarDao(){

            @Override
            public Car find(long id) {
                return cars.stream().filter(car -> car.getCar_id() == id).findFirst().orElse(null);
            }

            @Override
            public void delete(Car toDelete) {
                cars.remove(toDelete);
            }

            @Override
            public void update(Car toUpdate) {
            }

            @Override
            public void insert(Car toCreate) {
                toCreate.setCar_id(1);
                cars.add(toCreate);
            }
        };
    }

    private RequestDao mockRequestDao(ArrayList<Request> requests){
        return new RequestDao() {
            @Override
            public Request find(long id) {
                return requests.stream().filter(r -> r.getId() == id).findFirst().orElse(null);
            }

            @Override
            public void delete(Request toDelete) {
                requests.remove(toDelete);
            }

            @Override
            public void update(Request toUpdate) {

            }

            @Override
            public void insert(Request toCreate) {
                toCreate.setId(1);
                requests.add(toCreate);
            }

            @Override
            public List<Request> findAllRequests(long userId) {
                List<Request> result = new ArrayList<>();
                for(Request r: requests){
                    if(r.getCar().getUser().getUser_id() == userId){
                        result.add(r);
                    }
                }
                return result;
            }
        };
    }

}