package com.tourguide.modules.operation.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tourguide.common.api.PageResponse;
import com.tourguide.common.exception.BusinessException;
import com.tourguide.modules.operation.domain.ServiceType;
import com.tourguide.modules.operation.dto.*;
import com.tourguide.modules.operation.entity.OperationCity;
import com.tourguide.modules.operation.entity.OperationScenicSpot;
import com.tourguide.modules.operation.entity.ScenicMeetingPoint;
import com.tourguide.modules.operation.entity.ScenicPricing;
import com.tourguide.modules.operation.mapper.OperationCityMapper;
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
import com.tourguide.modules.operation.mapper.ScenicMeetingPointMapper;
import com.tourguide.modules.operation.mapper.ScenicPricingMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

/** 景区列表、详情及运营配置服务。 */
@Service
public class OperationScenicSpotService {
    private final OperationScenicSpotMapper scenicSpotMapper;
    private final OperationCityMapper cityMapper;
    private final ScenicPricingMapper pricingMapper;
    private final ScenicMeetingPointMapper meetingPointMapper;

    public OperationScenicSpotService(OperationScenicSpotMapper scenicSpotMapper,
                                      OperationCityMapper cityMapper,
                                      ScenicPricingMapper pricingMapper,
                                      ScenicMeetingPointMapper meetingPointMapper) {
        this.scenicSpotMapper = scenicSpotMapper;
        this.cityMapper = cityMapper;
        this.pricingMapper = pricingMapper;
        this.meetingPointMapper = meetingPointMapper;
    }

    public PageResponse<ScenicSpotListResponse> page(long page, long size, String keyword, Long cityId,
                                                      Integer status, LocalDate startDate, LocalDate endDate) {
        LambdaQueryWrapper<OperationScenicSpot> query = new LambdaQueryWrapper<OperationScenicSpot>()
                .like(StringUtils.hasText(keyword), OperationScenicSpot::getScenicName,
                        StringUtils.hasText(keyword) ? keyword.trim() : null)
                .eq(cityId != null, OperationScenicSpot::getCityId, cityId)
                .eq(status != null, OperationScenicSpot::getStatus, status)
                .ge(startDate != null, OperationScenicSpot::getCreatedAt, startDate == null ? null : startDate.atStartOfDay())
                .lt(endDate != null, OperationScenicSpot::getCreatedAt, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
                .orderByDesc(OperationScenicSpot::getId);
        Page<OperationScenicSpot> result = scenicSpotMapper.selectPage(new Page<OperationScenicSpot>(page, size), query);
        List<ScenicSpotListResponse> records = buildListResponses(result.getRecords());
        return new PageResponse<ScenicSpotListResponse>(records, result.getTotal(), result.getCurrent(), result.getSize());
    }

    @Transactional
    public ScenicSpotDetailResponse create(ScenicSpotDetailSaveRequest request) {
        OperationCity city = requireCity(request.getCityId());
        String scenicCode = request.getScenicCode().trim();
        String scenicName = request.getScenicName().trim();
        ensureUniqueCode(null, scenicCode);
        ensureUniqueName(null, city.getId(), scenicName);
        validateDetailRequest(request);
        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setStatus(1);
        scenicSpot.setDeleted(0);
        applyDetailFields(scenicSpot, city.getId(), scenicCode, scenicName, request);
        scenicSpotMapper.insert(scenicSpot);
        insertPricingConfigurations(scenicSpot.getId(), request);
        replaceMeetingPoints(scenicSpot.getId(), request.getMeetingPoints());
        return detail(scenicSpot.getId());
    }

    public ScenicSpotDetailResponse detail(Long id) {
        OperationScenicSpot scenicSpot = requireScenicSpot(id);
        OperationCity city = requireCity(scenicSpot.getCityId());
        Map<String, ScenicPricing> pricingMap = pricingMapper.selectList(
                new LambdaQueryWrapper<ScenicPricing>()
                        .eq(ScenicPricing::getScenicSpotId, id)
                        .orderByAsc(ScenicPricing::getId))
                .stream().collect(Collectors.toMap(ScenicPricing::getServiceType, value -> value));
        List<ScenicMeetingPointResponse> meetingPoints = meetingPointMapper.selectList(
                new LambdaQueryWrapper<ScenicMeetingPoint>()
                        .eq(ScenicMeetingPoint::getScenicSpotId, id)
                        .orderByAsc(ScenicMeetingPoint::getSortOrder, ScenicMeetingPoint::getId))
                .stream().map(ScenicMeetingPointResponse::from).collect(Collectors.toList());
        ScenicSpotDetailResponse response = new ScenicSpotDetailResponse();
        response.setId(scenicSpot.getId());
        response.setScenicCode(scenicSpot.getScenicCode());
        response.setScenicName(scenicSpot.getScenicName());
        response.setCityId(scenicSpot.getCityId());
        response.setCityName(city.getCityName());
        response.setCreatedAt(scenicSpot.getCreatedAt());
        response.setGroupFast(priceResponse(pricingMap, ServiceType.GROUP_QUICK.getCode()));
        response.setGroupPremium(priceResponse(pricingMap, ServiceType.GROUP_PREMIUM.getCode()));
        response.setPrivateFast(priceResponse(pricingMap, ServiceType.PRIVATE_QUICK.getCode()));
        response.setPrivatePremium(priceResponse(pricingMap, ServiceType.PRIVATE_PREMIUM.getCode()));
        response.setMeetingPoints(meetingPoints);
        response.setFirstOrderLeadMinutes(scenicSpot.getFirstOrderLeadMinutes());
        response.setVisitorNoOrderMinutes(scenicSpot.getVisitorNoOrderMinutes());
        response.setUnpaidCancelMinutes(scenicSpot.getUnpaidCancelMinutes());
        return response;
    }

    @Transactional
    public ScenicSpotDetailResponse save(Long id, ScenicSpotDetailSaveRequest request) {
        OperationScenicSpot scenicSpot = requireScenicSpot(id);
        OperationCity city = requireCity(request.getCityId());
        String scenicCode = request.getScenicCode().trim();
        String scenicName = request.getScenicName().trim();
        ensureUniqueCode(id, scenicCode);
        ensureUniqueName(id, city.getId(), scenicName);
        validateDetailRequest(request);
        applyDetailFields(scenicSpot, city.getId(), scenicCode, scenicName, request);
        scenicSpotMapper.updateById(scenicSpot);
        pricingMapper.markDeletedByScenicSpotId(id);
        insertPricingConfigurations(id, request);
        replaceMeetingPoints(id, request.getMeetingPoints());
        return detail(id);
    }

    @Transactional
    public void updateStatus(Long id, Integer status) {
        OperationScenicSpot scenicSpot = requireScenicSpot(id);
        scenicSpot.setStatus(status);
        scenicSpotMapper.updateById(scenicSpot);
    }

    private List<ScenicSpotListResponse> buildListResponses(List<OperationScenicSpot> scenicSpots) {
        if (scenicSpots.isEmpty()) { return Collections.emptyList(); }
        Set<Long> cityIds = scenicSpots.stream().map(OperationScenicSpot::getCityId).collect(Collectors.toSet());
        Set<Long> scenicIds = scenicSpots.stream().map(OperationScenicSpot::getId).collect(Collectors.toSet());
        Map<Long, String> cityNames = cityMapper.selectBatchIds(cityIds).stream()
                .collect(Collectors.toMap(OperationCity::getId, OperationCity::getCityName));
        Map<Long, Map<String, ScenicPricing>> pricingByScenic = new HashMap<Long, Map<String, ScenicPricing>>();
        for (ScenicPricing pricing : pricingMapper.selectList(
                new LambdaQueryWrapper<ScenicPricing>().in(ScenicPricing::getScenicSpotId, scenicIds))) {
            pricingByScenic.computeIfAbsent(pricing.getScenicSpotId(), key -> new HashMap<String, ScenicPricing>())
                    .put(pricing.getServiceType(), pricing);
        }
        List<ScenicSpotListResponse> responses = new ArrayList<ScenicSpotListResponse>();
        for (OperationScenicSpot scenicSpot : scenicSpots) {
            Map<String, ScenicPricing> prices = pricingByScenic.getOrDefault(
                    scenicSpot.getId(), Collections.<String, ScenicPricing>emptyMap());
            ScenicSpotListResponse response = new ScenicSpotListResponse();
            response.setId(scenicSpot.getId());
            response.setScenicCode(scenicSpot.getScenicCode());
            response.setScenicName(scenicSpot.getScenicName());
            response.setCityId(scenicSpot.getCityId());
            response.setCityName(cityNames.get(scenicSpot.getCityId()));
            response.setGroupFastPrice(discountPrice(prices.get(ServiceType.GROUP_QUICK.getCode())));
            response.setGroupPremiumPrice(discountPrice(prices.get(ServiceType.GROUP_PREMIUM.getCode())));
            response.setPrivateFastPrice(discountPrice(prices.get(ServiceType.PRIVATE_QUICK.getCode())));
            response.setPrivatePremiumPrice(discountPrice(prices.get(ServiceType.PRIVATE_PREMIUM.getCode())));
            response.setStatus(scenicSpot.getStatus());
            response.setCreatedAt(scenicSpot.getCreatedAt());
            responses.add(response);
        }
        return responses;
    }

    private void replaceMeetingPoints(Long scenicSpotId, List<ScenicMeetingPointRequest> requests) {
        meetingPointMapper.markDeletedByScenicSpotId(scenicSpotId);
        if (requests == null || requests.isEmpty()) { return; }
        long defaultCount = requests.stream().filter(request -> Integer.valueOf(1).equals(request.getIsDefault())).count();
        if (defaultCount == 0) {
            throw new BusinessException(400, "请设置一个默认汇合点");
        }
        if (defaultCount > 1) {
            throw new BusinessException(400, "同一景区只能配置一个默认汇合点");
        }
        Set<String> pointNames = new HashSet<String>();
        for (int index = 0; index < requests.size(); index++) {
            ScenicMeetingPointRequest request = requests.get(index);
            String pointName = request.getPointName().trim();
            if (!pointNames.add(pointName)) {
                throw new BusinessException(409, "同一景区不能配置重名汇合点");
            }
            ScenicMeetingPoint point = new ScenicMeetingPoint();
            point.setScenicSpotId(scenicSpotId);
            point.setPointName(pointName);
            point.setLongitude(request.getLongitude());
            point.setLatitude(request.getLatitude());
            point.setStatus(request.getStatus());
            point.setIsDefault(request.getIsDefault());
            point.setSortOrder(index + 1);
            meetingPointMapper.upsert(point);
        }
    }

    private void insertPricing(Long scenicSpotId, String serviceType, ScenicPriceConfigRequest request) {
        ScenicPricing pricing = new ScenicPricing();
        pricing.setScenicSpotId(scenicSpotId);
        pricing.setServiceType(serviceType);
        pricing.setDurationMinutes(request.getDurationMinutes());
        pricing.setMinParticipants(request.getMinParticipants());
        pricing.setMaxParticipants(request.getMaxParticipants());
        pricing.setOriginalPrice(request.getOriginalPrice());
        pricing.setDiscountPrice(request.getDiscountPrice());
        pricingMapper.upsert(pricing);
    }

    private void insertPricingConfigurations(Long scenicSpotId, ScenicSpotDetailSaveRequest request) {
        insertPricing(scenicSpotId, ServiceType.GROUP_QUICK.getCode(), request.getGroupFast());
        insertPricing(scenicSpotId, ServiceType.GROUP_PREMIUM.getCode(), request.getGroupPremium());
        insertPricing(scenicSpotId, ServiceType.PRIVATE_QUICK.getCode(), request.getPrivateFast());
        insertPricing(scenicSpotId, ServiceType.PRIVATE_PREMIUM.getCode(), request.getPrivatePremium());
    }

    private void validateDetailRequest(ScenicSpotDetailSaveRequest request) {
        validatePricing(request.getGroupFast(), true);
        validatePricing(request.getGroupPremium(), true);
        validatePricing(request.getPrivateFast(), false);
        validatePricing(request.getPrivatePremium(), false);
    }

    private void applyDetailFields(OperationScenicSpot scenicSpot, Long cityId, String scenicCode, String scenicName,
                                   ScenicSpotDetailSaveRequest request) {
        scenicSpot.setScenicCode(scenicCode);
        scenicSpot.setScenicName(scenicName);
        scenicSpot.setCityId(cityId);
        scenicSpot.setFirstOrderLeadMinutes(request.getFirstOrderLeadMinutes());
        scenicSpot.setVisitorNoOrderMinutes(request.getVisitorNoOrderMinutes());
        scenicSpot.setUnpaidCancelMinutes(request.getUnpaidCancelMinutes());
    }

    private void validatePricing(ScenicPriceConfigRequest request, boolean groupService) {
        if (groupService && request.getMaxParticipants() == null) {
            throw new BusinessException(400, "拼团讲解必须配置最多讲解人数");
        }
        if (request.getMaxParticipants() != null
                && request.getMaxParticipants() < request.getMinParticipants()) {
            throw new BusinessException(400, "最多讲解人数不能小于最少讲解人数");
        }
        if (request.getDiscountPrice().compareTo(request.getOriginalPrice()) > 0) {
            throw new BusinessException(400, "优惠价不能高于原价");
        }
        if (!groupService) { request.setMaxParticipants(null); }
    }

    private ScenicPriceConfigResponse priceResponse(Map<String, ScenicPricing> pricingMap, String serviceType) {
        ScenicPricing pricing = pricingMap.get(serviceType);
        if (pricing == null) { throw new BusinessException(500, "景区价格配置不完整"); }
        return ScenicPriceConfigResponse.from(pricing);
    }

    private BigDecimal discountPrice(ScenicPricing pricing) {
        return pricing == null ? BigDecimal.ZERO : pricing.getDiscountPrice();
    }

    private OperationScenicSpot requireScenicSpot(Long id) {
        OperationScenicSpot scenicSpot = scenicSpotMapper.selectById(id);
        if (scenicSpot == null) { throw new BusinessException(404, "景区不存在"); }
        return scenicSpot;
    }

    private OperationCity requireCity(Long id) {
        OperationCity city = cityMapper.selectById(id);
        if (city == null) { throw new BusinessException(404, "所属城市不存在"); }
        return city;
    }

    private void ensureUniqueName(Long id, Long cityId, String scenicName) {
        LambdaQueryWrapper<OperationScenicSpot> query = new LambdaQueryWrapper<OperationScenicSpot>()
                .eq(OperationScenicSpot::getCityId, cityId)
                .eq(OperationScenicSpot::getScenicName, scenicName)
                .ne(id != null, OperationScenicSpot::getId, id);
        if (scenicSpotMapper.selectCount(query) > 0) {
            throw new BusinessException(409, "该城市下已存在同名景区");
        }
    }

    private void ensureUniqueCode(Long id, String scenicCode) {
        LambdaQueryWrapper<OperationScenicSpot> query = new LambdaQueryWrapper<OperationScenicSpot>()
                .eq(OperationScenicSpot::getScenicCode, scenicCode)
                .ne(id != null, OperationScenicSpot::getId, id);
        if (scenicSpotMapper.selectCount(query) > 0) {
            throw new BusinessException(409, "景区编号已存在");
        }
    }
}