walkChina/src/main/java/com/izouma/walkchina/service/JourneyService.java

package com.izouma.walkchina.service;

import com.izouma.walkchina.constant.AppConstants;
import com.izouma.walkchina.constant.Strings;
import com.izouma.walkchina.domain.*;
import com.izouma.walkchina.dto.Location;
import com.izouma.walkchina.dto.webservice.DirectionResponse;
import com.izouma.walkchina.dto.webservice.MapRoute;
import com.izouma.walkchina.exception.ServiceException;
import com.izouma.walkchina.repo.*;
import lombok.extern.slf4j.Slf4j;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

@Service
@Slf4j
public class JourneyService {
    @Autowired
    private UserJourneyRepository  userJourneyRepository;
    @Autowired
    private JourneyStageRepository journeyStageRepository;
    @Autowired
    private WalkDataRepository     walkDataRepository;
    @Autowired
    private TeamMemberRepository   teamMemberRepository;
    @Autowired
    private MessageRepository      messageRepository;
    @Autowired
    private CityRepository         cityRepository;
    @Autowired
    private MapService             mapService;
    @Autowired
    private StageAwardRepository   stageAwardRepository;

    public boolean hasJourney(Long userId) {
        return userJourneyRepository.findByUserId(userId) != null;
    }

    public void newJourney(Long userId, Long originId, Long destinationId) {
        City origin = cityRepository.findById(originId).orElseThrow(new ServiceException("起始地不存在"));
        City destination = cityRepository.findById(destinationId).orElseThrow(new ServiceException("目的地不存在"));
        DirectionResponse directionResponse = mapService.direction(new Location(origin.getLatitude(), origin.getLongitude()),
                new Location(destination.getLatitude(), destination.getLongitude()));
        if (directionResponse.getStatus() != 0) {
            throw new ServiceException(directionResponse.getMessage());
        }
        UserJourney userJourney = UserJourney.builder()
                .userId(userId)
                .originId(originId)
                .destinationId(destinationId)
                .distance(directionResponse.getResult().getRoutes().get(0).getDistance())
                .polyline(directionResponse.getResult().getRoutes().get(0).getPolyline())
                .build();
        userJourney = userJourneyRepository.save(userJourney);
        int distance = directionResponse.getResult().getRoutes().get(0).getDistance();
        JourneyStage journeyStage = JourneyStage.builder()
                .userId(userId)
                .journeyId(userJourney.getId())
                .originId(originId)
                .destinationId(destinationId)
                .polyline(directionResponse.getResult().getRoutes().get(0).getPolyline())
                .routeSteps(directionResponse.getResult().getRoutes().get(0).getSteps())
                .distance(directionResponse.getResult().getRoutes().get(0).getDistance())
                .progress(.0)
                .steps(Math.round(distance / AppConstants.STEP_TO_DISTANCE_RATE))
                .award(BigDecimal.valueOf(Math.round(distance * AppConstants.DISTANCE_TO_COIN_RATE)))
                .build();
        journeyStage = journeyStageRepository.save(journeyStage);

        createStageAward(userId, journeyStage.getId(), userJourney.getId(), directionResponse.getResult().getRoutes().get(0));
    }

    public void newDestination(Long userId, Long id) {
        City destination = cityRepository.findById(id).orElseThrow(new ServiceException("目的地不存在"));
        UserJourney userJourney = userJourneyRepository.findByUserId(userId);
        JourneyStage journeyStage = journeyStageRepository.findByUserIdAndJourneyIdOrderByIdDesc(userId, userJourney.getId());
        DirectionResponse directionResponse = mapService.direction(new Location(journeyStage.getDestination().getLatitude(), journeyStage.getDestination().getLongitude()),
                new Location(destination.getLatitude(), destination.getLongitude()));
        if (directionResponse.getStatus() != 0) {
            throw new ServiceException(directionResponse.getMessage());
        }

        MapRoute route = directionResponse.getResult().getRoutes().get(0);
        List<Double> newPolyline = new ArrayList<>(route.getPolyline());

        JourneyStage newStage = JourneyStage.builder()
                .userId(userId)
                .journeyId(userJourney.getId())
                .originId(journeyStage.getDestination().getId())
                .destinationId(destination.getId())
                .distance(route.getDistance())
                .progress(.0)
                .polyline(route.getPolyline())
                .routeSteps(route.getSteps())
                .build();
        newStage = journeyStageRepository.save(newStage);
        List<Double> polyline = mapService.extractPolyline(userJourney.getPolyline());
        newPolyline.set(0, newPolyline.get(0) * 1000000 - polyline.get(polyline.size() - 2) * 1000000);
        newPolyline.set(1, newPolyline.get(1) * 1000000 - polyline.get(polyline.size() - 1) * 1000000);
        userJourney.getPolyline().addAll(newPolyline);
        userJourneyRepository.save(userJourney);

        createStageAward(userId, newStage.getId(), userJourney.getId(), route);
    }

    private void createStageAward(Long userId, Long stageId, Long journeyId, MapRoute route) {
        List<Double> extracted = mapService.extractPolyline(route.getPolyline());
        List<Double> points = Arrays.asList(.3, .6);
        for (Double p : points) {
            int end = mapService.endPoint(route.getSteps(), route.getDistance() * p);
            StageAward stageAward = StageAward.builder()
                    .userId(userId)
                    .stageId(stageId)
                    .latitude(extracted.get(end - 1))
                    .longitude(extracted.get(end))
                    .journeyId(journeyId)
                    .coin(new BigDecimal(10))
                    .needProgress(p)
                    .needStep((long) (p * route.getDistance() / AppConstants.STEP_TO_DISTANCE_RATE))
                    .received(false)
                    .build();
            stageAwardRepository.save(stageAward);
        }
    }

    public void updateUserJourney(Long userId) {
        UserJourney userJourney = userJourneyRepository.findByUserId(userId);
        if (userJourney == null) {
            throw new ServiceException("无数据");
        }
        List<JourneyStage> stageList = journeyStageRepository.findAllByJourneyIdOrderById(userJourney.getId());
        if (stageList.size() == 0) {
            throw new ServiceException("无数据");
        }
        JourneyStage latestStage = stageList.get(stageList.size() - 1);
        Long steps = 0L;
        WalkData todayWalkData = walkDataRepository.findByUserIdAndDate(userId, new Date());

        log.info("createAt type {}", latestStage.getCreatedAt().getClass().getName());
        steps += walkDataRepository.sumTeamWalkSteps(userId, latestStage.getCreatedAt(),
                Optional.ofNullable(latestStage.getFinishAt()).orElse(new Date()))
                .orElse(0L);

        steps += walkDataRepository.sumUserWalkSteps(userId, latestStage.getCreatedAt(),
                Optional.ofNullable(latestStage.getFinishAt()).orElse(new Date()))
                .orElse(0L);

        latestStage.setSteps((long) (latestStage.getDistance() / AppConstants.STEP_TO_DISTANCE_RATE));
        latestStage.setCurrentSteps(steps);
        double progress = steps * AppConstants.STEP_TO_DISTANCE_RATE / latestStage.getDistance();
        progress = progress > 1 ? 1 : (progress < 0 ? 0 : progress);
        latestStage.setProgress(progress);
        journeyStageRepository.save(latestStage);

        if (progress == 1) {
            Message msg = Message.builder()
                    .userId(userId)
                    .content(String.format(Strings.MSG_JOURNEY_PROGRESS,
                            latestStage.getOrigin().getName(),
                            latestStage.getDestination().getName(),
                            (todayWalkData != null ? todayWalkData.getSteps() : 0),
                            calcDays(latestStage.getCreatedAt(), new Date()),
                            steps,
                            Math.round(progress * 100)))
                    .build();
            messageRepository.save(msg);
        }
    }

    private int calcDays(Date start, Date end) {
        return Days.daysBetween(LocalDate.fromDateFields(start), LocalDate.fromDateFields(end)).getDays();
    }
}