package com.qianwen.core.coderule.builder;

import cn.hutool.core.convert.Convert;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.coderule.constant.CodeRuleConstant;
import com.qianwen.core.coderule.constant.enums.ElementTypeEnum;
import com.qianwen.core.coderule.constant.enums.SourcePropertyEnum;
import com.qianwen.core.coderule.dto.DropDownDTO;
import com.qianwen.core.coderule.dto.RefObjectTypeInfoDTO;
import com.qianwen.core.coderule.handler.DictHandler;
import com.qianwen.core.coderule.handler.MasterlinkCodeRuleModelHandler;
import com.qianwen.core.coderule.handler.MasterlinkDictHandler;
import com.qianwen.core.coderule.handler.MasterlinkMetaObjectTypeFieldEnumHandler;
import com.qianwen.core.coderule.handler.MasterlinkObjectTypeHandler;
import com.qianwen.core.coderule.handler.ObjectTypeHandler;
import com.qianwen.core.coderule.model.CodeRuleContext;
import com.qianwen.core.coderule.model.CodeRuleEntryModel;
import com.qianwen.core.coderule.model.CodeRuleModel;
import com.qianwen.core.coderule.util.CodeRuleHelper;
import com.qianwen.core.sequence.builder.SequenceBuilderFactory;
import com.qianwen.core.sequence.sequence.Sequence;
import com.qianwen.core.tool.utils.ConvertUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;
import org.springframework.jdbc.core.JdbcTemplate;


public class DefaultConcreateContextBuilder implements CodeRuleContextBuilder {
    private static final Logger log = LoggerFactory.getLogger(DefaultConcreateContextBuilder.class);
    private static String[] parsePatterns = {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm"};
    private JdbcTemplate jdbcTemplate;
    private CodeRuleContext context = new CodeRuleContext();

    public DefaultConcreateContextBuilder(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder codeRuleModel(Long codeRuleId) {
        MasterlinkCodeRuleModelHandler codeRuleModelHandler = new MasterlinkCodeRuleModelHandler(this.jdbcTemplate);
        this.context.setCodeRuleModel(codeRuleModelHandler.getCodeRuleById(codeRuleId));
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder objectData(Object object) {
        this.context.setObjectData(CodeRuleHelper.getDeclaredFieldsInfoByAnnotation(object));
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder constant() {
        List<CodeRuleEntryModel> constants = execute(ElementTypeEnum.CONSTANT.getType());
        if (Func.isNotEmpty(constants)) {
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel constant : constants) {
                map.put(constant.getSeq(), handleValueByOtherSetting(constant, constant.getElementValue()));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder date() {
        List<CodeRuleEntryModel> dates = execute(ElementTypeEnum.DATE.getType());
        if (Func.isNotEmpty(dates)) {
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel date : dates) {
                String format = Func.isNotEmpty(date.getFormat()) ? date.getFormat() : "yyyyMMdd";
                Object value = this.context.getObjectData().get(date.getElementSource());
                String result = "";
                if (value == null) {
                    value = Long.valueOf(new Date().getTime());
                }
                if (Func.isNotEmpty(value)) {
                    if (value instanceof Long) {
                        result = DateUtil.format((Date) ConvertUtil.convert(value, Date.class), format);
                    } else {
                        try {
                            result = DateUtil.format(DateUtils.parseDate(value.toString(), parsePatterns), format);
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                    }
                }
                map.put(date.getSeq(), handleValueByOtherSetting(date, result));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder number() {
        List<CodeRuleEntryModel> numbers = execute(ElementTypeEnum.NUMBER.getType());
        if (Func.isNotEmpty(numbers)) {
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel number : numbers) {
                Object value = this.context.getObjectData().get(number.getElementSource());
                String result = "";
                if (Func.isNotEmpty(value)) {
                    result = CodeRuleHelper.getRealData((BigDecimal) ConvertUtil.convert(value, BigDecimal.class));
                }
                map.put(number.getSeq(), handleValueByOtherSetting(number, result));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder dropdown(String objectId) {
        List<CodeRuleEntryModel> dropdowns = execute(ElementTypeEnum.DROPDOWN.getType());
        if (Func.isNotEmpty(dropdowns)) {
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel dropdown : dropdowns) {
                Object value = this.context.getObjectData().get(dropdown.getElementSource());
                String result = value.toString();
                if (Func.isNotEmpty(value)) {
                    Boolean isCode = true;
                    if (Func.isNotEmpty(dropdown.getSourceProperty())) {
                        isCode = Boolean.valueOf(dropdown.getSourceProperty().equals(SourcePropertyEnum.CODE.getType()));
                    }
                    if (!isCode.booleanValue()) {
                        DictHandler dictHandler = new MasterlinkDictHandler(this.jdbcTemplate);
                        MasterlinkMetaObjectTypeFieldEnumHandler metaObjectTypeFieldEnumHandler = new MasterlinkMetaObjectTypeFieldEnumHandler(this.jdbcTemplate);
                        String dictCodeForField = metaObjectTypeFieldEnumHandler.getDictCodeForField(objectId, dropdown.getElementSource());
                        if (Func.isNotEmpty(dictCodeForField)) {
                            DropDownDTO dropDownDTO = dictHandler.getDictInfo(dictCodeForField, value.toString());
                            if (Func.isNotEmpty(dropDownDTO)) {
                                result = dropDownDTO.getDictValue();
                            }
                        }
                    }
                }
                map.put(dropdown.getSeq(), handleValueByOtherSetting(dropdown, result));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder baseData(String objectId) {
        List<CodeRuleEntryModel> baseDatas = execute(ElementTypeEnum.BASE_DATA.getType());
        if (Func.isNotEmpty(baseDatas)) {
            ObjectTypeHandler objectTypeHandler = new MasterlinkObjectTypeHandler(this.jdbcTemplate);
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel baseData : baseDatas) {
                Object value = this.context.getObjectData().get(baseData.getElementSource());
                String result = "";
                if (Func.isNotEmpty(value)) {
                    RefObjectTypeInfoDTO refObjectTypeInfo = objectTypeHandler.getRefObjectTypeInfo(objectId, baseData.getElementSource(), value.toString());
                    Boolean isCode = Boolean.valueOf(baseData.getSourceProperty().equals(SourcePropertyEnum.CODE.getType()));
                    if (Func.isNotEmpty(refObjectTypeInfo)) {
                        result = isCode.booleanValue() ? refObjectTypeInfo.getCode() : refObjectTypeInfo.getName();
                    }
                }
                map.put(baseData.getSeq(), handleValueByOtherSetting(baseData, result));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder baseDataProperty() {
        List<CodeRuleEntryModel> baseDataProperties = execute(ElementTypeEnum.BASE_DATA_PROPERTY.getType());
        if (Func.isNotEmpty(baseDataProperties)) {
            Map<Integer, String> map = new HashMap<>();
            for (CodeRuleEntryModel baseDataProperty : baseDataProperties) {
                Object value = this.context.getObjectData().getOrDefault(baseDataProperty.getElementSource(), "");
                map.put(baseDataProperty.getSeq(), handleValueByOtherSetting(baseDataProperty, checkCops(value.toString(), baseDataProperty.getFormat())));
            }
            this.context.getEntryData().putAll(map);
        }
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContextBuilder sequence(String objectId) {
        List<CodeRuleEntryModel> sequences = execute(ElementTypeEnum.SEQUENCE.getType());
        if (Func.isEmpty(sequences)) {
            return this;
        }
        CodeRuleEntryModel sequenceEntry = sequences.iterator().next();
        String bizName = objectId.concat(getCodeDependOn());
        Integer start = sequenceEntry.getSeed();
        Integer step = sequenceEntry.getIncrementStep();
        if (Func.isNotEmpty(start)) {
            start = Integer.valueOf(start.intValue() - 1);
        }
        Sequence sequence = SequenceBuilderFactory.getSeqBuilder(bizName, step, start);
        Map<Integer, String> map = new HashMap<>();
        map.put(sequenceEntry.getSeq(), handleValueByOtherSetting(sequenceEntry, Convert.toStr(Long.valueOf(sequence.nextValue()))));
        this.context.getEntryData().putAll(map);
        return this;
    }

    @Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
    public CodeRuleContext createCodeRuleContext() {
        return this.context;
    }

    private List<CodeRuleEntryModel> execute(Integer elementType) {
        List<CodeRuleEntryModel> result = null;
        CodeRuleModel codeRuleModel = this.context.getCodeRuleModel();
        if (Func.isNotEmpty(codeRuleModel) && Func.isNotEmpty(codeRuleModel.getCodeRuleEntryModelList())) {
            result = (List) codeRuleModel.getCodeRuleEntryModelList().stream().filter(x -> {
                return x.getElementType().equals(elementType);
            }).collect(Collectors.toList());
        }
        return result;
    }

    private String getCodeDependOn() {
        StringBuilder codeDependOn = new StringBuilder();
        CodeRuleModel codeRuleModel = this.context.getCodeRuleModel();
        codeDependOn.append(codeRuleModel.getId());
        if (Func.isNotEmpty(codeRuleModel) && Func.isNotEmpty(codeRuleModel.getCodeRuleEntryModelList())) {
            List<CodeRuleEntryModel> collect = (List) codeRuleModel.getCodeRuleEntryModelList().stream().filter(x -> {
                return x.getCodeOnlyBy().equals(true);
            }).filter(x2 -> {
                return !x2.getElementType().equals(ElementTypeEnum.SEQUENCE.getType());
            }).sorted(Comparator.comparing((v0) -> {
                return v0.getSeq();
            })).collect(Collectors.toList());
            if (Func.isNotEmpty(collect)) {
                for (CodeRuleEntryModel codeRuleEntryModel : collect) {
                    String s = this.context.getEntryData().get(codeRuleEntryModel.getSeq());
                    if (Func.isNotEmpty(s)) {
                        codeDependOn.append(s);
                    }
                }
            }
        }
        return codeDependOn.toString();
    }

    private String handleValueByOtherSetting(CodeRuleEntryModel codeRuleEntryModel, String value) {
        String result = value;
        if (Func.isEmpty(value)) {
            String reChar = codeRuleEntryModel.getReChar();
            if (Func.isNotEmpty(reChar)) {
                result = reChar;
            }
        }
        Integer length = codeRuleEntryModel.getLength();
        if (!length.equals(0)) {
            if (result.length() >= length.intValue()) {
                result = codeRuleEntryModel.getCutStyle().booleanValue() ? StringUtil.sub(result, 0, length.intValue()) : result.substring(result.length() - length.intValue());
            } else {
                result = codeRuleEntryModel.getAddStyle().booleanValue() ? StringUtils.rightPad(result, length.intValue(), codeRuleEntryModel.getAddChar()) : StringUtils.leftPad(result, length.intValue(), codeRuleEntryModel.getAddChar());
            }
        }
        if (Func.isNotEmpty(codeRuleEntryModel.getSeparatorChar())) {
            result = result + codeRuleEntryModel.getSeparatorChar();
        }
        return result;
    }

    private String checkCops(String value, String format) {
        if (Func.isNotEmpty(format)) {
            if (format.equals(CodeRuleConstant.CAPS_TYPE_CODE_U)) {
                value = value.toUpperCase();
            } else {
                value = value.toLowerCase();
            }
        }
        return value;
    }
}