package shop.alien.store.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import shop.alien.entity.store.StoreImg;
import shop.alien.entity.store.StoreInfo;
import shop.alien.entity.store.StoreOfficialAlbum;
import shop.alien.entity.store.StoreVideo;
import shop.alien.entity.store.vo.StoreAlbumDetailVo;
import shop.alien.entity.store.vo.StoreAlbumNameVo;
import shop.alien.entity.store.vo.StoreOfficialAlbumImgVo;
import shop.alien.entity.store.vo.StoreOfficialAlbumVo;
import shop.alien.mapper.StoreImgMapper;
import shop.alien.mapper.StoreInfoMapper;
import shop.alien.mapper.StoreOfficialAlbumMapper;
import shop.alien.mapper.StoreVideoMapper;
import shop.alien.store.service.StoreImgService;
import shop.alien.store.service.StoreOfficialAlbumService;
import shop.alien.store.service.StoreVideoService;
import shop.alien.store.util.CommonConstant;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Transactional
@Service
@RequiredArgsConstructor
public class StoreOfficialAlbumServiceImpl extends ServiceImpl<StoreOfficialAlbumMapper, StoreOfficialAlbum> implements StoreOfficialAlbumService {

    private final StoreOfficialAlbumMapper storeOfficialAlbumMapper;
    private final StoreImgMapper storeImgMapper;

    private final StoreVideoMapper storeVideoMapper;

    private final StoreInfoMapper storeInfoMapper;

    private final StoreImgService storeImgService;

    private final StoreVideoService storeVideoService;
    /**
     * 创建官方相册
     *
     * @param storeOfficialAlbum 官方相册信息
     * @return storeOfficialAlbum 官方相册信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public StoreOfficialAlbum createOrUpdateOfficialAlbum(StoreOfficialAlbum storeOfficialAlbum) {
        // 参数校验
        if (storeOfficialAlbum == null) {
            throw new IllegalArgumentException("相册信息不能为空");
        }
        if (storeOfficialAlbum.getStoreId() == null || storeOfficialAlbum.getStoreId() <= 0) {
            throw new IllegalArgumentException("门店ID不能为空且必须大于0");
        }
        if (StringUtils.isBlank(storeOfficialAlbum.getAlbumName())) {
            throw new IllegalArgumentException("相册名称不能为空");
        }
        
        // 检查同一门店下相册名称是否重复
        LambdaQueryWrapper<StoreOfficialAlbum> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(StoreOfficialAlbum::getStoreId, storeOfficialAlbum.getStoreId())
                .eq(StoreOfficialAlbum::getAlbumName, storeOfficialAlbum.getAlbumName())
                .eq(StoreOfficialAlbum::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);
        
        // 如果是更新操作，排除当前记录
        Integer id = storeOfficialAlbum.getId();
        if (id != null && id > 0) {
            queryWrapper.ne(StoreOfficialAlbum::getId, id);
        }
        
        long count = storeOfficialAlbumMapper.selectCount(queryWrapper);
        if (count > 0) {
            throw new RuntimeException("同一门店下相册名称不能重复");
        }
        
        if (id != null && id > 0) {
            boolean updateSuccess = storeOfficialAlbumMapper.updateById(storeOfficialAlbum) > 0;
            if (!updateSuccess) {
                throw new RuntimeException("更新官方相册失败");
            }
        } else {
            boolean insertSuccess = storeOfficialAlbumMapper.insert(storeOfficialAlbum) > 0;
            if (!insertSuccess) {
                throw new RuntimeException("插入官方相册失败");
            }
        }
        return storeOfficialAlbum;
    }

    /**
     * 根据storeId查询官方相册列表
     *
     * @param storeId 店铺ID
     * @return List<StoreOfficialAlbumVo> 官方相册列表
     */
    @Override
    public List<StoreOfficialAlbumVo> getOfficialAlbumList(String storeId) {
        if(StringUtils.isNotBlank(storeId)) {
            //查询出店铺官方相册img数量并更新
            List<StoreOfficialAlbum> storeOfficialAlbumList = storeOfficialAlbumMapper.getStoreOfficialAlbumImgCount(Integer.parseInt(storeId));
            if(CollectionUtils.isNotEmpty(storeOfficialAlbumList)) {
                this.updateBatchById(storeOfficialAlbumList);
            }

            // 查询官方相册列表
            List<StoreOfficialAlbumVo> albumVoList = storeOfficialAlbumMapper.getStoreOfficialAlbumList(Integer.parseInt(storeId));
            
            // 为每个相册设置第一张图片，如果是视频相册则返回视频封面
            for (StoreOfficialAlbumVo albumVo : albumVoList) {
                // 如果是视频相册，查询视频封面
                if ("视频".equals(albumVo.getAlbumName())) {
                    String coverUrl = getVideoAlbumCover(Integer.parseInt(storeId), albumVo.getId());
                    if (StringUtils.isNotBlank(coverUrl)) {
                        albumVo.setImgUrl(coverUrl);
                    }
                }
                // 其他相册的imgUrl已经在SQL查询中设置了第一张图片
            }
            
            return albumVoList;
        }
        return Collections.emptyList();
    }
    
    /**
     * 获取视频相册的封面（第一个视频的封面）
     *
     * @param storeId 门店ID
     * @param albumId 相册ID
     * @return 封面URL
     */
    private String getVideoAlbumCover(Integer storeId, Integer albumId) {
        try {
            // 查询该相册下的第一个视频
            LambdaQueryWrapper<StoreVideo> videoQueryWrapper = new LambdaQueryWrapper<>();
            videoQueryWrapper.eq(StoreVideo::getStoreId, storeId)
                    .eq(StoreVideo::getBusinessId, albumId)
                    .eq(StoreVideo::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE)
                    .orderByAsc(StoreVideo::getImgSort)
                    .orderByAsc(StoreVideo::getCreatedTime)
                    .last("LIMIT 1");
            
            List<StoreVideo> videoList = storeVideoMapper.selectList(videoQueryWrapper);
            if (!CollectionUtils.isEmpty(videoList)) {
                StoreVideo firstVideo = videoList.get(0);
                String imgUrl = firstVideo.getImgUrl();
                if (StringUtils.isNotBlank(imgUrl)) {
                    // 解析JSON格式，提取cover字段
                    return extractCoverFromVideoUrl(imgUrl);
                }
            }
        } catch (Exception e) {
            log.error("获取视频相册封面失败，门店ID：{}，相册ID：{}，错误：{}", storeId, albumId, e.getMessage(), e);
        }
        return null;
    }
    
    /**
     * 从视频URL（JSON格式）中提取封面URL
     *
     * @param imgUrl 视频URL，格式：{"video": "...", "cover": "..."} 或 [{"video": "...", "cover": "..."}]
     * @return 封面URL
     */
    private String extractCoverFromVideoUrl(String imgUrl) {
        if (StringUtils.isBlank(imgUrl)) {
            return null;
        }
        
        try {
            // 尝试解析为JSON对象
            JSONObject jsonObject = JSON.parseObject(imgUrl);
            if (jsonObject != null && jsonObject.containsKey("cover")) {
                return jsonObject.getString("cover");
            }
        } catch (Exception e1) {
            // 如果不是对象格式，尝试解析为数组格式
            try {
                JSONArray jsonArray = JSONArray.parseArray(imgUrl);
                if (jsonArray != null && !jsonArray.isEmpty()) {
                    JSONObject firstItem = jsonArray.getJSONObject(0);
                    if (firstItem != null && firstItem.containsKey("cover")) {
                        return firstItem.getString("cover");
                    }
                }
            } catch (Exception e2) {
                log.debug("解析视频URL失败，imgUrl：{}", imgUrl);
            }
        }
        return null;
    }

    /**
     * 根据storeId查询官方相册列表
     *
     * @param storeOfficialAlbumList 根据官方相册信息删除官方相册及图片
     * @return result 删除结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteOfficialAlbum(List<StoreOfficialAlbum> storeOfficialAlbumList) {

        // 校验官方相册列表
        if (storeOfficialAlbumList == null || storeOfficialAlbumList.isEmpty()) {
            return CommonConstant.ERROR_CODE_INVALID_PARAMS;
        }
        List<Integer> albumIds =storeOfficialAlbumList.stream().map(StoreOfficialAlbum::getId).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(albumIds)) {
            return CommonConstant.ERROR_CODE_INVALID_PARAMS;
        }

        // 删除相册
        storeOfficialAlbumMapper.deleteBatchIds(albumIds);
        // 删除图片（批量删除）
        LambdaUpdateWrapper<StoreImg> wrapper = new LambdaUpdateWrapper<StoreImg>()
                .in(StoreImg::getBusinessId, albumIds)
                .eq(StoreImg::getImgType, CommonConstant.STORE_IMG_ALBUM);
        storeImgMapper.delete(wrapper);
        return CommonConstant.ERROR_CODE_VALID_PARAMS;
    }


    /**
     * 获取官方相册图片列表（客户端）
     * <p>
     * 根据门店ID和相册名称查询官方相册中的图片列表
     * 查询条件：imgType = 2（官方相册），通过 business_id 关联到 store_official_album 表，按 albumName 筛选
     * </p>
     *
     * @param storeId   门店ID，必填，必须大于0
     * @param albumName 相册名称，可选。例如：酒水、餐食、环境、全部等。当为null或空字符串时，查询全部
     * @param type      类型，必填。1：视频，2：相册，3：环境
     * @param pageNum   页码，可选，默认1
     * @param pageSize  每页数量，可选，默认10
     * @return 图片列表和总数
     */
    @Override
    public StoreOfficialAlbumImgVo getOfficialAlbumImgList(Integer storeId, String albumName, Integer type, Integer pageNum, Integer pageSize) {
        log.info("开始获取官方相册图片列表，门店ID：{}，相册名称：{}，类型：{}", storeId, albumName, type);

        // 参数校验
        if (storeId == null || storeId <= 0) {
            log.warn("获取官方相册图片列表失败，门店ID无效：{}", storeId);
            throw new IllegalArgumentException("门店ID不能为空且必须大于0");
        }

        if (type == null || type <= 0) {
            log.warn("获取类型无效：{}", type);
            throw new IllegalArgumentException("类型不能为空且必须大于0");
        }
        //视频
        if (type == 1) {
            // 查询视频相册（只查询视频表）
            LambdaQueryWrapper<StoreVideo> videoQueryWrapper = new LambdaQueryWrapper<>();
            videoQueryWrapper.eq(StoreVideo::getStoreId, storeId)
                    .eq(StoreVideo::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);
            
            // 如果指定了相册名称，根据相册名称找到对应的相册ID，然后查询该相册下的视频
            if (StringUtils.isNotBlank(albumName)) {
                LambdaQueryWrapper<StoreOfficialAlbum> albumQueryWrapper = new LambdaQueryWrapper<>();
                albumQueryWrapper.eq(StoreOfficialAlbum::getStoreId, storeId)
                        .eq(StoreOfficialAlbum::getAlbumName, albumName)
                        .eq(StoreOfficialAlbum::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);
                List<StoreOfficialAlbum> albumList = storeOfficialAlbumMapper.selectList(albumQueryWrapper);
                
                if (!CollectionUtils.isEmpty(albumList)) {
                    // 提取相册ID列表
                    List<Integer> albumIds = albumList.stream()
                            .map(StoreOfficialAlbum::getId)
                            .collect(Collectors.toList());
                    // 根据相册ID筛选视频
                    videoQueryWrapper.in(StoreVideo::getBusinessId, albumIds);
                } else {
                    // 如果未找到对应的相册，返回空结果
                    log.info("获取视频列表，门店ID：{}，相册名称：{}，未找到对应的相册", storeId, albumName);
                    StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
                    result.setVideoList(Collections.emptyList());
                    return result;
                }
            }
            videoQueryWrapper.orderByAsc(StoreVideo::getImgSort);
            List<StoreVideo> videoList = storeVideoMapper.selectList(videoQueryWrapper);
            StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
            result.setVideoList(videoList);
            return result;
        }
        //相册
        if (type == 2) {
            // 先查询符合条件的官方相册ID列表
            LambdaQueryWrapper<StoreOfficialAlbum> albumQueryWrapper = new LambdaQueryWrapper<>();
            albumQueryWrapper.eq(StoreOfficialAlbum::getStoreId, storeId)
                    .eq(StoreOfficialAlbum::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);

            // 如果指定了相册名称，添加筛选条件
            if (StringUtils.isNotBlank(albumName)) {
                albumQueryWrapper.eq(StoreOfficialAlbum::getAlbumName, albumName);
            }

            List<StoreOfficialAlbum> albumList = storeOfficialAlbumMapper.selectList(albumQueryWrapper);

            // 如果相册列表为空，直接返回空结果
            if (CollectionUtils.isEmpty(albumList)) {
                log.info("获取官方相册图片列表，门店ID：{}，未查询到符合条件的相册", storeId);
                StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
                result.setImgList(Collections.emptyList());
                result.setTotalCount(0);
                return result;
            }

            // 提取相册ID列表
            List<Integer> albumIds = albumList.stream()
                    .map(StoreOfficialAlbum::getId)
                    .collect(Collectors.toList());

            log.debug("查询到符合条件的相册数量：{}，相册ID列表：{}", albumList.size(), albumIds);

            // 查询这些相册下的所有图片（imgType = 2 表示官方相册）
//            LambdaQueryWrapper<StoreImg> imgQueryWrapper = new LambdaQueryWrapper<>();
//            imgQueryWrapper.eq(StoreImg::getStoreId, storeId)
//                    .eq(StoreImg::getImgType, CommonConstant.STORE_IMG_ALBUM) // imgType = 2 表示官方相册
//                    .in(StoreImg::getBusinessId, albumIds) // business_id 关联到相册ID
//                    .eq(StoreImg::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE)
//                    .orderByAsc(StoreImg::getImgSort);
//
//            List<StoreImg> imgList = storeImgMapper.selectList(imgQueryWrapper);

            // 使用连表查询获取图片列表（包含相册名称）
            // 连接条件：store_img.business_id = store_official_album.id
            List<StoreImg> imgList = storeImgMapper.selectOfficialAlbumImgWithName(
                    storeId,
                    CommonConstant.STORE_IMG_ALBUM, // imgType = 2 表示官方相册
                    albumIds
            );

            // 构建返回结果
            StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
            result.setImgList(imgList);
            result.setTotalCount(imgList.size());

            log.info("获取官方相册图片列表完成，门店ID：{}，相册名称：{}，返回图片数量：{}",
                    storeId, albumName, result.getTotalCount());

            return result;
        }
        //封面
        if (type == 3) {
            StoreInfo storeInfo = storeInfoMapper.getStoreInfo(storeId);

            if (storeInfo == null) {
                log.warn("获取门店信息失败，门店ID：{}", storeId);
                StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
                result.setImgList(Collections.emptyList());
                result.setTotalCount(0);
                return result;
            }
            // 单图模式 封面
            if (storeInfo.getImgMode() == 0) {
                List<StoreImg> imgList = storeImgService.getByCover(storeId, 20);
                StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
                result.setImgList(imgList);
                return result;
            }
            // 多图模式 封面
            if (storeInfo.getImgMode() == 1) {
                List<StoreImg> imgList = storeImgService.getByCover(storeId, 21);
                StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
                result.setImgList(imgList);
                return result;
            }
        }
        //环境
        if (type == 4){
            List<StoreImg> imgList = storeImgService.getByCover(storeId, 4);
            StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
            result.setImgList(imgList);
            return result;
        }

        // 默认返回空结果
        StoreOfficialAlbumImgVo result = new StoreOfficialAlbumImgVo();
        result.setImgList(Collections.emptyList());
        result.setTotalCount(0);
        return result;
    }

    /**
     * 获取官方相册名称列表（客户端）
     * <p>
     * 根据门店ID查询所有可用的相册名称列表，用于前端展示筛选选项
     * 返回每个相册名称及其对应的图片数量
     * </p>
     *
     * @param storeId 门店ID，必填
     * @return 相册名称列表，包含相册名称和图片数量
     */
    @Override
    public List<StoreAlbumNameVo> getAlbumNameList(Integer storeId) {
        log.info("开始获取官方相册名称列表，门店ID：{}", storeId);

        // 参数校验
        if (storeId == null || storeId <= 0) {
            log.warn("获取官方相册名称列表失败，门店ID无效：{}", storeId);
            throw new IllegalArgumentException("门店ID不能为空且必须大于0");
        }

        // 查询该门店下所有未删除的官方相册
        LambdaQueryWrapper<StoreOfficialAlbum> albumQueryWrapper = new LambdaQueryWrapper<>();
        albumQueryWrapper.eq(StoreOfficialAlbum::getStoreId, storeId)
                .eq(StoreOfficialAlbum::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE)
                .isNotNull(StoreOfficialAlbum::getAlbumName)
                .ne(StoreOfficialAlbum::getAlbumName, "");

        List<StoreOfficialAlbum> albumList = storeOfficialAlbumMapper.selectList(albumQueryWrapper);

        // 如果相册列表为空，直接返回空列表
        if (CollectionUtils.isEmpty(albumList)) {
            log.info("获取官方相册名称列表，门店ID：{}，未查询到相册", storeId);
            return Collections.emptyList();
        }

        // 提取相册ID列表
        List<Integer> albumIds = albumList.stream()
                .map(StoreOfficialAlbum::getId)
                .collect(Collectors.toList());

        // 查询这些相册下的所有图片（imgType = 2 表示官方相册）
        LambdaQueryWrapper<StoreImg> imgQueryWrapper = new LambdaQueryWrapper<>();
        imgQueryWrapper.eq(StoreImg::getStoreId, storeId)
                .eq(StoreImg::getImgType, CommonConstant.STORE_IMG_ALBUM) // imgType = 2 表示官方相册
                .in(StoreImg::getBusinessId, albumIds) // business_id 关联到相册ID
                .eq(StoreImg::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);

        List<StoreImg> imgList = storeImgMapper.selectList(imgQueryWrapper);

        // 构建相册ID到相册名称的映射
        Map<Integer, String> albumIdToNameMap = albumList.stream()
                .collect(Collectors.toMap(
                        StoreOfficialAlbum::getId,
                        StoreOfficialAlbum::getAlbumName,
                        (existing, replacement) -> existing // 如果有重复的ID，保留第一个
                ));

        // 按相册名称分组统计图片数量
        Map<String, Long> albumNameCountMap = imgList.stream()
                .filter(img -> img.getBusinessId() != null && albumIdToNameMap.containsKey(img.getBusinessId()))
                .collect(Collectors.groupingBy(
                        img -> albumIdToNameMap.get(img.getBusinessId()),
                        Collectors.counting()
                ));

        // 转换为返回VO列表
        List<StoreAlbumNameVo> result = albumNameCountMap.entrySet().stream()
                .map(entry -> {
                    StoreAlbumNameVo vo = new StoreAlbumNameVo();
                    vo.setAlbumName(entry.getKey());
                    vo.setImgCount(entry.getValue().intValue());
                    return vo;
                })
                .sorted((a, b) -> {
                    // 按图片数量降序排序，如果数量相同则按名称排序
                    int countCompare = Integer.compare(b.getImgCount(), a.getImgCount());
                    if (countCompare != 0) {
                        return countCompare;
                    }
                    return a.getAlbumName().compareTo(b.getAlbumName());
                })
                .collect(Collectors.toList());

        log.info("获取官方相册名称列表完成，门店ID：{}，返回相册数量：{}", storeId, result.size());

        return result;
    }

    /**
     * 将StoreImg转换为StoreImgInfo
     *
     * @param img 图片实体
     * @return 图片信息VO
     */
    private StoreAlbumDetailVo.StoreImgInfo convertToImgInfo(StoreImg img) {
        StoreAlbumDetailVo.StoreImgInfo info = new StoreAlbumDetailVo.StoreImgInfo();
        info.setId(img.getId());
        info.setImgUrl(img.getImgUrl());
        info.setImgDescription(img.getImgDescription());
        info.setImgSort(img.getImgSort());
        info.setImgType(img.getImgType());
        return info;
    }
}
