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.common.validation.ChineseIdCardValidator;
import com.tourguide.modules.order.dto.VisitorOrderStatRow;
import com.tourguide.modules.order.mapper.TourOrderMapper;
import com.tourguide.modules.review.dto.VisitorReviewStatRow;
import com.tourguide.modules.review.mapper.OrderReviewMapper;
import com.tourguide.modules.user.dto.MiniProfileUpdateRequest;
import com.tourguide.modules.user.dto.MiniRealNameUpdateRequest;
import com.tourguide.modules.user.dto.MiniUserDetailResponse;
import com.tourguide.modules.user.dto.MiniUserResponse;
import com.tourguide.modules.user.entity.MiniUser;
import com.tourguide.modules.user.mapper.MiniUserMapper;
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.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/** 仅处理小程序用户，管理后台只能通过本服务执行查询或状态管理。 */
@Service
public class MiniUserService {
    private final MiniUserMapper userMapper;
    private final TourOrderMapper orderMapper;
    private final OrderReviewMapper reviewMapper;

    public MiniUserService(MiniUserMapper userMapper, TourOrderMapper orderMapper, OrderReviewMapper reviewMapper) {
        this.userMapper = userMapper;
        this.orderMapper = orderMapper;
        this.reviewMapper = reviewMapper;
    }

    public MiniUser findEnabledById(Long id) {
        MiniUser user = userMapper.selectById(id);
        if (user == null || user.getStatus() == null || user.getStatus() != 1) {
            throw new BusinessException(401, "小程序用户不存在或已停用");
        }
        return user;
    }

    public MiniUser findByUsername(String username) {
        return userMapper.selectOne(new LambdaQueryWrapper<MiniUser>().eq(MiniUser::getUsername, username).last("LIMIT 1"));
    }

    public PageResponse<MiniUserResponse> page(long page, long size, String keyword, Integer status,
                                                LocalDate startDate, LocalDate endDate) {
        LambdaQueryWrapper<MiniUser> query = new LambdaQueryWrapper<MiniUser>();
        if (StringUtils.hasText(keyword)) {
            String searchKeyword = keyword.trim();
            query.and(wrapper -> {
                wrapper.like(MiniUser::getUsername, searchKeyword)
                        .or().like(MiniUser::getNickname, searchKeyword)
                        .or().like(MiniUser::getMobile, searchKeyword);
                if (searchKeyword.matches("\\d+")) {
                    wrapper.or().eq(MiniUser::getId, Long.valueOf(searchKeyword));
                }
            });
        }
        query.eq(status != null, MiniUser::getStatus, status)
                .ge(startDate != null, MiniUser::getCreatedAt, startDate == null ? null : startDate.atStartOfDay())
                .lt(endDate != null, MiniUser::getCreatedAt, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
                .orderByDesc(MiniUser::getId);
        Page<MiniUser> result = userMapper.selectPage(new Page<MiniUser>(page, size), query);
        List<MiniUser> users = result.getRecords();
        Map<Long, UserStats> statsByUserId = loadUserStats(
                users.stream().map(MiniUser::getId).collect(Collectors.toList()));
        return new PageResponse<MiniUserResponse>(users.stream()
                .map(user -> MiniUserResponse.from(user, statsOf(statsByUserId, user.getId()).orderCount))
                .collect(Collectors.toList()),
                result.getTotal(), result.getCurrent(), result.getSize());
    }

    public MiniUserDetailResponse detail(Long id) {
        MiniUser user = userMapper.selectById(id);
        if (user == null) { throw new BusinessException(404, "游客不存在"); }
        UserStats stats = statsOf(loadUserStats(Collections.singletonList(id)), id);
        return MiniUserDetailResponse.from(user, stats.orderCount, stats.totalConsumption, stats.reviewCount);
    }

    private Map<Long, UserStats> loadUserStats(List<Long> visitorIds) {
        if (visitorIds.isEmpty()) { return Collections.emptyMap(); }
        Map<Long, UserStats> statsByUserId = new HashMap<Long, UserStats>();
        for (Long visitorId : visitorIds) {
            statsByUserId.put(visitorId, new UserStats());
        }
        List<VisitorOrderStatRow> orderRows = orderMapper.selectVisitorOrderStats(visitorIds);
        if (orderRows != null) {
            for (VisitorOrderStatRow row : orderRows) {
                if (row.getVisitorId() == null) { continue; }
                UserStats stats = statsByUserId.computeIfAbsent(row.getVisitorId(), ignored -> new UserStats());
                stats.orderCount = defaultLong(row.getOrderCount());
                stats.totalConsumption = row.getTotalConsumption() == null ? BigDecimal.ZERO : row.getTotalConsumption();
            }
        }
        List<VisitorReviewStatRow> reviewRows = reviewMapper.selectVisitorReviewStats(visitorIds);
        if (reviewRows != null) {
            for (VisitorReviewStatRow row : reviewRows) {
                if (row.getVisitorId() == null) { continue; }
                statsByUserId.computeIfAbsent(row.getVisitorId(), ignored -> new UserStats())
                        .reviewCount = defaultLong(row.getReviewCount());
            }
        }
        return statsByUserId;
    }

    private static UserStats statsOf(Map<Long, UserStats> statsByUserId, Long userId) {
        UserStats stats = statsByUserId.get(userId);
        return stats == null ? new UserStats() : stats;
    }

    private static long defaultLong(Long value) {
        return value == null ? 0L : value;
    }

    @Transactional
    public MiniUserResponse updateProfile(Long id, MiniProfileUpdateRequest request) {
        MiniUser user = findEnabledById(id);
        user.setNickname(request.getNickname().trim());
        userMapper.updateById(user);
        return MiniUserResponse.from(user);
    }

    @Transactional
    public MiniUserResponse updateAvatar(Long id, String avatar) {
        MiniUser user = findEnabledById(id);
        user.setAvatar(avatar);
        userMapper.updateById(user);
        return MiniUserResponse.from(user);
    }

    @Transactional
    public MiniUserResponse updateRealName(Long id, MiniRealNameUpdateRequest request) {
        MiniUser user = findEnabledById(id);
        String idCardNo = request.getIdCardNo().trim().toUpperCase();
        if (!ChineseIdCardValidator.isValid(idCardNo)) {
            throw new BusinessException(400, "身份证号格式不正确");
        }
        if (userMapper.selectCount(new LambdaQueryWrapper<MiniUser>()
                .eq(MiniUser::getIdCardNo, idCardNo)
                .ne(MiniUser::getId, id)) > 0) {
            throw new BusinessException(409, "该身份证号已被其他账号使用");
        }
        user.setRealName(request.getRealName().trim());
        user.setIdCardNo(idCardNo);
        userMapper.updateById(user);
        return MiniUserResponse.from(user);
    }

    @Transactional
    public void updateStatus(Long id, Integer status) {
        MiniUser user = userMapper.selectById(id);
        if (user == null) { throw new BusinessException(404, "小程序用户不存在"); }
        user.setStatus(status);
        userMapper.updateById(user);
    }

    private static final class UserStats {
        private long orderCount;
        private BigDecimal totalConsumption = BigDecimal.ZERO;
        private long reviewCount;
    }
}