package com.qianwen.smartman.modules.system.service.impl;

import java.lang.reflect.Field;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.ImmutableMap;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.coderule.annotation.CodeRule;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.tool.utils.BeanUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.cache.DictCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.ExtCacheConstant;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.smis.vo.ConfigVO;
import com.qianwen.smartman.modules.system.convert.BasCoderuleConvert;
import com.qianwen.smartman.modules.system.dto.BasCoderuleDTO;
import com.qianwen.smartman.modules.system.entity.BasCodeRule;
import com.qianwen.smartman.modules.system.entity.BasCodeRuleEntry;
import com.qianwen.smartman.modules.system.entity.MetaObjectType;
import com.qianwen.smartman.modules.system.entity.MetaObjectTypeField;
import com.qianwen.smartman.modules.system.mapper.BasCoderuleMapper;
import com.qianwen.smartman.modules.system.mapper.CodeHistoryMapper;
import com.qianwen.smartman.modules.system.service.IBasCoderuleEntryService;
import com.qianwen.smartman.modules.system.service.IBasCoderuleService;
import com.qianwen.smartman.modules.system.service.IMetaObjectTypeFieldService;
import com.qianwen.smartman.modules.system.service.IMetaObjectTypeService;

import cn.hutool.core.annotation.AnnotationUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;

@Service
public class BasCoderuleServiceImpl extends BaseServiceImpl<BasCoderuleMapper, BasCodeRule> implements IBasCoderuleService {
    private static final Logger log = LoggerFactory.getLogger(BasCoderuleServiceImpl.class);
    private final IBasCoderuleEntryService basCoderuleEntryService;
    private final IMetaObjectTypeService metaObjectTypeService;
    private final IMetaObjectTypeFieldService metaObjectTypeFieldService;
    private final CodeHistoryMapper codeHistoryMapper;
    //private final ConfigVO configVO;


    //public BasCoderuleServiceImpl(final IBasCoderuleEntryService basCoderuleEntryService, final IMetaObjectTypeService metaObjectTypeService, final IMetaObjectTypeFieldService metaObjectTypeFieldService, final CodeHistoryMapper codeHistoryMapper, final ConfigVO configVO) {
    public BasCoderuleServiceImpl(final IBasCoderuleEntryService basCoderuleEntryService, final IMetaObjectTypeService metaObjectTypeService, final IMetaObjectTypeFieldService metaObjectTypeFieldService, final CodeHistoryMapper codeHistoryMapper) {
        this.basCoderuleEntryService = basCoderuleEntryService;
        this.metaObjectTypeService = metaObjectTypeService;
        this.metaObjectTypeFieldService = metaObjectTypeFieldService;
        this.codeHistoryMapper = codeHistoryMapper;
        //this.configVO = configVO;
    }

    @Override
    public BasCoderuleDTO getCoderuleDetails(Long coderuleId) {
        BasCoderuleDTO result = BasCoderuleConvert.INSTANCE.convertToDTO((BasCodeRule) getById(coderuleId));
        if (Func.isNotEmpty(result)) {
        	result.setEntryList(this.basCoderuleEntryService.list(Wrappers.<BasCodeRuleEntry>lambdaQuery().eq(BasCodeRuleEntry::getRuleId, coderuleId))); 
        	/*
            result.setEntryList(this.basCoderuleEntryService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getRuleId();
            }, coderuleId)));*/
        }
        return result;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public BasCodeRule submitCoderule(BasCoderuleDTO basCoderuleDTO) {
        CacheUtil.clear(ExtCacheConstant.CODE_RULE_CACHE, Boolean.FALSE);
        if (Func.isNotEmpty(basCoderuleDTO)) {
            BasCodeRule basCoderule = (BasCodeRule) BeanUtil.copy(basCoderuleDTO, BasCodeRule.class);
            if (basCoderuleDTO.getSystemDefault().booleanValue() && basCoderule.getId() != null) {
                int existCount = getDefaultCount(basCoderule);
                if (existCount != 0) {
                    throw new ServiceException("已经存在一个默认的规则，请先取消该规则");
                }
            }
            saveOrUpdate(basCoderule);
            List<BasCodeRuleEntry> entryList = basCoderuleDTO.getEntryList();
            this.basCoderuleEntryService.remove(Wrappers.<BasCodeRuleEntry>lambdaQuery().eq(BasCodeRuleEntry::getRuleId, basCoderule.getId()));
            /*
            this.basCoderuleEntryService.remove((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getRuleId();
            }, basCoderule.getId()));*/
            if (Func.isNotEmpty(entryList)) {
                entryList.forEach(x -> {
                    x.setRuleId(basCoderule.getId());
                });
                this.basCoderuleEntryService.saveOrUpdateBatch(entryList);
            }
            return basCoderule;
        }
        return null;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public Boolean deleteCoderule(List<Long> ids) {
        deleteLogic(ids);
        this.basCoderuleEntryService.remove(Wrappers.<BasCodeRuleEntry>lambdaQuery().in(BasCodeRuleEntry::getRuleId, ids));
        /*
        this.basCoderuleEntryService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getRuleId();
        }, ids));*/
        return true;
    }

    @Override
    public boolean isExistCodeRule(String billFormId) {
    	return (count(Lambda.eq(BasCodeRule::getBillFormId, billFormId).eq(BasCodeRule::getSystemDefault,true)) != 0);
    	
    }

    public String getAnnotationFieldValue(Object data, String dbField) {
        String fieldName = StrUtil.toCamelCase(dbField);
        Object fieldValue = ReflectUtil.getFieldValue(data, fieldName);
        if (fieldValue == null) {
            Field[] fields = data.getClass().getDeclaredFields();
            int i = 0;
            while (true) {
                if (i >= fields.length) {
                    break;
                }
                String code = (String) AnnotationUtil.getAnnotationValue(fields[i], CodeRule.class, "code");
                if (!dbField.equals(code)) {
                    i++;
                } else {
                    fields[i].setAccessible(true);
                    try {
						fieldValue = fields[i].get(data);
					} catch (IllegalArgumentException | IllegalAccessException e) {
						log.error("设置字段数据错误",e);
					} 
                }
            }
        }
        if (fieldValue == null) {
            return null;
        }
        return fieldValue.toString();
    }

    @Override
    public BasCodeRule getRuleByObjectType(Object data, String typeId) {
        BasCodeRule basCodeRule;
        /*
        MetaObjectType metaObjectType = (MetaObjectType) this.metaObjectTypeService.getOne(Lambda.eq((v0) -> {
            return v0.getFId();
        }, typeId));*/
        //yys mod 20251104
        MetaObjectType metaObjectType = metaObjectTypeService.lambdaQuery().eq(MetaObjectType::getFId,typeId).one();
        if (metaObjectType.getRuleField() != null) {
            String fieldValue = getAnnotationFieldValue(data, metaObjectType.getRuleField());
            if (Func.isEmpty(fieldValue)) {
                throw new ServiceException(String.format(MessageUtils.message("system.coderule.filed.empty.err", new Object[0]), metaObjectType.getName(), metaObjectType.getRuleField()));
            }
            basCodeRule = getDictRuleByObjectType(typeId, fieldValue);
            if (basCodeRule == null) {
                String dictValue = DictCache.getValue(metaObjectType.getRuleDictCode(), fieldValue);
                if (dictValue == null) {
                    throw new ServiceException(String.format(MessageUtils.message("system.coderule.dict.search.err", new Object[0]), metaObjectType.getRuleDictCode(), fieldValue.toString()));
                }
                throw new ServiceException(String.format(MessageUtils.message("system.coderule.get.rule.err2", new Object[0]), metaObjectType.getName(), dictValue));
            }
        } else {
            basCodeRule = getDefaultRuleByObjectType(typeId);
            if (basCodeRule == null) {
                throw new ServiceException(String.format(MessageUtils.message("system.coderule.get.rule.err1", new Object[0]), metaObjectType.getName()));
            }
        }
        return basCodeRule;
    }

    private BasCodeRule getDefaultRuleByObjectType(String objectTypeId) {
    	BasCodeRule basCodeRule = getOne(
    	        Lambda.eq(BasCodeRule::getBillFormId, objectTypeId)
    	        .eq(BasCodeRule::getSystemDefault, Boolean.TRUE)
    	        .isNull(BasCodeRule::getRuleFieldDictKey), false);
    	/*
        BasCodeRule basCodeRule = (BasCodeRule) getOne((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
            return v0.getBillFormId();
        }, objectTypeId).eq((v0) -> {
            return v0.getSystemDefault();
        }, Boolean.TRUE)).isNull((v0) -> {
            return v0.getRuleFieldDictKey();
        }), false);*/
        return basCodeRule;
    }

    private BasCodeRule getDictRuleByObjectType(String objectTypeId, String dictKey) {
        if (dictKey == null) {
            return getDefaultRuleByObjectType(objectTypeId);
        }
        
        BasCodeRule basCodeRule = (BasCodeRule)getOne(
                Lambda.eq(BasCodeRule::getBillFormId, objectTypeId)
                .eq(BasCodeRule::getSystemDefault, Boolean.valueOf(true))
                .eq(BasCodeRule::getRuleFieldDictKey, dictKey));
        /*
        BasCodeRule basCodeRule = (BasCodeRule) getOne((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
            return v0.getBillFormId();
        }, objectTypeId).eq((v0) -> {
            return v0.getSystemDefault();
        }, true)).eq((v0) -> {
            return v0.getRuleFieldDictKey();
        }, dictKey));*/
        if (basCodeRule == null) {
            return getDefaultRuleByObjectType(objectTypeId);
        }
        return basCodeRule;
    }

    private int getDefaultCount(BasCodeRule basCodeRule) {
    	long existCount = count(
    	        Lambda.eq(BasCodeRule::getBillFormId, basCodeRule.getBillFormId())
    	        .eq(Func.isNotEmpty(basCodeRule.getRuleFieldDictKey()), BasCodeRule::getRuleFieldDictKey, basCodeRule.getRuleFieldDictKey())
    	        .isNull(Func.isNull(basCodeRule.getRuleFieldDictKey()), BasCodeRule::getRuleFieldDictKey)
    	        .ne(BasCodeRule::getId, basCodeRule.getId())
    	        .eq(BasCodeRule::getSystemDefault, true));
    	/*
        long existCount = count((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
            return v0.getBillFormId();
        }, basCodeRule.getBillFormId()).eq(Func.isNotEmpty(basCodeRule.getRuleFieldDictKey()), (v0) -> {
            return v0.getRuleFieldDictKey();
        }, basCodeRule.getRuleFieldDictKey()).isNull(Func.isNull(basCodeRule.getRuleFieldDictKey()), (v0) -> {
            return v0.getRuleFieldDictKey();
        }).ne((v0) -> {
            return v0.getId();
        }, basCodeRule.getId())).eq((v0) -> {
            return v0.getSystemDefault();
        }, true));*/
        return Func.toInt(Long.valueOf(existCount));
    }

    @Override
    public boolean changeDefault(String id) {
        BasCodeRule basCodeRule = (BasCodeRule) getById(id);
        if (basCodeRule != null) {
            int existCount = getDefaultCount(basCodeRule);
            if (existCount != 0) {
                throw new ServiceException("已经存在一个默认的规则，请先取消该规则");
            }
            basCodeRule.setSystemDefault(Boolean.valueOf(!basCodeRule.getSystemDefault().booleanValue()));
            return updateById(basCodeRule);
        }
        return false;
    }

    @Override
    public List<String> patchCodeList(final String billFormId, final Map<String, Object> data) {
        BasCodeRule rule;
        MetaObjectType metaObjectType = (MetaObjectType) this.metaObjectTypeService.getById(billFormId);
        if (metaObjectType == null) {
            throw new ServiceException(MessageUtils.message("system.metaobjet.not.found", new Object[0]) + billFormId);
        }
        if (Func.isNotEmpty(metaObjectType.getRuleField())) {
        	 MetaObjectTypeField field = this.metaObjectTypeFieldService.getOne(Lambda.eq(MetaObjectTypeField::getEnumType, metaObjectType.getRuleDictCode())
        	          .eq(MetaObjectTypeField::getObjectId, billFormId).limit(1));
        	 /*
            MetaObjectTypeField field = (MetaObjectTypeField) this.metaObjectTypeFieldService.getOne(((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
                return v0.getEnumType();
            }, metaObjectType.getRuleDictCode()).eq((v0) -> {
                return v0.getObjectId();
            }, billFormId)).limit(1));*/
            rule = (BasCodeRule) Optional.ofNullable(data.get(field.getField())).map(item -> {
                return (BasCodeRule) Optional.ofNullable(getDictRuleByObjectType(billFormId, item.toString())).orElseThrow(() -> {
                    return new IllegalArgumentException(JSONObject.toJSONString(ImmutableMap.of(CommonConstant.ALARM_MSG, String.format(MessageUtils.message("system.coderule.rule.not.found", new Object[0]), field.getFName(), data.get(field.getField())), "data", field.getField())));
                });
            }).orElseThrow(() -> {
                return new IllegalArgumentException(JSONObject.toJSONString(ImmutableMap.of(CommonConstant.ALARM_MSG, MessageUtils.message("system.coderuel.select.rule", new Object[0]), "data", field.getField())));
            });
        } else {
            rule = getDefaultRuleByObjectType(billFormId);
        }
        Date endTime = new Date();
        DateTime offset = DateUtil.offset(endTime, DateField.HOUR_OF_DAY, -720);
        if (((Boolean) Optional.ofNullable(rule).map((v0) -> {
            return v0.getRepairBillno();
        }).orElseThrow(() -> {
            return new ServiceException(MessageUtils.message("system.coderule.not.found", new Object[0]));
        })).booleanValue()) {
            return Optional.ofNullable(metaObjectType.getCode()).map(item2 -> {
                return this.codeHistoryMapper.getPatchCodeList(billFormId, metaObjectType.getTableName(), item2, offset, endTime);
            }).orElseThrow(() -> {
                return new ServiceException(MessageUtils.message("system.coderule.code.not.set", new Object[0]));
            });
        }
        throw new ServiceException(MessageUtils.message("system.coderule.patch.not.open", new Object[0]));
    }
}