package com.sundata.internalevaluation.calc.calcUnit;

import com.sundata.common.util.DBExecutor;
import com.sundata.common.util.JsonUtil;
import com.sundata.internalevaluation.calc.model.CalcException;
import com.sundata.internalevaluation.calc.model.CalcResult;
import com.sundata.internalevaluation.calc.model.CalcUnit;
import com.sundata.internalevaluation.calc.model.finals.CalcType;
import com.sundata.internalevaluation.calc.util.InvokeUtil;
import com.sundata.internalevaluation.configuration.model.SysInterfaceParam;
import com.sundata.internalevaluation.script.TemplateUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;

/**
 * Created by IntelliJ IDEA.
 *
 * @author JoeLazy
 * @date 2025-02-13 16:23:55
 * @description: 接口参数计算单元
 */
public class InterfaceParamCalcUnit extends CalcUnit {

    private static final Logger log = LoggerFactory.getLogger(InterfaceParamCalcUnit.class);

    /**
     * 接口参数实体
     */

    private final SysInterfaceParam sysInterfaceParam;

    /**
     * 创建数据单元的绝对对象，对象必须包含如下参数
     *
     * @param calcCode    计算对象编号
     * @param calcName    计算对象名称
     * @param calcType    计算类型
     * @param initContext 计算单元初始化参数
     */
    public InterfaceParamCalcUnit(String calcCode, String calcName, CalcType calcType, Map<String, Object> initContext, SysInterfaceParam sysInterfaceParam) {
        super(calcCode, calcName, calcType, initContext);
        this.sysInterfaceParam = sysInterfaceParam;
    }

    /**
     * 判断是否已经计算过数据了
     *
     * @param calculateInstanceNumber 计算流水号
     * @return 是否计算过 true 计算过 false 没有计算过
     */
    @Override
    public boolean isCalcFinished(String calculateInstanceNumber) {
        return false;
    }

    /**
     * 初始化计算结果的方法，如果已经计算过，在实现过程中，应当在此方法中根据计算流水号重新初始化 resultContext 结果对象，为其他依赖对象做准备
     * 若明明计算过本单元但再次计算时没有初始化该对象，则计算依赖出现问题无法定位与处理
     *
     * @param calculateInstanceNumber 计算流水号
     */
    @Override
    public void initResultContext(String calculateInstanceNumber) {

    }

    /**
     * 根据节点配置获取源节点；
     *
     * @return 所有源头节点
     */
    @Override
    public List<CalcUnit> getSourceCalcUnits() {
        return List.of();
    }

    /**
     * 计算之后的方法，可实现为空
     *
     * @param context
     */
    @Override
    public void afterCalc(Map<String, Object> context) {

    }

    /**
     * 计算之前，可实现空
     *
     * @param context
     */
    @Override
    public void beforeCalc(Map<String, Object> context) {

    }

    /**
     * 必须实现的主体计算内容
     *
     * @param thisResult              本计算单元的结果
     * @param calculateInstanceNumber 计算流水号
     * @param context                 节点计算参数清单
     * @param sourceResults           源头计算节点的结果
     */
    @Override
    public void calc(CalcResult<String, Object> thisResult, String calculateInstanceNumber, Map<String, Object> context, Map<CalcUnit, CalcResult<String, Object>> sourceResults) {


        log.debug("计算{}：编号:{}，名称:{}，流水号:{}", getCalcType().getName(),getCalcCode(),getCalcName(),calculateInstanceNumber);


        // 参数获取类型
        String paramRetrievalTypeCode = sysInterfaceParam.getParamRetrievalTypeCode();

        // 参数获取内容
        String paramRetrievalTypeCont = sysInterfaceParam.getParamRetrievalTypeCont();


        Object result = null;

        // 获取参数值
        switch (paramRetrievalTypeCode) {
            // 固定值
            case "fixed":
                result = paramRetrievalTypeCont;
                break;
            // java
            //   获取参数内容
            case "java":
                try {
                    result = InvokeUtil.invokeMethod(paramRetrievalTypeCont);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                break;
            // SQL-Map
            case "sqlmap":
                result = DBExecutor.doQuery(TemplateUtil.execute("interfaceParam-temp-sqlmap-"+getCalcCode(),paramRetrievalTypeCont, context));
                break;
            // SQL-List
            case "sqllist":
                result = DBExecutor.doQueryMapList(TemplateUtil.execute("interfaceParam-temp-sqllist-"+getCalcCode(),paramRetrievalTypeCont, context));
                break;
            // SQL-String
            case "sqlstring":
                result = DBExecutor.doQuery(TemplateUtil.execute("interfaceParam-temp-sqlstring-"+getCalcCode(),paramRetrievalTypeCont, context));
                break;
        }


        String paramTypeCode = this.sysInterfaceParam.getParamTypeCode();
        if ("string".equals(paramTypeCode)) {
            if (result instanceof String) {

            } else {
                result = JsonUtil.toJSONString(result);
            }
        } else if ("number".equals(paramTypeCode)) {
            if (result instanceof Number) {
                if (result instanceof Integer) {
                    result = ((Number) result).intValue();
                } else if (result instanceof Long) {
                    result = ((Number) result).longValue();
                } else if (result instanceof Float) {
                    result = ((Number) result).floatValue();
                } else if (result instanceof Double) {
                    result = ((Number) result).doubleValue();
                } else if (result instanceof Short) {
                    result = ((Number) result).shortValue();
                } else if (result instanceof Byte) {
                    result = ((Number) result).byteValue();
                } else {
                    throw new RuntimeException("数据类型不匹配：计算机过不为'数字'");
                }

            } else {
                throw new RuntimeException("数据类型不匹配：计算机过不为'数字'");
            }
        } else {
            throw new CalcException("返回值类型有无，目前仅有 数字和字符串");
        }
        thisResult.put(getCalcCode(), result);
        thisResult.put("entity", sysInterfaceParam);
    }
}