package be.kdg.carpool.services;

import be.kdg.carpool.dao.AddressDao;
import be.kdg.carpool.dao.CarDao;
import be.kdg.carpool.dao.PathDao;
import be.kdg.carpool.dao.PointDao;
import be.kdg.carpool.domain.*;
import be.kdg.carpool.jsonPojos.AndriodPath;
import be.kdg.carpool.jsonPojos.AndriodPathPassenger;
import be.kdg.carpool.jsonPojos.AndriodPaths;
import be.kdg.carpool.utility.DistanceCalculator;
import be.kdg.carpool.utility.SecurityClass;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: Annelies
 * Date: 23/02/12
 * Time: 11:50
 */
@Service(value = "pathService")
@Transactional
public class PathServiceImpl implements PathService {
    /**
     * PathDao injected by Spring via constructor
     */
    @Resource(name = "pathDao")
    private PathDao pathDao;

    @Resource(name = "carDao")
    private CarDao carDao;

    @Resource(name = "addressDao")
    private AddressDao addressDao;

    @Resource(name = "pointDao")
    private PointDao pointDao;

    @Resource(name = "profileService")
    private ProfileService profileService;

    @Resource(name = "pathPassengerService")
    private PathPassengerService pathPassengerService;

    @Autowired
    private SecurityClass securityClass;

    @Override
    public void createPath(Path path) {
        pathDao.addPath(path);
    }

    @Override
    public List<Path> getAllPaths() {
        return pathDao.getAllPaths();
    }

    @Override
    public void editPath(Path path) {
        pathDao.edit(path);
    }

    @Override
    public Path getPath(int id) {
        return pathDao.getPath(id);
    }

    @Override
    public void deletePath(int id) {
        pathDao.delete(id);
    }

    @Override
    public void createPath(Path path, String startPoint, int startHour, int startMin, Date date, String endPoint, int endHour, int endMin, int car, List<String> passagepoints) {

        double[] location = DistanceCalculator.getCoords(startPoint);
        Address startAddress = DistanceCalculator.getCoords(location[0], location[1]);

        Point start = new Point();
        start.setAddress(startAddress);
        start.setLatCoordinate(location[0]);
        start.setLngCoordinate(location[1]);
        /*
        System.out.println(startAddress.getStreet());
        System.out.println(startAddress.getNumber());
        System.out.println(startAddress.getZipCode());
        System.out.println(startAddress.getCity());
        System.out.println(startAddress.getCountry());
         */
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTime(date);
        cal.set(Calendar.HOUR_OF_DAY, startHour);
        cal.set(Calendar.MINUTE, startMin);
        Date startDate = cal.getTime();
        start.setPassageDateTime(startDate);
        path.setBeginpoint(start);

        double[] location2 = DistanceCalculator.getCoords(endPoint);
        Address endAddress = DistanceCalculator.getCoords(location2[0], location2[1]);
        Point end = new Point();
        end.setAddress(endAddress);
        end.setLatCoordinate(location2[0]);
        end.setLngCoordinate(location2[1]);

        GregorianCalendar cal2 = new GregorianCalendar();
        cal2.setTime(date);
        cal2.set(Calendar.HOUR_OF_DAY, endHour);
        cal2.set(Calendar.MINUTE, endMin);
        Date endDate = cal.getTime();
        end.setPassageDateTime(endDate);
        path.setEndpoint(end);

        Car c = carDao.getCar(car);
        path.setCar(c);

        Set<Point> points = new LinkedHashSet<Point>();
        for (String passage : passagepoints) {
            double[] lo = DistanceCalculator.getCoords(passage);
            Address address = DistanceCalculator.getCoords(lo[0], lo[1]);
            Point point = new Point();
            point.setAddress(address);
            point.setLatCoordinate(lo[0]);
            point.setLngCoordinate(lo[1]);

            GregorianCalendar cl = new GregorianCalendar();
            cl.setTime(date);
            ////////////////////////////////////
            cl.set(Calendar.HOUR_OF_DAY, endHour);
            ////////////// endMin
            cl.set(Calendar.MINUTE, endMin);
            Date d = cal.getTime();
            point.setPassageDateTime(d);
            points.add(point);
        }
        path.setPassagepunten(points);
        pathDao.addPath(path);
    }

    @Override
    public List<Path> getAllPathsBelongTo(String username) {
        List<Path> paths = pathDao.getAllPathsBelongTo(username);
        if (paths == null) return new ArrayList<Path>();
        return paths;
    }

    @Override
    public boolean invite(int pathId, int beginPointId, int endPointId, String userToInvite, String currentUser) {
        if (pathId <= 0 || endPointId <= 0 || beginPointId <= 0) return false;
        if (userToInvite.isEmpty()) return false;

        Path p = getPath(pathId);
        if (p == null) return false;

        //security check: should be the owner to invite people
        if (!p.getCar().getProfile().getUserName().equals(currentUser)) return false;

        Point beginPoint = pointDao.getPointById(beginPointId);
        Point endPoint = pointDao.getPointById(endPointId);

        if (beginPoint == null || endPoint == null) return false;
        if (beginPoint.getOrder() >= endPoint.getOrder()) return false;

        Profile invitee = profileService.searchProfile(userToInvite);
        for (PathPassenger pass : p.getPassengers()) {
            //an invitation already exists
            if (pass.getProfile().getUserName().equals(invitee.getUserName())) return false;
        }
        //cannot invite yourself
        if (p.getCar().getProfile().getUserName().equals(invitee.getUserName())) return false;

        PathPassenger passenger = new PathPassenger(invitee, false);
        //adding unconfirmed (false) path passenger, user still needs to confirm
        passenger.setPickupPoint(beginPoint);
        passenger.setDropoffPoint(endPoint);
        p.addPassenger(passenger);

        //update in db
        pathDao.edit(p);

        return true;
    }

    @Override
    public List<Path> getAllPathsAsPassengerAccepted(String username) {
        List<Path> paths = pathDao.getAllPathsAsPassengerAccepted(username);
        if (paths == null) return new ArrayList<Path>();
        return paths;
    }

    @Override
    public List<Path> getAllPathsAsPassengerInvitation(String username) {
        List<Path> paths = pathDao.getAllPathsAsPassengerInvitation(username);
        if (paths == null) return new ArrayList<Path>();
        return paths;
    }

    @Override
    public boolean acceptPath(int pathId, String username, String currentUser) {
        Path path = pathDao.getPath(pathId);
        //wont work if we have no Path
        if (path == null) return false;

        PathPassenger passenger = null;
        for (PathPassenger ps : path.getPassengers()) {
            if (ps.getProfile().getUserName().equals(username)) passenger = ps;
        }
        //if no passenger was found, we cant accept
        if (passenger == null) return false;

        //security check: should be the invitee only to accept invitations
        if (!passenger.getProfile().getUserName().equals(currentUser)) return false;

        //accept invitation (put status to true)
        passenger.setPassengerStatus(true);
        pathPassengerService.editPathPassenger(passenger);

        return true;
    }

    @Override
    public boolean leavePath(int pathId, String username, String currentUser) {
        Path path = pathDao.getPath(pathId);
        //wont work if we have no Path
        if (path == null) return false;

        PathPassenger passenger = null;
        for (PathPassenger ps : path.getPassengers()) {
            if (ps.getProfile().getUserName().equals(username)) passenger = ps;
        }
        //if no passenger was found, we cant accept
        if (passenger == null) return false;

        //security check: should be the invitee only to be able to leave
        if (!passenger.getProfile().getUserName().equals(currentUser)) return false;

        //decline invitation (put status to false)
        passenger.setPassengerStatus(false);

        //db updates
        pathPassengerService.editPathPassenger(passenger);

        return true;
    }

    @Override
    public boolean deleteInvitation(int passengerId, String currentUser) {
        PathPassenger passenger = pathPassengerService.get(passengerId);
        //Cant delete unexisting
        if (passenger == null) return false;

        //security check: the owner of the path should only be able to call this method
        Path path = pathDao.getPathForPathPassenger(passenger);
        if (path == null) return false;
        if (!path.getCar().getProfile().getUserName().equals(currentUser)) return false;

        pathPassengerService.deletePathPassenger(passenger);
        //delete successful
        if (pathPassengerService.get(passengerId) == null) return true;
        //unsuccesfull
        return false;  //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public AndriodPaths getAndriodPaths(String userName) {
        AndriodPaths andriodPaths = new AndriodPaths();
        List<Path> pathListOwner = pathDao.getAllPathsBelongTo(userName);
        List<Path> pathListPassenger = pathDao.getAllPathsAsPassengerAccepted(userName);
        List<AndriodPath> andriodPathList = new ArrayList<AndriodPath>();

        for(Path path : pathListOwner)
        {
            andriodPathList.add(getAndriodPathFromPath(path));
        }

        for(Path path : pathListPassenger )
        {
            andriodPathList.add(getAndriodPathFromPath(path));
        }
        andriodPaths.setPathList(andriodPathList);

        return andriodPaths;
    }  //TODO TESTEN  cehcekn op datum

    private AndriodPath getAndriodPathFromPath(Path path)
    {

        AndriodPath andriodPath = new AndriodPath();
        andriodPath.setId(path.getId());
        andriodPath.setPathName(path.getPathName());
        andriodPath.setDate(path.getDate());
        andriodPath.setUserName(path.getCar().getProfile().getUserName());
        andriodPath.setFirstName(path.getCar().getProfile().getFirstName());
        andriodPath.setLastName(path.getCar().getProfile().getLastName());
        andriodPath.setPhoneNumber(path.getCar().getProfile().getPhonenumber());
        andriodPath.setStatus(path.getStatus());
        andriodPath.setDriverPosition(path.getDriverPosition());

        List<Point> points = new ArrayList<Point>();
        path.getBeginpoint().setOrder(-1);

        points.add(path.getBeginpoint());
        int i = 0;
        for (Point p : path.getPassagepunten()) {
            points.add(p);
            i = p.getOrder();
        }
        path.getEndpoint().setOrder(i + 1);
        points.add(path.getEndpoint());
        andriodPath.setPoints(points);

        List<AndriodPathPassenger> andriodPathPassengerList = new ArrayList<AndriodPathPassenger>();
        for(PathPassenger passenger: path.getPassengers())
        {
            AndriodPathPassenger andriodPathPassenger = new AndriodPathPassenger();
            andriodPathPassenger.setId(passenger.getId());
            andriodPathPassenger.setUserName(passenger.getProfile().getUserName());
            andriodPathPassenger.setFirstName(passenger.getProfile().getFirstName());
            andriodPathPassenger.setLastName(passenger.getProfile().getLastName());
            andriodPathPassenger.setPhoneNumber(passenger.getProfile().getPhonenumber());
            andriodPathPassenger.setPickupPoint(passenger.getPickupPoint());
            andriodPathPassenger.setDropoffPoint(passenger.getDropoffPoint());

            andriodPathPassengerList.add(andriodPathPassenger);
        }
        andriodPath.setPassengers(andriodPathPassengerList);

        return andriodPath;
    }
}