package com.tourguide.modules.user.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.user.dto.GuideRegistrationTeamOptionResponse;
import com.tourguide.modules.user.dto.GuideTeamResponse;
import com.tourguide.modules.user.dto.GuideTeamCollectionGuideResponse;
import com.tourguide.modules.user.dto.GuideTeamScenicRequest;
import com.tourguide.modules.user.dto.GuideTeamSaveRequest;
import com.tourguide.modules.user.entity.GuideTeam;
import com.tourguide.modules.user.entity.GuideTeamScenicConfig;
import com.tourguide.modules.user.entity.GuideUser;
import com.tourguide.modules.user.mapper.GuideTeamMapper;
import com.tourguide.modules.user.mapper.GuideTeamScenicConfigMapper;
import com.tourguide.modules.user.mapper.GuideUserMapper;
import com.tourguide.modules.finance.mapper.GuideWithdrawalMapper;
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.mapper.OperationCityMapper;
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
import com.tourguide.modules.operation.mapper.ScenicMeetingPointMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class GuideTeamService {
    private final GuideTeamMapper teamMapper;
    private final GuideTeamScenicConfigMapper scenicConfigMapper;
    private final GuideUserMapper guideUserMapper;
    private final GuideWithdrawalMapper withdrawalMapper;
    private final OperationScenicSpotMapper operationScenicSpotMapper;
    private final OperationCityMapper operationCityMapper;
    private final ScenicMeetingPointMapper meetingPointMapper;

    public GuideTeamService(GuideTeamMapper teamMapper, GuideTeamScenicConfigMapper scenicConfigMapper,
                            GuideUserMapper guideUserMapper, GuideWithdrawalMapper withdrawalMapper) {
        this(teamMapper, scenicConfigMapper, guideUserMapper, withdrawalMapper,
                null, null, null);
    }

    @Autowired
    public GuideTeamService(GuideTeamMapper teamMapper, GuideTeamScenicConfigMapper scenicConfigMapper,
                            GuideUserMapper guideUserMapper, GuideWithdrawalMapper withdrawalMapper,
                            OperationScenicSpotMapper operationScenicSpotMapper,
                            OperationCityMapper operationCityMapper,
                            ScenicMeetingPointMapper meetingPointMapper) {
        this.teamMapper = teamMapper;
        this.scenicConfigMapper = scenicConfigMapper;
        this.guideUserMapper = guideUserMapper;
        this.withdrawalMapper = withdrawalMapper;
        this.operationScenicSpotMapper = operationScenicSpotMapper;
        this.operationCityMapper = operationCityMapper;
        this.meetingPointMapper = meetingPointMapper;
    }

    public GuideTeamResponse detail(Long id) {
        GuideTeam team = requireTeam(id);
        List<GuideTeamScenicConfig> scenicConfigs = scenicConfigMapper.selectList(
                new LambdaQueryWrapper<GuideTeamScenicConfig>()
                        .eq(GuideTeamScenicConfig::getTeamId, id)
                        .orderByAsc(GuideTeamScenicConfig::getId));
        return GuideTeamResponse.from(team, scenicConfigs);
    }

    public PageResponse<GuideTeamResponse> page(long page, long size, String keyword, Integer status,
                                                LocalDate startDate, LocalDate endDate) {
        LambdaQueryWrapper<GuideTeam> query = new LambdaQueryWrapper<GuideTeam>();
        if (StringUtils.hasText(keyword)) {
            String searchKeyword = keyword.trim();
            query.and(wrapper -> wrapper.like(GuideTeam::getTeamName, searchKeyword)
                    .or().like(GuideTeam::getContactPhone, searchKeyword));
        }
        query.eq(status != null, GuideTeam::getStatus, status)
                .ge(startDate != null, GuideTeam::getCreatedAt, startDate == null ? null : startDate.atStartOfDay())
                .lt(endDate != null, GuideTeam::getCreatedAt, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
                .orderByDesc(GuideTeam::getId);
        Page<GuideTeam> result = teamMapper.selectPage(new Page<GuideTeam>(page, size), query);
        return new PageResponse<GuideTeamResponse>(
                result.getRecords().stream().map(GuideTeamResponse::from).collect(Collectors.toList()),
                result.getTotal(), result.getCurrent(), result.getSize());
    }

    public List<GuideRegistrationTeamOptionResponse> registrationOptions() {
        List<GuideRegistrationTeamOptionResponse> options = new ArrayList<GuideRegistrationTeamOptionResponse>();
        options.add(GuideRegistrationTeamOptionResponse.personal());
        List<GuideTeam> teams = teamMapper.selectList(new LambdaQueryWrapper<GuideTeam>()
                .eq(GuideTeam::getStatus, 1)
                .orderByAsc(GuideTeam::getTeamName));
        for (GuideTeam team : teams) {
            options.add(GuideRegistrationTeamOptionResponse.team(team));
        }
        return options;
    }

    public List<GuideTeamCollectionGuideResponse> collectionGuideOptions(Long teamId) {
        requireTeam(teamId);
        return guideUserMapper.selectList(new LambdaQueryWrapper<GuideUser>()
                        .eq(GuideUser::getTeamId, teamId)
                        .orderByAsc(GuideUser::getRealName)
                        .orderByAsc(GuideUser::getId))
                .stream()
                .map(guide -> new GuideTeamCollectionGuideResponse(
                        guide, withdrawalMapper.countActiveByGuideId(guide.getId()) > 0))
                .collect(Collectors.toList());
    }

    @Transactional
    public GuideTeamResponse create(GuideTeamSaveRequest request) {
        ensureNameAvailable(request.getTeamName(), null);
        GuideTeam team = new GuideTeam();
        apply(team, request);
        team.setCollectionGuideId(null);
        team.setBalance(java.math.BigDecimal.ZERO);
        team.setStatus(1);
        teamMapper.insert(team);
        if (request.getCollectionGuideId() != null) {
            validateCollectionGuide(team.getId(), request.getCollectionGuideId());
            team.setCollectionGuideId(request.getCollectionGuideId());
            teamMapper.updateById(team);
        }
        replaceScenicConfigs(team.getId(), request.getScenicConfigs());
        return detail(team.getId());
    }

    @Transactional
    public GuideTeamResponse update(Long id, GuideTeamSaveRequest request) {
        GuideTeam team = requireTeam(id);
        ensureNameAvailable(request.getTeamName(), id);
        if (!java.util.Objects.equals(team.getCollectionGuideId(), request.getCollectionGuideId())) {
            validateCollectionGuide(id, request.getCollectionGuideId());
        }
        apply(team, request);
        teamMapper.updateById(team);
        replaceScenicConfigs(id, request.getScenicConfigs());
        return detail(id);
    }

    @Transactional
    public void updateStatus(Long id, Integer status) {
        GuideTeam team = requireTeam(id);
        team.setStatus(status);
        teamMapper.updateById(team);
    }

    private GuideTeam requireTeam(Long id) {
        GuideTeam team = teamMapper.selectById(id);
        if (team == null) {
            throw new BusinessException(404, "讲解队不存在");
        }
        return team;
    }

    private void ensureNameAvailable(String teamName, Long excludedId) {
        LambdaQueryWrapper<GuideTeam> query = new LambdaQueryWrapper<GuideTeam>()
                .eq(GuideTeam::getTeamName, teamName.trim())
                .ne(excludedId != null, GuideTeam::getId, excludedId);
        if (teamMapper.selectCount(query) > 0) {
            throw new BusinessException(409, "讲解队名称已存在");
        }
    }

    private void apply(GuideTeam team, GuideTeamSaveRequest request) {
        List<GuideTeamScenicRequest> scenicConfigs = request.getScenicConfigs() == null
                ? Collections.<GuideTeamScenicRequest>emptyList()
                : request.getScenicConfigs();
        team.setTeamName(request.getTeamName().trim());
        team.setContactPhone(request.getContactPhone().trim());
        team.setOperatingArea(scenicConfigs.stream()
                .map(GuideTeamScenicRequest::getScenicName)
                .filter(StringUtils::hasText)
                .map(String::trim)
                .distinct()
                .collect(Collectors.joining("，")));
        team.setCompanyName(trimToNull(request.getCompanyName()));
        team.setUnifiedSocialCreditCode(trimToNull(request.getUnifiedSocialCreditCode()));
        team.setCommissionRatio(request.getCommissionRatio());
        team.setWechatOpenId(trimToNull(request.getWechatOpenId()));
        team.setMerchantId(trimToNull(request.getMerchantId()));
        team.setCollectionGuideId(request.getCollectionGuideId());
    }

    private void validateCollectionGuide(Long teamId, Long guideId) {
        if (guideId == null) return;
        GuideUser guide = guideUserMapper.selectForUpdate(guideId);
        if (guide == null || guide.getStatus() == null || guide.getStatus() != 1) {
            throw new BusinessException(409, "收款导游不存在或已停用");
        }
        if (!teamId.equals(guide.getTeamId())) {
            throw new BusinessException(409, "收款导游必须属于当前讲解队");
        }
        if (guide.getBalance() != null && guide.getBalance().signum() != 0) {
            throw new BusinessException(409, "导游账户余额必须为0才能配置为收款导游");
        }
        if (withdrawalMapper.countActiveByGuideId(guideId) > 0) {
            throw new BusinessException(409, "导游存在进行中的提现单，不能配置为收款导游");
        }
    }

    private void replaceScenicConfigs(Long teamId, List<GuideTeamScenicRequest> requests) {
        scenicConfigMapper.markDeletedByTeamId(teamId);
        if (requests == null) {
            return;
        }
        Set<String> scenicNames = new HashSet<String>();
        for (GuideTeamScenicRequest request : requests) {
            validateManagedScenic(request);
            String scenicName = request.getScenicName().trim();
            if (!scenicNames.add(scenicName)) {
                throw new BusinessException(409, "同一讲解队不能重复配置相同景区");
            }
            GuideTeamScenicConfig config = new GuideTeamScenicConfig();
            config.setTeamId(teamId);
            config.setScenicName(scenicName);
            config.setCityName(request.getCityName().trim());
            config.setMeetingPoints(request.getMeetingPoints().trim());
            scenicConfigMapper.upsert(config);
        }
    }

    private void validateManagedScenic(GuideTeamScenicRequest request) {
        if (operationScenicSpotMapper == null || operationCityMapper == null || meetingPointMapper == null) {
            throw new BusinessException(500, "景区配置校验服务未初始化");
        }
        OperationCity city = operationCityMapper.selectOne(new LambdaQueryWrapper<OperationCity>()
                .eq(OperationCity::getCityName, request.getCityName().trim())
                .eq(OperationCity::getStatus, 1)
                .last("LIMIT 1"));
        if (city == null) {
            throw new BusinessException(400, "所选景区城市不存在或已停用");
        }
        OperationScenicSpot scenicSpot = operationScenicSpotMapper.selectOne(
                new LambdaQueryWrapper<OperationScenicSpot>()
                        .eq(OperationScenicSpot::getScenicName, request.getScenicName().trim())
                        .eq(OperationScenicSpot::getCityId, city.getId())
                        .eq(OperationScenicSpot::getStatus, 1)
                        .last("LIMIT 1"));
        if (scenicSpot == null) {
            throw new BusinessException(400, "所选景区不存在或已停用");
        }
        Set<String> allowedMeetingPoints = meetingPointMapper.selectList(
                        new LambdaQueryWrapper<ScenicMeetingPoint>()
                                .eq(ScenicMeetingPoint::getScenicSpotId, scenicSpot.getId())
                                .eq(ScenicMeetingPoint::getStatus, 1))
                .stream().map(ScenicMeetingPoint::getPointName).collect(Collectors.toSet());
        List<String> selectedMeetingPoints = java.util.Arrays.stream(request.getMeetingPoints().split("[,，]"))
                .map(String::trim).filter(StringUtils::hasText).collect(Collectors.toList());
        if (selectedMeetingPoints.isEmpty()
                || selectedMeetingPoints.size() != new HashSet<String>(selectedMeetingPoints).size()
                || !allowedMeetingPoints.containsAll(selectedMeetingPoints)) {
            throw new BusinessException(400, "汇合点必须从所选景区的启用汇合点中选择");
        }
        request.setScenicName(scenicSpot.getScenicName());
        request.setCityName(city.getCityName());
        request.setMeetingPoints(String.join("，", selectedMeetingPoints));
    }

    private String trimToNull(String value) {
        return StringUtils.hasText(value) ? value.trim() : null;
    }
}