package es.template;

import com.miniframe.core.ext.UtilTools;
import com.miniframe.mappers.es.dao.EsMapper;
import com.miniframe.mappers.es.model.ProComAttDto;
import com.miniframe.model.es.*;
import com.miniframe.model.es.dao.*;
import es.template.pipenet.Component;
import es.template.pipenet.ComponetData;
import es.template.pipenet.Node;
import es.template.pipenet.Simulations;
import tk.mybatis.mapper.entity.Example;

import javax.rmi.CORBA.Util;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TemplateServer {

    public static List<Node> findNodes(String pid ){
        List<Node> nodes = new ArrayList<>();
        EsProComMapper cdao = UtilTools.getBean(EsProComMapper.class);
        EsProComSQLBuilder csb = new EsProComSQLBuilder();
        EsProComSQLBuilder.Criteria csc = csb.createCriteria();
        csc.andPidEqualTo(pid);
        csc.andComIdEqualTo("3");//节点
        csb.setOrderByClause("ser asc");
        List<EsProCom> cs =cdao.selectByExample(csb);
        for (EsProCom c:cs) {
            Node n =new Node();
            n.setNode(c);
            EsMapper esdao = UtilTools.getBean(EsMapper.class);
            List<ProComAttDto> atts = esdao.selectPrComAttList(c.getPcId());
            n.setAtts(atts);
            nodes.add(n);
        }
        return  nodes;
    }
    public static List<Component> findComs(String pid ){
        List<Component> coms = new ArrayList<>();
        EsMapper esdao = UtilTools.getBean(EsMapper.class);
        EsProComMapper cdao = UtilTools.getBean(EsProComMapper.class);

        EsProComSQLBuilder csb = new EsProComSQLBuilder();
        EsProComSQLBuilder.Criteria csc = csb.createCriteria();
        csc.andPidEqualTo(pid);
        csc.andComIdNotEqualTo("3");//非节点
        csc.andComIdNotEqualTo("-1");//非模拟数据
        csb.setOrderByClause("ser asc");
        List<EsProCom> cs =cdao.selectByExample(csb);
        for (EsProCom c:cs) {
            EsComMapper comdao =UtilTools.getBean(EsComMapper.class);
            EsCom  cm= comdao.selectByPrimaryKey(c.getComId());
            Component com = new Component();
            com.setCom(cm);
            com.setPcom(c);
            //获取非下拉值数据
            List<ProComAttDto> atts =esdao.selectPrComAttListNoData(c.getPcId());
            com.setAtts(conversionUnit(atts));

            //获取下拉值数据
            List<ComponetData> datas = new ArrayList<>();
            List<String> cdIds = esdao.selectAttDataCdIds(c.getPcId());
            for (String cdId:cdIds) {
                EsDataMapper ddao = UtilTools.getBean(EsDataMapper.class);
                EsData d = ddao.selectByPrimaryKey(cdId);
                List<ProComAttDto> datts =esdao.selectPrComAttDataList(c.getPcId(),cdId);
                ComponetData data = new ComponetData();
                data.setCode(d.getCode());
                data.setAtts(conversionUnit(datts));
                datas.add(data);
            }
            com.setDatas(datas);

            //获取链接数据
            List<String> nIds =esdao.selectComconNodeIdcodeSer(c.getPcId());
            com.setNodeIds(nIds);

            coms.add(com);
        }
        return  coms;
    }

    /**
     * 获取模拟数据
     * @param pid
     * @return
     */
    public static Simulations findSimulations(String pid ){
        Simulations sim =new Simulations();
        EsMapper esdao = UtilTools.getBean(EsMapper.class);
        List<ProComAttDto> comatt = esdao.selectSimulationsPrComAttDataList(pid);
        sim.setType( comatt.get(0).getValue());//仿真类型
        comatt.remove(0);
        sim.setAtts(conversionUnit(comatt));
        return sim;
    }
    /**
     * 转换单位
     * @param proComAttDtoList
     * @return
     */
    public static List<ProComAttDto> conversionUnit(List<ProComAttDto> proComAttDtoList){
        for(ProComAttDto proComAttDto:proComAttDtoList){
            if(proComAttDto.getUnitType() == null || proComAttDto.getUnitType().equals("无")|| proComAttDto.getUnitType().isEmpty()){
                continue;
            }
            String unit = proComAttDto.getUnit();
            String str = "无";
            if(unit == null) continue;
            if((!unit.isEmpty())&&(!str.equals(unit))){
                //查询目前单位在es_unit表的记录
                EsUnitMapper esmapper = UtilTools.getBean(EsUnitMapper.class);
                EsUnitSQLBuilder sqlbuilder = new EsUnitSQLBuilder();
                EsUnitSQLBuilder.Criteria criteria = sqlbuilder.createCriteria();
                criteria.andGutIdEqualTo(proComAttDto.getUnitType());//在es_unit表中查找gutid = unit_type
                criteria.andValueEqualTo(proComAttDto.getUnit());
                EsUnit esUnit = esmapper.selectOneByExample(sqlbuilder);


                //查询factor为1的单位在es_unit表中的记录
                Example example = new Example(EsUnit.class);
                example.createCriteria()
                        .andEqualTo("gutId", proComAttDto.getUnitType())
                        .andEqualTo("factor", new BigDecimal(1));
                List<EsUnit> esUnitList = esmapper.selectByExample(example);
                /*EsUnitSQLBuilder sqlbuilder_standardUnit = new EsUnitSQLBuilder();
                EsUnitSQLBuilder.Criteria criteria1 = sqlbuilder_standardUnit.createCriteria();
                criteria1.andGutIdEqualTo(proComAttDto.getUnitType());
                criteria1.andFactorEqualTo(new BigDecimal(1));
                //EsUnit esUnit_standardUnit = esmapper.selectOneByExample(sqlbuilder_standardUnit);
                List<EsUnit> esUnitList = esmapper.selectByExample(criteria1);*/
                EsUnit esUnit_standardUnit = esUnitList.get(0);

                if(Objects.equals(esUnit.getFactor(), new BigDecimal(1))){//factor为1时不变
                    continue;
                }else if(proComAttDto.getValue().isEmpty()) {
                    continue;
                } else if (proComAttDto.getValue()==null) {
                    continue;
                } else{//计算value值
                    double value = Double.parseDouble(proComAttDto.getValue());
                    double factor = esUnit.getFactor().doubleValue();
                    double offset = esUnit.getUtOffset().doubleValue();
                    double conversionValue = (value- offset) / factor ;
                    proComAttDto.setValue(String.valueOf(conversionValue));
                    proComAttDto.setUnit(esUnit_standardUnit.getValue());
                }
            }
        }
        return proComAttDtoList;
    }

}