package com.vincent.rsf.server.system.utils;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vincent.rsf.framework.common.SpringUtils;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.common.utils.DateUtils;
import com.vincent.rsf.server.system.entity.SerialRule;
import com.vincent.rsf.server.system.entity.SerialRuleItem;
import com.vincent.rsf.server.system.enums.SerialRuleReset;
import com.vincent.rsf.server.system.enums.SerialRuleType;
import com.vincent.rsf.server.system.service.SerialRuleItemService;
import com.vincent.rsf.server.system.service.SerialRuleService;
import org.apache.tika.utils.StringUtils;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * @author Ryan
 * @version 1.0
 * @title 生成规则编码功能
 * @description
 * @create 2025/3/5 08:01
 */
public class SerialRuleUtils {

    /**
     * @author Ryan
     * @description 根据编码规则生成编码号
     * @throws
     * @return 编码号
     * @time 2025/3/5 08:52
     */
    public static String generateRuleCode(String code, Object obj) {
        SerialRuleService ruleService = SpringUtils.getBean(SerialRuleService.class);
        //获取规则编码主单
        SerialRule serialRule = ruleService
                .getOne(new LambdaQueryWrapper<SerialRule>()
                        .eq(SerialRule::getCode, code));
        if (Objects.isNull(serialRule)) {

            throw new CoolException("当前业务：" + code + "，编码规则不存在！！");
        }
        SerialRuleItemService serialRuleItemService = SpringUtils.getBean(SerialRuleItemService.class);

        //获取规则编码明细
        List<SerialRuleItem> ruleItems = serialRuleItemService
                .list(new LambdaQueryWrapper<SerialRuleItem>()
                        .eq(SerialRuleItem::getRuleId, serialRule.getId())
                        .orderByAsc(SerialRuleItem::getSort));
        if (Objects.isNull(ruleItems) || ruleItems.isEmpty()) {
            throw new CoolException("编码规则明细为空！！");
        }

        StringBuffer buffer = new StringBuffer();
        ruleItems.forEach(rule -> {
            if (rule.getWkType().equals(SerialRuleType.WK_CONSTANT.wkType)) {
                buffer.append(rule.getFeildValue());
            } else if (rule.getWkType().equals(SerialRuleType.WK_SERIAL_NO.wkType)) {
                String result = "", format = "";
                if (serialRule.getReset().equals(SerialRuleReset.SERIAL_REST_TYPE_YEAR.type)) {
                     format = DateUtils.format(new Date(), "yyyy");
                } else if (serialRule.getReset().equals(SerialRuleReset.SERIAL_REST_TYPE_MONTH.type)) {
                     format = DateUtils.format(new Date(), "MM");
                } else if (serialRule.getReset().equals(SerialRuleReset.SERIAL_REST_TYPE_DAYS.type)){
                     format = DateUtils.format(new Date(), "dd");
                }
                //当前值自动加1
                Integer curVal = serialRule.getCurrValue() + 1;
                //字符串左边自加补0
                String lef =  StringUtils.leftPad(curVal + "", serialRule.getMaxLen(), "0");
                //最近一次流水号
                result = format + lef;
                //修改最后编码，当前值
                serialRule.setCurrValue(curVal);

                buffer.append(result);
            } else if (rule.getWkType().equals(SerialRuleType.WK_DATE_FORMAT.wkType)) {
                //获取时间14位格式时间值yyyyMMddHHmmss
                String format = DateUtils.format(new Date(), DateUtils.YYYYMMDDHHMMSS_PATTER);
                //判断是否设置截取长度和起始截取位置
                buffer.append(subStr(format, rule.getLenStr(), rule.getLen()));
            } else if (rule.getWkType().equals(SerialRuleType.WK_FEILD.wkType)) {
                String subStr;
                if (!Objects.isNull(objectToMap(obj).get(rule.getFeildValue()))) {
                    subStr = subStr(objectToMap(obj).get(rule.getFeildValue()).toString(), rule.getLenStr(), rule.getLen());
                    buffer.append(subStr);
                }
            }
        });

        serialRule.setLastCode(buffer.toString());
        //修改当前规则编码号至数据库
        if (!ruleService.saveOrUpdate(serialRule)) {
            throw new CoolException("规则编码保存失败！！");
        }
        return buffer.toString();
    }

    /**
     * @author Ryan
     * @description 根据字段长度及，起始位置截取字符串
     * @throws
     * @return
     * @time 2025/3/5 13:00
     */
    public static String subStr(String str, Integer start, Integer end) {
        StringBuffer buffer = new StringBuffer();
        //判断是否设置截取长度和起始截取位置
        if (Objects.isNull(start) || end == 0) {
            buffer.append(str);
        } else {
            if (str.length() < (end + start)) {
                throw new CoolException("截取字符起出字符串长度，请查看规则设定！！");
            }
            //返回起始位置lenStr开始，终点位置为lenStr + len长度的字符串
            String substring  = str.substring(start, (start + end));
            buffer.append(substring);
        }
        return buffer.toString();
    }


    /**
     * @author Ryan
     * @description Object 转 Map字段
     * @throws
     * @return
     * @time 2025/3/5 14:00
     */
    public static Map<?, ?> objectToMap (Object obj) {
        if (Objects.isNull(obj)) {
            return null;
        }
        ObjectMapper objectMapper = new ObjectMapper();
        Map<?, ?> mappedObject = objectMapper.convertValue(obj, Map.class);

        return mappedObject;
    }

}