package cn.huge.module.sy.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.sy.dao.mapper.SyHolidayMapper;
import cn.huge.module.sy.domain.po.SyHoliday;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;

/**
 * @title: 节假日日期配置表业务逻辑处理
 * @Description 节假日日期配置表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2025-01-20 10:56:54
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class SyHolidayService extends ServiceImpl<SyHolidayMapper, SyHoliday>{

    @Autowired
    private SyHolidayMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateSyHoliday(SyHoliday entity){
        try{
            mapper.updateSyHoliday(entity);
        }catch (Exception e){
            log.error("[SyHolidayService.updateSyHoliday]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.updateSyHoliday", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateSyHolidayTerms(SyHoliday entity, Map<String, Object> terms){
        try{
            mapper.updateSyHolidayTerms(entity, terms);
        }catch (Exception e){
            log.error("[SyHolidayService.updateSyHolidayTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.updateSyHolidayTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteSyHoliday(String id){
        try{
            mapper.deleteSyHoliday(id);
        }catch (Exception e){
            log.error("[SyHolidayService.deleteSyHoliday]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.deleteSyHoliday", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<SyHoliday> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<SyHoliday> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<SyHoliday> content = mapper.pageTerms(page, terms);
        return new PageImpl<SyHoliday>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param syHoliday 实体对象
    */
    public void saveSyHoliday(SyHoliday syHoliday){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(syHoliday.getId())){
                syHoliday.setId(utilsClient.getNewTimeId());
                syHoliday.setCreateTime(nowDate);
            }
            syHoliday.setUpdateTime(nowDate);
            this.saveOrUpdate(syHoliday);
        }catch (Exception e){
            log.error("[SyHolidayService.saveSyHoliday]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.saveSyHoliday", e);
        }
    }

    /**
     * 根据开始日期和需要添加的天数计算到期日期
     * 此方法考虑了节假日因素，如果到期日遇到节假日，则向后顺延
     *
     * @param startDate 开始日期
     * @param daysToAdd 需要添加的天数
     * @return 到期日期
     */
    public Date getExpiryDay(Date startDate, int daysToAdd){
        try{
            // 查询指定年份的节假日信息
            QueryWrapper<SyHoliday> syHolidayQueryWrapper = new QueryWrapper<>();
            syHolidayQueryWrapper.eq("year_time", DateUtils.getYear(startDate));
            SyHoliday syHoliday = this.getOne(syHolidayQueryWrapper);

            // 如果没有找到节假日信息，则直接添加天数返回
            if (syHoliday == null){
                return DateUtils.addDay(startDate, daysToAdd);
            }else{
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                SimpleDateFormat sdf1 = new SimpleDateFormat("HH:mm:ss");
                SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                // 存储节假日日期的集合
                Set<Date> holidaySet = new HashSet<>();
                // 将节假日日期字符串分割为数组并添加到集合中
                String[] holidayDates = syHoliday.getHolidayDate().split(",");
                for (String holidayDate : holidayDates) {
                    holidaySet.add(sdf.parse(holidayDate));
                }

                // 初始化当前日期为开始日期
                String currentDateStr = sdf.format(startDate);
                Date currentDate = sdf.parse(currentDateStr);
                int daysCounted = 0;
                // 循环直到添加足够的非节假日天数
                while (daysCounted < daysToAdd || holidaySet.contains(currentDate)) {
                    // 如果当前日期不是节假日，则计数加一
                    if (!holidaySet.contains(currentDate)) {
                        daysCounted++;
                    }
                    currentDate = DateUtils.addDay(currentDate, 1);
                }
                // 返回计算后的到期日期
                String endDateStr = sdf.format(currentDate) + " " + sdf1.format(startDate);
                Date endDate = sdf2.parse(endDateStr);
                return endDate;
            }
        }catch (Exception e){
            log.error("[SyHolidayService.getExpiryDay]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.getExpiryDay", e);
        }
    }



    /**
     * 根据开始日期和需要添加的天数计算到期日期
     * 此方法考虑了节假日因素，如果到期日遇到节假日，则向后顺延
     *
     * @param startDate 开始日期
     * @param hourToAdd 需要添加的小时
     * @return 到期日期
     */
    public Date getExpiryHour(Date startDate, int hourToAdd){
        try{
            // 查询指定年份的节假日信息
            QueryWrapper<SyHoliday> syHolidayQueryWrapper = new QueryWrapper<>();
            syHolidayQueryWrapper.eq("year_time", DateUtils.getYear(startDate));
            SyHoliday syHoliday = this.getOne(syHolidayQueryWrapper);

            if (syHoliday == null){
                return DateUtils.addHour(startDate, hourToAdd);
            }else{
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                // 存储节假日日期的集合
                Set<Date> holidaySet = new HashSet<>();
                // 将节假日日期字符串分割为数组并添加到集合中
                String[] holidayDates = syHoliday.getHolidayDate().split(",");
                for (String holidayDate : holidayDates) {
                    holidaySet.add(sdf.parse(holidayDate+" "+"00:00:00"));
                }

                // 初始化当前日期为开始日期
                Date currentDate = startDate;
                int hoursCounted = 0;
                // 循环直到添加足够的非节假日天数
                while (hoursCounted < hourToAdd || holidaySet.contains(currentDate)) {
                    // 如果当前日期不是节假日，则计数加一
                    if (!holidaySet.contains(currentDate)) {
                        hoursCounted++;
                    }
                    currentDate = DateUtils.addHour(currentDate, 1);
                }
                // 返回计算后的到期日期
                String endDateStr = sdf.format(currentDate);
                Date endDate = currentDate;
                return endDate;
            }

        }catch (Exception e){
            log.error("[SyHolidayService.getExpiryHour]调用失败，异常信息："+e, e);
            throw new ServiceException("SyHolidayService.getExpiryHour", e);
        }
    }

}