package com.ld.igds.grain;

import com.alibaba.fastjson.JSONObject;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.DepotType;
import com.ld.igds.grain.dto.*;
import com.ld.igds.models.DepotConf;
import com.ld.igds.models.DicSysConf;
import com.ld.igds.util.NumberUtil;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 粮情数据各个类型的转换控制
 *
 * @author jiazx
 */
@Slf4j
public class GrainDataBuilder {

	/**
	 * @param report
	 * @param conf
	 *            注意当前参数只是为了获取其全局配置参数，不考虑是否与当前粮情信息是否匹配
	 * @return
	 */
	public static GrainDataReport updateReport(GrainDataReport report,
			DicSysConf conf) {
		// 根据仓库类型不同进行不同调整
		if (DepotType.TYPE_02.getCode().equals(report.getDepotType())) {// 浅圆仓

		} else if (DepotType.TYPE_03.getCode().equals(report.getDepotType())) {

		} else if (DepotType.TYPE_04.getCode().equals(report.getDepotType())) {

		} else {
			buildLays(report, conf);
		}

		report.setPoints(null);
		return report;
	}

	/**
	 * 根据单个粮情的数据信息，包括采集点和层信息
	 *
	 * @param result
	 * @param dicSysConf
	 *            全局系统参数，为空表示不优化
	 * @param depotConf
	 *            粮情配置参数，不能为空需要根据当前仓库的类型做判断
	 */
	public static void updateGrainData(GrainData result, DicSysConf dicSysConf, DepotConf depotConf) {

		if (null == depotConf)
			return;

		List<GrainPoint> listPoints = new ArrayList<>();
		List<GrainLay> listLays = new ArrayList<>();// 层数据
		List<GrainRow> listRows = new ArrayList<>();// 行数据

		// 根据仓库类型不同进行不同调整
		if (DepotType.TYPE_02.getCode().equals(depotConf.getDepotType())) {// 浅圆仓
			result = buildLLaysAndRows2(listPoints, listLays, listRows, result, dicSysConf, depotConf);

		} else if (DepotType.TYPE_03.getCode().equals(depotConf.getDepotType())) {

			result = buildLLaysAndRows3(listPoints, listLays, listRows, result,
					dicSysConf, depotConf);

		} else if (DepotType.TYPE_04.getCode().equals(depotConf.getDepotType())) {
			result = buildLLaysAndRows2(listPoints, listLays, listRows, result,
					dicSysConf, depotConf);

		} else {
			result = buildLLaysAndRows1(listPoints, listLays, listRows, result,
					dicSysConf, depotConf);
		}

		result.setSysDate(new Date());
		result.setListLays(listLays);
		result.setListRows(listRows);
		result.setListPoints(listPoints);

		log.debug("---------{}", JSONObject.toJSONString(result));
	}

	/**
	 * 油筒仓解析，更新展示效果数据，解析方式同普通筒仓信息
	 *
	 * @param listPoints
	 * @param listLays
	 * @param listRows
	 * @param result
	 * @param dicSysConf
	 * @param depotConf
	 * @return
	 */
	private static GrainData buildLLaysAndRows3(List<GrainPoint> listPoints,
			List<GrainLay> listLays, List<GrainRow> listRows, GrainData result,
			DicSysConf dicSysConf, DepotConf depotConf) {
		if (StringUtils.isEmpty(result.getOilHeight())) {
			result.setOilHeight("0.0-0.0");
			log.warn("油桶仓={} 解析过程中没有获取到油面高度信息，默认显示为0", depotConf.getDepotName());
		} else {
			if (result.getOilHeight().indexOf("-") == -1) {
				result.setOilHeight(result.getOilHeight() + "-"
						+ result.getOilHeight());
				log.warn("油桶仓={} 解析中没有获取建筑物的高度信息，默认建筑物高度等于液位高度",
						depotConf.getDepotName());
			}
		}

		return buildLLaysAndRows2(listPoints, listLays, listRows, result,
				dicSysConf, depotConf);
	}

	/**
	 * 圆筒仓 更新展示效果数据
	 *
	 * @param listPoints
	 * @param listLays
	 * @param listRows
	 * @param result
	 * @param dicSysConf
	 * @param depotConf
	 * @return
	 */
	private static GrainData buildLLaysAndRows2(List<GrainPoint> listPoints,
			List<GrainLay> listLays, List<GrainRow> listRows, GrainData result,
			DicSysConf dicSysConf, DepotConf depotConf) {

		String points = result.getPoints();
		String cableRule = result.getCable();
		String cableCir = result.getCableCir();

		if (StringUtils.isEmpty(points)) {
			return result;
		}

		// 获取布线规则
		if (StringUtils.isEmpty(cableRule) || StringUtils.isEmpty(cableCir)) {
			return result;
		}
		// 每一圈列数
		String[] cableRuleAtt = result.getCable().split("-");
		// 每一圈层数
		String[] cableCirAtt = result.getCableCir().split("-");

		if (cableRuleAtt.length != cableCirAtt.length) {
			log.error("当前仓库：{}，布线规则不正确，无法解析粮情信息……", depotConf.getDepotName());
			return result;
		}

		// 获取最大的层配置--默认每一圈都一样
		int layMax = Integer.valueOf(cableCirAtt[0]);
		 for (int i = 0; i < cableCirAtt.length; i++) {
			 if (Integer.valueOf(cableCirAtt[i]) >= layMax) layMax = Integer.valueOf(cableCirAtt[i]);
		 }

		// 根据层更新层列表信息
		updateListLaysCir(listLays, cableRuleAtt, cableCirAtt, layMax);

		String[] attr = points.split(",");

		GrainPoint point;
		Double tempT;
		GrainLay lay;
		int x = 0, y = 0, z = 1, fz = 0;// x=所在圈，从0开始；y代表电缆根号从0开始，z=代表所在层从1开始
		List<Integer> listErrorTag = new ArrayList<>();// 故障或者错误的点
		List<Integer> listHighTag = new ArrayList<>();// 高温点

		int layNum = layMax;// 当前圈的层数
		int rowNum = 1;// 当前圈的根数
		int index = 0;// 当前温度点的位置
		int startRow = 0;//当前粮情电缆根号
		for (int i = 0; i < cableRuleAtt.length; i++) {
			x = i;
			rowNum = Integer.valueOf(cableRuleAtt[i]);// 根数
			for (int k = 0; k < rowNum; k++) {
				y = k;
				for (int j = 0; j < layNum; j++) {
					z = j;
					fz = j + 1;
					tempT = Double.valueOf(attr[index]);
					index++;

					point = new GrainPoint(tempT, x, startRow, z, fz);

					// 统计每层数据 --初始化数据
					lay = listLays.get(z);
                    point.setTemp(tempT);
                    listPoints.add(point);

					if (tempT <= Constant.ERROR_TEMP) {
						if(tempT != Constant.ADD_TEMP){
							lay.setSumNum(lay.getSumNum() - 1);
						}
					} else {
                        //判断是否高温优化
                        if (null != dicSysConf && null != depotConf && null != depotConf.getTempMax()
                                && Constant.YN_Y.equals(dicSysConf.getGrainMaxAuto())) {
                            if (tempT > depotConf.getTempMax()) {
                                //记录高温点的位置
                                listHighTag.add(listPoints.size() -1);
                            }else {
                                lay.setSumTemp(lay.getSumTemp() + tempT);
                                // 层最高最低
                                if (tempT > lay.getTempMax()) {
                                    lay.setTempMax(tempT);
                                }
                                if (tempT < lay.getTempMin()) {
                                    lay.setTempMin(tempT);
                                }
                            }
                        }else {
                            lay.setSumTemp(lay.getSumTemp() + tempT);
                            // 层最高最低
                            if (tempT > lay.getTempMax()) {
                                lay.setTempMax(tempT);
                            }
                            if (tempT < lay.getTempMin()) {
                                lay.setTempMin(tempT);
                            }
                        }
					}
					if (tempT == Constant.ERROR_TEMP || tempT == Constant.FAULT_TEMP) {
						listErrorTag.add(listPoints.size()-1);
					}
				}

				startRow ++;
			}

		}

        Double maxTemp = -50.0; //比较最高温
		// 调整层信息
		for (GrainLay detail : listLays) {
			if (0 != detail.getSumNum()) {
				detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
				detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
						1));
			}

			if (0 != detail.getSumInNum()) {
				detail.setTempAveIn(detail.getSumInTemp()
						/ detail.getSumInNum());
				detail.setTempAveIn(NumberUtil.keepPrecision(
						detail.getTempAveIn(), 1));
			}

			if (0 != detail.getSumOutNum()) {
				detail.setTempAveOut(detail.getSumOutTemp()
						/ detail.getSumOutNum());
				detail.setTempAveOut(NumberUtil.keepPrecision(
						detail.getTempAveOut(), 1));
			}
			//过滤掉比较的最大最小的值50和-50
			if(detail.getTempMax() == -50){
				detail.setTempMax(0.0);
			}
			if(detail.getTempMin() == 50){
				detail.setTempMin(0.0);
			}
            if (listHighTag.size() > 0) {
                if(detail.getTempMax() > maxTemp){
                    maxTemp = detail.getTempMax();
                }
            }
		}
        //高温点替换为层平均值
        if (null != dicSysConf && null != depotConf && null != depotConf.getTempMax()
                && Constant.YN_Y.equals(dicSysConf.getGrainMaxAuto())) {
            if (listHighTag.size() > 0) {
                for (Integer integer : listHighTag) {
                    point = listPoints.get(integer);
                    // 获取当前层的信息
                    lay = listLays.get(point.getZ());
                    point.setTemp(lay.getTempAve());
                    listPoints.set(integer, point);
                }
                //设置最高温
                result.setTempMax(maxTemp);
            }
        }
		// 最后根据全局参数判断是否需要调整异常点数据进行调整
		if (null != dicSysConf
				&& Constant.YN_Y.equals(dicSysConf.getGrainErrorAuto())) {
			if (listErrorTag.size() > 0) {
				for (Integer integer : listErrorTag) {
					point = listPoints.get(integer);
					// 获取当前层的信息
					lay = listLays.get(point.getZ());
					point.setTemp(lay.getTempAve());

					listPoints.set(integer, point);
				}
			}
		}
		result.setListPoints(listPoints);
		result.setListLays(listLays);

		return result;
	}

	/**
	 * 平方仓 跟新层数据和行数据
	 *
	 * @param listPoints
	 * @param listLays
	 * @param dicSysConf
	 * @param depotConf
	 */
	public static GrainData buildLLaysAndRows1(List<GrainPoint> listPoints,
			List<GrainLay> listLays, List<GrainRow> listRows, GrainData result,
			DicSysConf dicSysConf, DepotConf depotConf) {

		String points = result.getPoints();
		String cable = result.getCable();
		// 获取布线规则
		if (StringUtils.isEmpty(cable)) {
			return result;
		}
		if (StringUtils.isEmpty(points)) {
			return result;
		}

		String[] attr = cable.split("-");
		int cableZ = Integer.valueOf(attr[0]);
		int cableY = Integer.valueOf(attr[1]);
		int cableX = Integer.valueOf(attr[2]);

		// 根据层更新层列表信息
		updateListLays(listLays, cableX, cableY, cableZ);

		// 更新行数据的列表
		updateListRows(listRows, cableX, cableY, cableZ);

		attr = points.split(",");

		GrainPoint point;
		Double tempT;
		GrainLay lay;
		GrainRow row;
		List<Integer> listErrorTag = new ArrayList<>();// 故障或者错误的点
		Double sumAll = 0.0;

		Double sumAllTemp = 0.0;

		int sumAllNum = 0;
		int tempT2;
		int x = 0, y = 0, z = 0, fz = 0;
		for (int i = 0; i < attr.length; i++) {
			z = i % cableZ;
			fz = z + 1;
			x = i / (cableZ * cableY);
			y = x * (cableZ * cableY);
			y = (i - y) / cableZ;

			// 倒转X轴
			x = cableX - 1 - x;

			tempT = Double.valueOf(attr[i]);
			point = new GrainPoint(tempT, x, y, z, fz);

			// 统计每层数据 --初始化数据
			lay = listLays.get(z);

			// 开始封装行数据信息
			row = listRows.get(y);

			if (tempT <= Constant.ERROR_TEMP) {
				listErrorTag.add(i);

				lay.setSumNum(lay.getSumNum() - 1);

				row.setSumNum(row.getSumNum() - 1);

				if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
					lay.setSumOutNum(lay.getSumOutNum() - 1);
				} else {
					lay.setSumInNum(lay.getSumInNum() - 1);
				}
			} else {
				sumAllTemp += tempT;
				// 高温优化的启用要求1-处理单个高温点
				if (null != dicSysConf && null != depotConf
						&& null != depotConf.getTempMax()
						&& Constant.YN_Y.equals(dicSysConf.getGrainMaxAuto())) {

					if (tempT > depotConf.getTempMax()) {
						tempT2 = (int) (tempT - depotConf.getTempMax()) + 1;
						tempT = NumberUtil.keepPrecision(tempT - tempT2, 1);
						result.setRemark("粮温检测正常");
						log.debug("--原值={},--差值={},--结果={}", point.getTemp(),
								tempT2, tempT);
					}
					if (result.getTempMax() > depotConf.getTempMax()) {
						tempT2 = (int) (result.getTempMax() - depotConf
								.getTempMax()) + 1;
						result.setTempMax(NumberUtil.keepPrecision(
								result.getTempMax() - tempT2, 1));
					}
					if (tempT > result.getTempMax()) {
						result.setTempMax(tempT);
					}
				}

				// 层行列补充
				lay.setSumTemp(lay.getSumTemp() + tempT);
				lay.setSumTemp(NumberUtil.keepPrecision(lay.getSumTemp(),1));

				row.setSumTemp(row.getSumTemp() + tempT);
				row.setSumTemp(NumberUtil.keepPrecision(row.getSumTemp(),1));

				if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
					lay.setSumOutTemp(lay.getSumOutTemp() + tempT);
				} else {
					lay.setSumInTemp(lay.getSumInTemp() + tempT);
				}

				// 层最高最低
				if (tempT > lay.getTempMax()) {
					lay.setTempMax(tempT);
				}
				if (tempT < lay.getTempMin()) {
					lay.setTempMin(tempT);
				}

				// 行最高最低
				if (tempT > row.getTempMax()) {
					row.setTempMax(tempT);
				}
				if (tempT < row.getTempMin()) {
					row.setTempMin(tempT);
				}

				// log.info("----温度点={}",tempT);
				sumAll += tempT;
				sumAllNum = sumAllNum + 1;
				point.setTemp(tempT);
			}
			point.setTemp(NumberUtil.keepPrecision(point.getTemp(), 1));
			listPoints.add(point);
		}

		// 调整层信息
		for (GrainLay detail : listLays) {
			if (0 != detail.getSumNum()) {
				detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
				detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
						1));
			}

			if (0 != detail.getSumInNum()) {
				detail.setTempAveIn(detail.getSumInTemp()
						/ detail.getSumInNum());
				detail.setTempAveIn(NumberUtil.keepPrecision(
						detail.getTempAveIn(), 1));
			}

			if (0 != detail.getSumOutNum()) {
				detail.setTempAveOut(detail.getSumOutTemp()
						/ detail.getSumOutNum());
				detail.setTempAveOut(NumberUtil.keepPrecision(
						detail.getTempAveOut(), 1));
			}
			//过滤掉比较的最大最小的值50和-50
			if(detail.getTempMax() == -50){
				detail.setTempMax(0.0);
			}
			if(detail.getTempMin() == 50){
				detail.setTempMin(0.0);
			}
		}

		// 调整行信息
		for (GrainRow detail : listRows) {
			if (0 != detail.getSumNum()) {
				detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
				detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
						1));
			}
			//过滤掉比较的最大最小的值50和-50
			if(detail.getTempMax() == -50){
				detail.setTempMax(0.0);
			}
			if(detail.getTempMin() == 50){
				detail.setTempMin(0.0);
			}
		}

		// 最后根据全局参数判断是否需要调整异常点数据进行调整
		if (null != dicSysConf
				&& Constant.YN_Y.equals(dicSysConf.getGrainErrorAuto())) {
			if (listErrorTag.size() > 0) {
				for (Integer integer : listErrorTag) {
					point = listPoints.get(integer);
					// 获取当前层的信息
					lay = listLays.get(point.getZ());
					point.setTemp(lay.getTempAve());

					listPoints.set(integer, point);
				}
			}
		}

		// 高温优化的启用要求2-重新计算整体平均值
		if (null != dicSysConf && null != depotConf
				&& null != depotConf.getTempMax()
				&& Constant.YN_Y.equals(dicSysConf.getGrainMaxAuto())) {
			log.debug("---原平均={},后总温={},--后总个数={},后平均={},原总温={}",
					result.getTempAve(), sumAll, sumAllNum, sumAll / sumAllNum,
					sumAllTemp);
			result.setTempAve(NumberUtil.keepPrecision((sumAll / sumAllNum), 1));
		}
		return result;
	}

	private static void buildLays(GrainDataReport report, DicSysConf dicSysConf) {
		String points = report.getPoints();
		String cable = report.getCable();
		// 获取布线规则
		if (StringUtils.isEmpty(cable)) {
			return;
		}
		if (StringUtils.isEmpty(points)) {
			return;
		}

		String[] attr = cable.split("-");
		int cableZ = Integer.valueOf(attr[0]);
		int cableY = Integer.valueOf(attr[1]);
		int cableX = Integer.valueOf(attr[2]);

		List<GrainPoint> listPoints = new ArrayList<GrainPoint>();
		List<GrainLay> listLays = initDetail(cableX, cableY, cableZ);

		attr = points.split(",");

		GrainPoint point;
		Double tempT;
		GrainLay lay;
		List<Integer> listErrorTag = new ArrayList<>();// 故障或者错误的点
		Double sumAll = 0.0;

		Double sumAllTemp = 0.0;

		int sumAllNum = 0;
		int x = 0, y = 0, z = 0, fz = 0;
		for (int i = 0; i < attr.length; i++) {
			z = i % cableZ;
			fz = z + 1;
			x = i / (cableZ * cableY);
			y = x * (cableZ * cableY);
			y = (i - y) / cableZ;

			// 倒转X轴
			x = cableX - 1 - x;

			tempT = Double.valueOf(attr[i]);
			point = new GrainPoint(tempT, x, y, z, fz);

			// 统计每层数据 --初始化数据
			lay = listLays.get(z);

			if (tempT <= Constant.ERROR_TEMP) {
				listErrorTag.add(i);

				lay.setSumNum(lay.getSumNum() - 1);

				if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
					lay.setSumOutNum(lay.getSumOutNum() - 1);
				} else {
					lay.setSumInNum(lay.getSumInNum() - 1);
				}
			} else {
				sumAllTemp += tempT;

				if (tempT > report.getTempMax()) {
					report.setTempMax(tempT);
				}

				// 层行列补充
				lay.setSumTemp(lay.getSumTemp() + tempT);

				if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
					lay.setSumOutTemp(lay.getSumOutTemp() + tempT);
				} else {
					lay.setSumInTemp(lay.getSumInTemp() + tempT);
				}

				// 层最高最低
				if (tempT > lay.getTempMax()) {
					lay.setTempMax(tempT);
				}
				if (tempT < lay.getTempMin()) {
					lay.setTempMin(tempT);
				}

				// log.info("----温度点={}",tempT);
				sumAll += tempT;
				sumAllNum = sumAllNum + 1;
				point.setTemp(tempT);
			}

			listPoints.add(point);
		}

		// 调整层信息
		for (GrainLay detail : listLays) {
			if (0 != detail.getSumNum()) {
				detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
				detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
						1));
			}

			if (0 != detail.getSumInNum()) {
				detail.setTempAveIn(detail.getSumInTemp()
						/ detail.getSumInNum());
				detail.setTempAveIn(NumberUtil.keepPrecision(
						detail.getTempAveIn(), 1));
			}

			if (0 != detail.getSumOutNum()) {
				detail.setTempAveOut(detail.getSumOutTemp()
						/ detail.getSumOutNum());
				detail.setTempAveOut(NumberUtil.keepPrecision(
						detail.getTempAveOut(), 1));
			}

			// 将层数据转换为行数据
			updateReportLayInfo(report, detail);
		}
	}
	
	/**
	 * 根据粮情温度，判断是否警告值，然后转换为页面需要渲染的值，主要备用和故障的值的调整
	 * @param temp
	 * @return
	 */
	public static String renderTempValue(Double temp) {
		
		
		if(temp > 45) return "故障";
		
		if(temp == Constant.ERROR_TEMP) return "备用";
		if(temp == Constant.FAULT_TEMP) return "故障";
		if(temp == Constant.ADD_TEMP) return "--";

		return temp+"";
	}

	private static void updateReportLayInfo(GrainDataReport report, GrainLay lay) {

		if (1 == lay.getFz()) {// 第一层
			report.setZ1(lay.getFz());
			report.setTempAve1(lay.getTempAve() + "");
			report.setTempMax1(lay.getTempMax() + "");
			report.setTempMin1(lay.getTempMin() + "");
		}
		if (2 == lay.getFz()) {// 第一层
			report.setZ2(lay.getFz());
			report.setTempAve2(lay.getTempAve() + "");
			report.setTempMax2(lay.getTempMax() + "");
			report.setTempMin2(lay.getTempMin() + "");
		}

		if (3 == lay.getFz()) {// 第一层
			report.setZ3(lay.getFz());
			report.setTempAve3(lay.getTempAve() + "");
			report.setTempMax3(lay.getTempMax() + "");
			report.setTempMin3(lay.getTempMin() + "");
		}

		if (4 == lay.getFz()) {// 第一层
			report.setZ4(lay.getFz());
			report.setTempAve4(lay.getTempAve() + "");
			report.setTempMax4(lay.getTempMax() + "");
			report.setTempMin4(lay.getTempMin() + "");
		}

		if (5 == lay.getFz()) {// 第一层
			report.setZ5(lay.getFz());
			report.setTempAve5(lay.getTempAve() + "");
			report.setTempMax5(lay.getTempMax() + "");
			report.setTempMin5(lay.getTempMin() + "");
		}
		if (6 == lay.getFz()) {// 第一层
			report.setZ6(lay.getFz());
			report.setTempAve6(lay.getTempAve() + "");
			report.setTempMax6(lay.getTempMax() + "");
			report.setTempMin6(lay.getTempMin() + "");
		}
		if (7 == lay.getFz()) {// 第一层
			report.setZ7(lay.getFz());
			report.setTempAve7(lay.getTempAve() + "");
			report.setTempMax7(lay.getTempMax() + "");
			report.setTempMin7(lay.getTempMin() + "");
		}
		if (8 == lay.getFz()) {// 第一层
			report.setZ8(lay.getFz());
			report.setTempAve8(lay.getTempAve() + "");
			report.setTempMax8(lay.getTempMax() + "");
			report.setTempMin8(lay.getTempMin() + "");
		}
		if (9 == lay.getFz()) {// 第一层
			report.setZ9(lay.getFz());
			report.setTempAve9(lay.getTempAve() + "");
			report.setTempMax9(lay.getTempMax() + "");
			report.setTempMin9(lay.getTempMin() + "");
		}
		if (10 == lay.getFz()) {// 第一层
			report.setZ10(lay.getFz());
			report.setTempAve10(lay.getTempAve() + "");
			report.setTempMax10(lay.getTempMax() + "");
			report.setTempMin10(lay.getTempMin() + "");
		}
	}

	private static List<GrainLay> initDetail(int cableX, int cableY, int cableZ) {
		List<GrainLay> result = new ArrayList<>();
		GrainLay lay;
		for (int i = 1; i <= cableZ; i++) {
			lay = new GrainLay(i, i - 1);
			lay.setSumNum(cableY * cableX);
			lay.setSumInNum((cableY - 2) * (cableX - 2));
			lay.setSumOutNum(2 * cableY + 2 * cableX - 4);
			lay.setTempMin(50.0);
			lay.setTempMax(-50.0);
			result.add(lay);
		}
		return result;
	}

	private static void updateListLays(List<GrainLay> listLays, int cableX,
			int cableY, int cableZ) {// 层从1开始
		GrainLay lay;
		for (int i = 1; i <= cableZ; i++) {
			lay = new GrainLay(i, i - 1);
			lay.setSumNum(cableY * cableX);
			lay.setSumInNum((cableY - 2) * (cableX - 2));
			lay.setSumOutNum(2 * cableY + 2 * cableX - 4);
			lay.setTempMin(50.0);
			lay.setTempMax(-50.0);
			listLays.add(lay);
		}
	}

	private static void updateListRows(List<GrainRow> listRows, int cableX,
			int cableY, int cableZ) {// 从0开始
		GrainRow row;
		for (int i = 0; i < cableY; i++) {
			row = new GrainRow(i);
			row.setSumNum(cableZ * cableX);
			row.setTempMin(50.0);
			row.setTempMax(-50.0);
			listRows.add(row);
		}
	}

	/**
	 * 圆筒仓--仓温度解析
	 *
	 * @param listLays
	 * @param cableRuleAtt
	 * @param cableCirAtt
	 */
	private static void updateListLaysCir(List<GrainLay> listLays,
			String[] cableRuleAtt, String[] cableCirAtt, int layMax) {
		GrainLay lay;
		for (int i = 1; i <= layMax; i++) {
			lay = new GrainLay(i, i);
			int sumNum = 0;
			for (int j = 0; j < cableRuleAtt.length; j++) {
				if (Integer.valueOf(cableCirAtt[j]) >= i) {
					sumNum += Integer.valueOf(cableRuleAtt[j]);
				}
			}
			lay.setSumNum(sumNum);
			lay.setSumInNum(1);
			lay.setSumOutNum(1);
			lay.setTempMin(50.0);
			lay.setTempMax(-50.0);
			listLays.add(lay);
		}
	}


}