package shop.alien.storeplatform.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import shop.alien.entity.second.vo.StoreImgDTO;
import shop.alien.entity.store.StoreImg;
import shop.alien.entity.store.StoreInfo;
import shop.alien.entity.storePlatform.StoreLicenseHistory;
import shop.alien.entity.storePlatform.vo.StoreLicenseHistoryDto;
import shop.alien.mapper.StoreImgMapper;
import shop.alien.mapper.StoreInfoMapper;
import shop.alien.mapper.storePlantform.StoreLicenseHistoryMapper;
import shop.alien.storeplatform.service.LicenseService;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 证照管理服务实现类
 * <p>
 * 提供商户证照图片和证照历史记录的管理功能，包括：
 * 1. 营业执照、合同、食品经营许可证等图片的查询
 * 2. 证照历史记录的增删改查操作
 * </p>
 *
 * @author system
 * @since 2025-11-24
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class LicenseServiceImpl implements LicenseService {

    /**
     * 商户图片数据访问对象
     */
    private final StoreImgMapper storeImgMapper;

    /**
     * 商户证照历史记录数据访问对象
     */
    private final StoreLicenseHistoryMapper licenseHistoryMapper;

    private final StoreInfoMapper storeInfoMapper;


    @Override
    public int uploadfoodLicence(StoreImg storeImg) {
        storeImgMapper.delete(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 24).eq(StoreImg::getStoreId, storeImg.getStoreId()));
        storeImg.setImgType(24);
        storeImg.setImgDescription("经营许可证审核通过前图片");
        storeImgMapper.insert(storeImg);

        // 经营许可证历史表插入
        StoreLicenseHistory licenseHistory = new StoreLicenseHistory();
        licenseHistory.setStoreId(storeImg.getStoreId());
        licenseHistory.setLicenseStatus(2);
        licenseHistory.setLicenseExecuteStatus(2);
        licenseHistory.setImgUrl(storeImg.getImgUrl());
        licenseHistory.setDeleteFlag(0);
        licenseHistoryMapper.insert(licenseHistory);

        //更新店铺
        StoreInfo storeInfo = new StoreInfo();
        storeInfo.setFoodLicenceStatus(2);
        storeInfo.setId(storeImg.getStoreId());
        storeInfo.setUpdateFoodLicenceTime(new Date());
        return storeInfoMapper.updateById(storeInfo);
    }

    /**
     * 获取营业执照图片列表
     * <p>
     * 查询指定商户的营业执照图片信息（图片类型为14）
     * </p>
     *
     * @param id 商户ID
     * @return 营业执照图片列表
     */
    @Override
    public List<StoreImg> getbusinessLicenseList(Integer id) {
        // 查询图片类型为14（营业执照）的图片列表
        return storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>()
                .eq(StoreImg::getImgType, 14)
                .eq(StoreImg::getStoreId, id));
    }

    /**
     * 获取合同图片列表
     * <p>
     * 查询指定商户的合同图片信息（图片类型为15）
     * </p>
     *
     * @param id 商户ID
     * @return 合同图片列表
     */
    @Override
    public List<StoreImgDTO> getContractList(Integer id) {


        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));


        log.info("getEntertainmentLicenseList - 查询商户ID为 {} 的娱乐经营许可证图片列表", id);
        List<StoreImg> storeImgList = storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>()
                .eq(StoreImg::getImgType, 15)
                .eq(StoreImg::getStoreId, id));

        List<StoreImgDTO> storeImgVoList = new ArrayList<>();
        for (StoreImg storeImg : storeImgList) {
            StoreImgDTO storeImgVo = new StoreImgDTO();
            BeanUtils.copyProperties(storeImg, storeImgVo);
            if (storeInfo != null) {
                storeImgVo.setExpirationTime(storeInfo.getExpirationTime());
            }
            storeImgVoList.add(storeImgVo);
        }

        // 查询图片类型为15（合同）的图片列表
        return storeImgVoList;
    }

    /**
     * 获取食品经营许可证图片列表
     * <p>
     * 查询指定商户的食品经营许可证图片信息（图片类型为25）
     * </p>
     *
     * @param id 商户ID
     * @return 食品经营许可证图片列表
     */
    @Override
    public List<StoreImgDTO> getFoodLicenceList(Integer id) {
        log.info("getEntertainmentLicenseList - 查询商户ID为 {} 的娱乐经营许可证图片列表", id);

        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));

        // 查询图片类型为25（食品经营许可证）的图片列表
        List<StoreImg> storeImgList = storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>()
                .eq(StoreImg::getImgType, 25)
                .eq(StoreImg::getStoreId, id));

        List<StoreImgDTO> storeImgVoList = new ArrayList<>();
        for (StoreImg storeImg : storeImgList) {
            StoreImgDTO storeImgVo = new StoreImgDTO();
            BeanUtils.copyProperties(storeImg, storeImgVo);
            if (storeInfo != null) {
                storeImgVo.setExpirationTime(storeInfo.getFoodLicenceExpirationTime());
            }
            storeImgVoList.add(storeImgVo);
        }

        // 查询图片类型为15（合同）的图片列表
        return storeImgVoList;
    }

    /**
     * 根据商户ID查询证照历史记录列表（带格式化日期）
     * <p>
     * 查询指定商户的证照历史记录，将创建时间格式化为 yyyy-MM-dd 格式，
     * 并转换为 VO 对象返回
     * </p>
     *
     * @param storeId 商户ID
     * @return 证照历史记录VO列表
     */
    @Override
    public List<StoreLicenseHistoryDto> queryLicenceByStatusList(Integer storeId) {

        List<StoreLicenseHistory> licenseList = licenseHistoryMapper.queryLicenceByStatusList(storeId, 2, 1);

        // 创建日期格式化对象，格式为 yyyy-MM-dd
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        // 创建返回的 VO 列表
        List<StoreLicenseHistoryDto> voList = new java.util.ArrayList<>();

        for (StoreLicenseHistory license : licenseList) {
            // 创建 VO 对象
            StoreLicenseHistoryDto vo = new StoreLicenseHistoryDto();

            // 将实体对象属性复制到 VO 对象
            BeanUtils.copyProperties(license, vo);

            // 将创建时间格式化为 yyyy-MM-dd 格式，去除时分秒
            if (license.getCreatedTime() != null) {
                String dateStr = sdf.format(license.getCreatedTime());
                vo.setCreatedDateFormat(dateStr);
            }

            // 设置审核状态名称
            if (license.getLicenseExecuteStatus() != null) {
                switch (license.getLicenseExecuteStatus()) {
                    case 1:
                        vo.setLicenseExecuteName("审核通过");
                        break;
                    case 2:
                        vo.setLicenseExecuteName("审核中");
                        break;
                    case 3:
                        vo.setLicenseExecuteName("审核失败");
                        break;
                    default:
                        vo.setLicenseExecuteName("未知");
                        break;
                }
            }

            voList.add(vo);
        }

        return voList;
    }


    @Override
    public int uploadRenewalContract(List<StoreImg> storeImgList) {
        //取出集合中门店id
        Optional<Integer> storeId = storeImgList.stream().map(StoreImg::getStoreId).findFirst();
        int value = storeId.orElse(0);
        int num = 0;

        Date date = new Date();
        //先清除数据
        storeImgMapper.delete(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 22).eq(StoreImg::getStoreId, value));
        for (StoreImg renewContract : storeImgList) {
            StoreImg storeImg = new StoreImg();
            storeImg.setStoreId(renewContract.getStoreId());
            storeImg.setImgType(22);
            storeImg.setImgSort(renewContract.getImgSort());
            storeImg.setImgDescription("续签合同图片");
            storeImg.setImgUrl(renewContract.getImgUrl());
            storeImg.setCreatedUserId(renewContract.getCreatedUserId());
            num = storeImgMapper.insert(storeImg);


            // 经营许可证历史表插入
            StoreLicenseHistory licenseHistory = new StoreLicenseHistory();
            licenseHistory.setStoreId(storeImg.getStoreId());
            licenseHistory.setLicenseStatus(1);
            licenseHistory.setLicenseExecuteStatus(2);
            licenseHistory.setImgUrl(storeImg.getImgUrl());
            licenseHistory.setDeleteFlag(0);
            licenseHistory.setCreatedTime(date);
            licenseHistoryMapper.insert(licenseHistory);
        }
        if (num > 0) {
            StoreInfo storeInfo = new StoreInfo();
            storeInfo.setRenewContractStatus(2);
            storeInfo.setUpdateRenewContractTime(new Date());
            storeInfo.setId(value);
            storeInfoMapper.updateById(storeInfo);
        }
        return num;
    }


    @Override
    public Map<String, Object> getStoreFoodLicenceStatus(int id) {
        Map<String, Object> map = new HashMap<>();
        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));
        //审核通过给前台反显未提交
        if (storeInfo.getFoodLicenceStatus() == 1) {
            map.put("foodLicenceStatus", 0);
        } else {
            map.put("foodLicenceStatus", storeInfo.getFoodLicenceStatus());
        }
        //食品经营许可证照片列表
        List<StoreImg> storeImgList = storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 24).eq(StoreImg::getStoreId, id));
        if (!CollectionUtils.isEmpty(storeImgList)) {
            map.put("foodLicenceImgList", storeImgList);
        } else {
            map.put("foodLicenceImgList", "");
        }
        if (storeInfo.getFoodLicenceReason() != null) {
            map.put("foodLicenceReason", storeInfo.getFoodLicenceReason());
        } else {
            map.put("foodLicenceReason", "");
        }
        return map;
    }


    @Override
    public Map<String, Object> getStoreContractStatus(int id) {
        Map<String, Object> map = new HashMap<>();
        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));
        //审核通过给前台反显未提交
        if (storeInfo.getRenewContractStatus() == 1) {
            map.put("renewContractStatus", 0);
        } else {
            map.put("renewContractStatus", storeInfo.getRenewContractStatus());
        }
        //续签合同照片列表
        List<StoreImg> storeImgList = storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 22).eq(StoreImg::getStoreId, id));
        if (!CollectionUtils.isEmpty(storeImgList)) {
            map.put("contractImgList", storeImgList);
        } else {
            map.put("contractImgList", "");
        }
        if (storeInfo.getContractReason() != null) {
            map.put("contractReason", storeInfo.getContractReason());
        } else {
            map.put("contractReason", "");
        }
        return map;
    }


    /**
     * 根据商户ID查询合同历史记录列表（按时间分组）
     * <p>
     * 查询指定商户的合同历史记录，将创建时间格式化为 yyyy-MM-dd HH:mm:ss 格式，
     * 并按照时间进行分组，相同时间的数据存储到 licenseList 中
     * 返回按时间去重后的列表，每个元素包含该时间下的所有记录
     * 排序规则：时间倒序（最新的在前），同一时间内ID升序
     * </p>
     *
     * @param storeId 商户ID
     * @return 按时间分组的证照历史记录列表
     */
    @Override
    public List<StoreLicenseHistoryDto> queryContractByStatusList(Integer storeId) {

        // 查询证照类型为1（合同管理）的记录
        List<StoreLicenseHistory> licenseList = licenseHistoryMapper.queryLicenceByStatusList(storeId, 1, 1);

        // 第一步：对原始数据进行排序
        // 时间倒序（最新的在前），同一时间内ID升序
        licenseList.sort((o1, o2) -> {
            // 先按时间倒序排序（最新的在前）
            if (o1.getCreatedTime() != null && o2.getCreatedTime() != null) {
                int timeCompare = o2.getCreatedTime().compareTo(o1.getCreatedTime());
                if (timeCompare != 0) {
                    return timeCompare;
                }
            }
            // 时间相同时，按ID升序排序
            if (o1.getId() != null && o2.getId() != null) {
                return o1.getId().compareTo(o2.getId());
            }
            return 0;
        });

        // 创建日期格式化对象，格式为 yyyy-MM-dd HH:mm:ss
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        // 使用 LinkedHashMap 按时间分组，保持插入顺序
        Map<String, List<StoreLicenseHistoryDto>> timeGroupMap = new LinkedHashMap<>();

        // 第二步：按时间分组，将所有数据按时间归类
        for (StoreLicenseHistory license : licenseList) {
            // 创建 VO 对象
            StoreLicenseHistoryDto vo = new StoreLicenseHistoryDto();

            // 将实体对象属性复制到 VO 对象
            BeanUtils.copyProperties(license, vo);

            // 格式化创建时间
            String dateKey = "";
            if (license.getCreatedTime() != null) {
                String dateStr = sdf.format(license.getCreatedTime());
                vo.setCreatedDateFormat(dateStr);
                // 使用日期时间作为分组 key
                dateKey = dateStr;
            }

            // 设置审核状态名称
            if (license.getLicenseExecuteStatus() != null) {
                switch (license.getLicenseExecuteStatus()) {
                    case 1:
                        vo.setLicenseExecuteName("审核通过");
                        break;
                    case 2:
                        vo.setLicenseExecuteName("审核中");
                        break;
                    case 3:
                        vo.setLicenseExecuteName("审核失败");
                        break;
                    default:
                        vo.setLicenseExecuteName("未知");
                        break;
                }
            }

            // 将 VO 对象添加到对应时间的列表中
            if (!dateKey.isEmpty()) {
                timeGroupMap.computeIfAbsent(dateKey, k -> new ArrayList<>()).add(vo);
            }
        }

        // 第三步：将分组后的数据转换为列表结构
        // 每个时间节点创建一个父对象，将该时间的所有记录存储到 licenseList 中
        List<StoreLicenseHistoryDto> resultList = new ArrayList<>();

        for (Map.Entry<String, List<StoreLicenseHistoryDto>> entry : timeGroupMap.entrySet()) {
            String timeKey = entry.getKey();
            List<StoreLicenseHistoryDto> sameTimeList = entry.getValue();

            // 创建一个父对象，代表这个时间节点
            StoreLicenseHistoryDto parentVo = new StoreLicenseHistoryDto();

            // 使用第一条记录的基本信息作为父对象的信息（ID最小的那条）
            if (!sameTimeList.isEmpty()) {
                StoreLicenseHistoryDto firstItem = sameTimeList.get(0);
                BeanUtils.copyProperties(firstItem, parentVo);

                // 将相同时间的所有记录存储到 licenseList 中（已按ID升序排列）
                parentVo.setLicenseList(sameTimeList);
                parentVo.setCreatedDateFormat(timeKey);

                resultList.add(parentVo);
            }
        }

        log.info("queryContractByStatusList - 共查询到 {} 条记录，按时间分组后 {} 个时间节点",
                licenseList.size(), resultList.size());

        return resultList;
    }

    /**
     * 获取营业执照图片列表
     * <p>
     * 查询指定商户的营业执照图片信息（图片类型为14）
     * </p>
     *
     * @param id 商户ID
     * @return 营业执照图片列表
     */
    @Override
    public List<StoreImgDTO> getEntertainmentLicenseList(Integer id) {

        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));

        log.info("getEntertainmentLicenseList - 查询商户ID为 {} 的娱乐经营许可证图片列表", id);
        List<StoreImg> storeImgList = storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>()
                .eq(StoreImg::getImgType, 31)
                .eq(StoreImg::getStoreId, id));

        List<StoreImgDTO> storeImgVoList = new ArrayList<>();
        for (StoreImg storeImg : storeImgList) {
            StoreImgDTO storeImgVo = new StoreImgDTO();
            BeanUtils.copyProperties(storeImg, storeImgVo);
            if (storeInfo != null) {
                storeImgVo.setExpirationTime(storeInfo.getEntertainmentLicenceExpirationTime());
            }
            storeImgVoList.add(storeImgVo);
        }
        return storeImgVoList;
    }

    @Override
    public int uploadEntertainmentLicence(StoreImg storeImg) {
        storeImgMapper.delete(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 32).eq(StoreImg::getStoreId, storeImg.getStoreId()));
        storeImg.setImgType(32);
        storeImg.setImgDescription("经营许可证审核通过前图片");
        storeImgMapper.insert(storeImg);


        // 经营许可证历史表插入
        StoreLicenseHistory licenseHistory = new StoreLicenseHistory();
        licenseHistory.setStoreId(storeImg.getStoreId());
        licenseHistory.setLicenseStatus(3);
        licenseHistory.setLicenseExecuteStatus(1);
        licenseHistory.setImgUrl(storeImg.getImgUrl());
        licenseHistory.setDeleteFlag(0);
        licenseHistoryMapper.insert(licenseHistory);

        //更新店铺
        StoreInfo storeInfo = new StoreInfo();
        storeInfo.setEntertainmentLicenceStatus(1);
        storeInfo.setId(storeImg.getStoreId());
        storeInfo.setUpdateEntertainmentLicenceTime(new Date());
        return storeInfoMapper.updateById(storeInfo);
    }

    /**
     * 根据商户ID查询证照历史记录列表（带格式化日期）
     * <p>
     * 查询指定商户的证照历史记录，将创建时间格式化为 yyyy-MM-dd 格式，
     * 并转换为 VO 对象返回
     * </p>
     *
     * @param storeId 商户ID
     * @return 证照历史记录VO列表
     */
    @Override
    public List<StoreLicenseHistoryDto> queryEntertainmentByStatusList(Integer storeId) {

        List<StoreLicenseHistory> licenseList = licenseHistoryMapper.queryLicenceByStatusList(storeId, 3, 1);

        // 创建日期格式化对象，格式为 yyyy-MM-dd
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        // 创建返回的 VO 列表
        List<StoreLicenseHistoryDto> voList = new java.util.ArrayList<>();

        for (StoreLicenseHistory license : licenseList) {
            // 创建 VO 对象
            StoreLicenseHistoryDto vo = new StoreLicenseHistoryDto();

            // 将实体对象属性复制到 VO 对象
            BeanUtils.copyProperties(license, vo);

            // 将创建时间格式化为 yyyy-MM-dd 格式，去除时分秒
            if (license.getCreatedTime() != null) {
                String dateStr = sdf.format(license.getCreatedTime());
                vo.setCreatedDateFormat(dateStr);
            }

            // 设置审核状态名称
            if (license.getLicenseExecuteStatus() != null) {
                switch (license.getLicenseExecuteStatus()) {
                    case 1:
                        vo.setLicenseExecuteName("审核通过");
                        break;
                    case 2:
                        vo.setLicenseExecuteName("审核中");
                        break;
                    case 3:
                        vo.setLicenseExecuteName("审核失败");
                        break;
                    default:
                        vo.setLicenseExecuteName("未知");
                        break;
                }
            }

            voList.add(vo);
        }

        return voList;
    }


    @Override
    public Map<String, Object> getStoreEntertainmentStatus(int id) {
        Map<String, Object> map = new HashMap<>();
        StoreInfo storeInfo = storeInfoMapper.selectOne(new LambdaQueryWrapper<StoreInfo>().eq(StoreInfo::getId, id));
        //审核通过给前台反显未提交
        if (storeInfo.getEntertainmentLicenceStatus() != null && storeInfo.getEntertainmentLicenceStatus() == 1) {
            map.put("entertainmentStatus", 0);
        } else {
            map.put("entertainmentStatus", storeInfo.getEntertainmentLicenceStatus());
        }
        return map;
    }
}

