package com.smtaiserver.smtaiserver.javaai.ast;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.smtaiserver.smtaiserver.core.SMTAIServerApp;
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecord;
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecords;
import com.smtaiserver.smtaiserver.javaai.ast.ASTCubeRecs.ASTCubeRecsType;
import com.smtservlet.util.SMTJsonWriter;
import com.smtservlet.util.SMTStatic;

@SuppressWarnings("unused")
public class ASTMergeResult 
{
	private static class ASTMergeChart
	{
		public String				_chartType;
		public Date					_startTime;
		public DBRecords 			_recsValue;
	}
	
	private static abstract class ASTMergeGroup
	{
		public String				_title;
		
		public abstract void		outputGroupToJson(String agentKey, SMTJsonWriter jsonWr) throws Exception;
	}
	
	private static abstract class ASTMergeGroupTableBase extends ASTMergeGroup
	{
		public String				_posXColName;
		public String				_posYColName;
		public String				_devKeyColName;
	}
	
	private static class ASTMergeGroupTableNoDim extends ASTMergeGroupTableBase
	{

		public ASTCubeRecs 			_astCubeRecs;
		public List<ASTDimFilter>	_listDimFilter = null;
		
		private String getStartDate()
		{
			for(ASTCubeRecsValue recValue : _astCubeRecs._mapDimId2Recs.values())
			{
				if(recValue._timeRange != null && recValue._timeRange._startTime != null)
					return SMTStatic.toString(recValue._timeRange._startTime).substring(0, 11);
			}
			
			return "";
		}

		
		@Override
		public void outputGroupToJson(String agentKey, SMTJsonWriter jsonWr) throws Exception 
		{
			int maxRecs = SMTAIServerApp.getApp().getOutputAITableMax();
			
			jsonWr.beginMap(null);
			{
				
				jsonWr.addKeyValue("type", "recordset");
				jsonWr.addKeyValue("agent_key", agentKey);
				jsonWr.addKeyValue("chart", "table");
				jsonWr.addKeyValue("title", _title);	
				jsonWr.addKeyValue("max_cols", _astCubeRecs._colKeyCount);
				
				ASTCubeRecsValue cubeRecs = _astCubeRecs._mapDimId2Recs.get(-1);
				
				if(cubeRecs._timeRange != null)
				{
					jsonWr.beginArray("filter");
					{
						jsonWr.beginMap(null);
						{
							jsonWr.addKeyValue("type", "time_range");
							jsonWr.addKeyValue("update", "set");
							jsonWr.addKeyValue("title", "时间范围");
							jsonWr.addKeyValue("start_value", cubeRecs._timeRange._startTime);
							jsonWr.addKeyValue("end_value", cubeRecs._timeRange._endTime);
							
							long deltaDays = (cubeRecs._timeRange._endTime.getTime() - cubeRecs._timeRange._startTime.getTime()) / 1000 / 24 / 3600 - 60;
							jsonWr.addKeyValue("time_step", deltaDays > 0 ? "month" : "days");
							
							jsonWr.beginArray("start_path");
							{
								jsonWr.addKeyValue(null, cubeRecs._timeRange._pathStartTime);
							}
							jsonWr.endArray();
							
							jsonWr.beginArray("end_path");
							{
								jsonWr.addKeyValue(null, cubeRecs._timeRange._pathEndTime);		
							}
							jsonWr.endArray();
						}
						jsonWr.endMap();

					}
					jsonWr.endArray();

				}
				
				if(_listDimFilter != null && _listDimFilter.size() > 0)
				{
					jsonWr.beginArray("filter");
					for(ASTDimFilter dimFilter : _listDimFilter)
					{
						if(!cubeRecs._recsValue.getFieldMap().containsKey(dimFilter._dimDef.getId().toUpperCase()))
							continue;
						
						jsonWr.beginMap(null);
						{
							String type;
							switch(dimFilter._dimDef.getType())
							{
							case 'T':
								type = "time";
								break;
								
							default:
								type = "string";
								break;
							}
							
							jsonWr.addKeyValue("type", type);
							jsonWr.addKeyValue("update", "set");
							jsonWr.addKeyValue("title", dimFilter._dimDef.getName());
							
							jsonWr.beginArray("path");
							{
								jsonWr.addKeyValue(null, dimFilter._dimPath);
							}
							jsonWr.endArray();
						}
						jsonWr.endMap();
					}
					jsonWr.endArray();
				}

				
				jsonWr.beginArray("cols");
				if(_astCubeRecs._colTitles == null)
				{
					for(String colName : cubeRecs._recsValue.getFieldMap().keySet())
					{
						jsonWr.beginMap(null);
						{
							jsonWr.addKeyValue("title", colName);
							jsonWr.addKeyValue("name", colName);
							jsonWr.addKeyValue("type", "text");
						}
						jsonWr.endMap();
					}
				}
				else
				{
					String[] colNames = cubeRecs._recsValue.getColNames();
					for(int i = 0; i < _astCubeRecs._colTitles.length; i ++)
					{
						String colTitle = _astCubeRecs._colTitles[i];
						
						jsonWr.beginMap(null);
						{
							jsonWr.addKeyValue("title", colTitle);
							jsonWr.addKeyValue("name", colNames[i]);
							jsonWr.addKeyValue("type", "text");
						}
						jsonWr.endMap();						
					}
				}
				jsonWr.endArray();
				
				int posX = cubeRecs._recsValue.getColIndex(_posXColName);
				int posY = cubeRecs._recsValue.getColIndex(_posYColName);
				
				if(posX >= 0 && posY >= 0)
				{
					jsonWr.beginMap("map");
					{
						jsonWr.addKeyValue("pos_x", posX);
						jsonWr.addKeyValue("pos_y", posY);
					}
					jsonWr.endMap();
				}
				
				int posDevKey = cubeRecs._recsValue.getColIndex(_devKeyColName);
				if(posDevKey >= 0)
				{
					jsonWr.beginMap("quota_chart");
					{
						jsonWr.addKeyValue("col", posDevKey);
					}
					jsonWr.endMap();
				}
			
				int colCount = cubeRecs._recsValue.getColCount();
				jsonWr.beginArray("values");
				int recCount = 0;
				for(DBRecord rec : cubeRecs._recsValue.getRecords())
				{
					jsonWr.beginArray(null);
					for(int i = 0; i < colCount; i ++)
					{
						jsonWr.addKeyValue(null, rec.getString(i));
					}
					jsonWr.endArray();
					recCount ++;
					if(recCount > maxRecs)
						break;
				}
				jsonWr.endArray();
				
			}
			jsonWr.endMap();
			
			
		}
		
	}
	
	private static class ASTMergeGroupTableHasDim extends ASTMergeGroupTableBase
	{
		public ASTCubeRecs 			_astCubeRecs;
		public List<ASTDimFilter>	_listDimFilter;
		
		private String getStartDate()
		{

			for(ASTCubeRecsValue recValue : _astCubeRecs._mapDimId2Recs.values())
			{
				if(recValue._timeRange != null && recValue._timeRange._startTime != null)
					return SMTStatic.toString(recValue._timeRange._startTime).substring(0, 11);
			}
			
			return "";
		}

		
		
		@Override
		public void outputGroupToJson(String agentKey, SMTJsonWriter jsonWr) throws Exception 
		{
			int maxRecs = SMTAIServerApp.getApp().getOutputAITableMax();
			
			ASTCubeRecsValue firstCubeRecs = null;
			for(ASTCubeRecsValue curCubeRecs : _astCubeRecs._mapDimId2Recs.values())
			{
				firstCubeRecs = curCubeRecs;
				break;
			}
			
			if(firstCubeRecs == null)
				return;
			
			Set<String> setDimNames = new HashSet<>();
			for(String dimName : _astCubeRecs._dimNames)
			{
				setDimNames.add(dimName);
			}
			
			jsonWr.beginMap(null);
			{
				jsonWr.addKeyValue("type", "recordset");
				jsonWr.addKeyValue("agent_key", agentKey);
				jsonWr.addKeyValue("chart", "table");
				jsonWr.addKeyValue("title", _title);	
				jsonWr.addKeyValue("max_cols", _astCubeRecs._colKeyCount + _astCubeRecs._dimTitles.size());
				
				if(_listDimFilter != null && _listDimFilter.size() > 0)
				{
					jsonWr.beginArray("filter");
					for(ASTDimFilter dimFilter : _listDimFilter)
					{
						if(!firstCubeRecs._recsValue.getFieldMap().containsKey(dimFilter._dimDef.getId().toUpperCase()) && 
						   !setDimNames.contains(dimFilter._dimDef.getId()))
							continue;
						
						jsonWr.beginMap(null);
						{
							String type;
							switch(dimFilter._dimDef.getType())
							{
							case 'T':
								type = "time";
								break;
								
							default:
								type = "string";
								break;
							}
							
							jsonWr.addKeyValue("type", type);
							jsonWr.addKeyValue("update", "set");
							jsonWr.addKeyValue("title", dimFilter._dimDef.getName());
							
							jsonWr.beginArray("path");
							{
								jsonWr.addKeyValue(null, dimFilter._dimPath);
							}
							jsonWr.endArray();
						}
						jsonWr.endMap();
					}
					jsonWr.endArray();
				}
				
				jsonWr.beginArray("cols");
				
				for(int i = 0; i < _astCubeRecs._dimTitles.size(); i ++)
				{
					String title = _astCubeRecs._dimTitles.get(i);
					String name = _astCubeRecs._dimNames.get(i);
					jsonWr.beginMap(null);
					{
						jsonWr.addKeyValue("title", title);
						jsonWr.addKeyValue("name", name);
						jsonWr.addKeyValue("type", "text");
						jsonWr.addKeyValue("group", true);
					}
					jsonWr.endMap();
				}
				
				if(_astCubeRecs._colTitles == null)
				{
					for(String colName : firstCubeRecs._recsValue.getFieldMap().keySet())
					{
						jsonWr.beginMap(null);
						{
							jsonWr.addKeyValue("title", colName);
							jsonWr.addKeyValue("name", colName);
							jsonWr.addKeyValue("type", "text");
						}
						jsonWr.endMap();
					}
				}
				else
				{
					String[] colNames = firstCubeRecs._recsValue.getColNames();
					for(int i = 0; i < _astCubeRecs._colTitles.length; i ++ )
					{
						String colTitle = _astCubeRecs._colTitles[i];
						String colName = colNames[i];
						jsonWr.beginMap(null);
						{
							jsonWr.addKeyValue("title", colTitle);
							jsonWr.addKeyValue("name", colName);
							jsonWr.addKeyValue("type", "text");
						}
						jsonWr.endMap();						
					}
				}
				jsonWr.endArray();
			
				int recCount = 0;
				for(int dimIndex = 0; dimIndex < _astCubeRecs._dimValues.size(); dimIndex ++)
				{
					ASTCubeRecsValue cubeRecs = _astCubeRecs._mapDimId2Recs.get(dimIndex);
					Object[] dimValues = _astCubeRecs._dimValues.get(dimIndex);
					
					if(dimIndex == 0)
					{
						if(!SMTStatic.isNullOrEmpty(cubeRecs._countField))
						{
							int colIndex = cubeRecs._recsValue.getColIndex(cubeRecs._countField);
							if(colIndex >= 0)
								jsonWr.addKeyValue("agg_count_col", colIndex + _astCubeRecs._dimTitles.size());
						}
						
						if(cubeRecs._timeRange != null)
						{
							jsonWr.beginArray("filter");
							{
								jsonWr.beginMap(null);
								{
									jsonWr.addKeyValue("type", "time_range");
									jsonWr.addKeyValue("update", "set");
									jsonWr.addKeyValue("title", "时间范围");
									jsonWr.addKeyValue("start_value", cubeRecs._timeRange._startTime);
									jsonWr.addKeyValue("end_value", cubeRecs._timeRange._endTime);

									long deltaDays = (cubeRecs._timeRange._endTime.getTime() - cubeRecs._timeRange._startTime.getTime()) / 1000 / 24 / 3600 - 60;
									jsonWr.addKeyValue("time_step", deltaDays > 0 ? "month" : "days");
									
									jsonWr.beginArray("start_path");
									{
										jsonWr.addKeyValue(null, cubeRecs._timeRange._pathStartTime);
									}
									jsonWr.endArray();
									
									jsonWr.beginArray("end_path");
									{
										jsonWr.addKeyValue(null, cubeRecs._timeRange._pathEndTime);		
									}
									jsonWr.endArray();
								}
								jsonWr.endMap();

							}
							jsonWr.endArray();

						}
					}
					
					
					int colCount = cubeRecs._recsValue.getColCount();
					
					if(!SMTStatic.isNullOrEmpty(_posXColName) && !SMTStatic.isNullOrEmpty(_posYColName))
					{
						int posX = cubeRecs._recsValue.getColIndex(_posXColName);
						int posY = cubeRecs._recsValue.getColIndex(_posYColName);
						
						if(posX >= 0 && posY >= 0)
						{
							jsonWr.beginMap("map");
							{
								jsonWr.addKeyValue("pos_x", posX);
								jsonWr.addKeyValue("pos_y", posY);
							}
							jsonWr.endMap();
						}
					}
					
					if(!SMTStatic.isNullOrEmpty(_devKeyColName))
					{
						int posDevKey = cubeRecs._recsValue.getColIndex(_devKeyColName);
						if(posDevKey >= 0)
						{
							jsonWr.beginMap("quota_chart");
							{
								jsonWr.addKeyValue("col", posDevKey);
							}
							jsonWr.endMap();
						}
					}
					
					jsonWr.beginArray("values");
					for(DBRecord rec : cubeRecs._recsValue.getRecords())
					{
						jsonWr.beginArray(null);
						
						for(Object dimValue : dimValues)
						{
							jsonWr.addKeyValue(null, SMTStatic.toString(dimValue));
						}
						
						for(int i = 0; i < colCount; i ++)
						{
							jsonWr.addKeyValue(null, rec.getString(i));
						}
						jsonWr.endArray();
						
						recCount ++;
						if(recCount > maxRecs)
							break;
					}
					jsonWr.endArray();
				
					if(recCount > maxRecs)
						break;
				}
			}
			jsonWr.endMap();
			
			
			
		}
		
	}
	
	private static class ASTMergeGroupSummary extends ASTMergeGroup
	{
		public List<ASTCubeRecs>	_listCubeRecs = new ArrayList<>();
		
		private String getStartDate()
		{
			for(ASTCubeRecs cubeRecs : _listCubeRecs)
			{
				for(ASTCubeRecsValue recValue : cubeRecs._mapDimId2Recs.values())
				{
					if(recValue._timeRange != null && recValue._timeRange._startTime != null)
						return SMTStatic.toString(recValue._timeRange._startTime).substring(0, 11);
				}
			}
			
			return "";
		}
		
		@Override
		public void outputGroupToJson(String agentKey, SMTJsonWriter jsonWr) throws Exception
		{
			jsonWr.beginMap(null);
			{
				jsonWr.addKeyValue("type", "summary");
				jsonWr.addKeyValue("agent_key", agentKey);
				jsonWr.addKeyValue("title", _title);
				jsonWr.beginArray("values");
				{
					for(ASTCubeRecs cubeRecs : _listCubeRecs)
					{
						if(cubeRecs._dimValues.size() == 0)
						{
							ASTCubeRecsValue recsValues = cubeRecs._mapDimId2Recs.get(-1);
							if(recsValues == null)
								continue;
							for(DBRecord rec : recsValues._recsValue.getRecords())
							{
								jsonWr.beginMap(null);
								{
									jsonWr.addKeyValue("title", recsValues._title);
									jsonWr.addKeyValue("value", rec.getString(recsValues._groupField));
								}
								jsonWr.endMap();							
							}
						}
						else
						{
							for(int dimId = 0; dimId < cubeRecs._dimValues.size(); dimId ++)
							{
								ASTCubeRecsValue recsValues = cubeRecs._mapDimId2Recs.get(dimId);
								if(recsValues == null)
									continue;
								for(DBRecord rec : recsValues._recsValue.getRecords())
								{
									jsonWr.beginMap(null);
									{
										jsonWr.addKeyValue("title", recsValues._title);
										jsonWr.addKeyValue("value", rec.getString(recsValues._groupField));
									}
									jsonWr.endMap();							
								}							
							}
						}
					}
				}
				jsonWr.endArray();
			}
			jsonWr.endMap();
		}
	}
	
	private static class ASTMergeGroupDetail extends ASTMergeGroup
	{
		public List<ASTMergeChart>				_listRecsValue = new ArrayList<>();
		public Map<String, SMTJsonWriter>		_mapId2filterJson = new LinkedHashMap<>();
		
		public SMTJsonWriter prepareFilterJson(String id)
		{
			SMTJsonWriter jsonWr = _mapId2filterJson.get(id);
			if(jsonWr == null)
			{
				jsonWr = new SMTJsonWriter(false);
				_mapId2filterJson.put(id, jsonWr);
			}
			
			return jsonWr;
		}
		

		private String getStartDate()
		{
			for(ASTMergeChart mergeChart : _listRecsValue)
			{

				if(mergeChart._startTime != null)
					return SMTStatic.toString(mergeChart._startTime).substring(0, 11);
			}
			
			return "";
		}
		
		private String getChartType()
		{
			for(ASTMergeChart mergeChart : _listRecsValue)
			{

				if(mergeChart._chartType != null)
					return mergeChart._chartType;
			}
			
			return null;
		}
		
		protected void outputDetailHeadJson(String agentKey, SMTJsonWriter jsonWr)
		{
			jsonWr.addKeyValue("type", "recordset");
			jsonWr.addKeyValue("agent_key", agentKey);
			jsonWr.addKeyValue("chart", "muli_line");
			jsonWr.addKeyValue("title", _title);
			String chartType = getChartType();
			if(!SMTStatic.isNullOrEmpty(chartType))
				jsonWr.addKeyValue("chart_type", chartType);
	
			// 生成字段
			jsonWr.beginArray("cols");
			{
				jsonWr.beginMap(null);
				{
					jsonWr.addKeyValue("title", "时间");
					jsonWr.addKeyValue("type", "time");
				}
				jsonWr.endMap();
				
				jsonWr.beginMap(null);
				{
					jsonWr.addKeyValue("title", "名称");
					jsonWr.addKeyValue("type", "name");
				}
				jsonWr.endMap();
				
				jsonWr.beginMap(null);
				{
					jsonWr.addKeyValue("title", "值");
					jsonWr.addKeyValue("type", "value");
				}
				jsonWr.endMap();
			}
			jsonWr.endArray();	
			
			// 生成过滤条件
			if(_mapId2filterJson.size() > 0)
			{
				jsonWr.beginArray("filter");
				for(SMTJsonWriter jsonFilter : _mapId2filterJson.values())
				{
					jsonWr.addKeyRaw(null, jsonFilter.getRootJson());
				}
				jsonWr.endArray();
			}
		}

		@Override
		public void outputGroupToJson(String agentKey, SMTJsonWriter jsonWr) throws Exception
		{
			jsonWr.beginMap(null);
			{
				// 输出明细定义
				outputDetailHeadJson(agentKey, jsonWr);
				
				Set<String> setExistKey = new HashSet<>();
				List<Object[]> listRecs = new ArrayList<>();
				for(ASTMergeChart mergeChart : _listRecsValue)
				{
					for(DBRecord rec : mergeChart._recsValue.getRecords())
					{
						Object[] values = rec.getValues();
						String key = SMTStatic.toString(values[0]) + "\b" + SMTStatic.toString(values[1]);
						if(setExistKey.contains(key))
							continue;
						setExistKey.add(key);			
						
						listRecs.add(values);
					}
				}
				
				Collections.sort(listRecs, new Comparator<Object[]>() {
					@Override
					public int compare(Object[] o1, Object[] o2) 
					{
						return ((String)o1[0]).compareTo((String)o2[0]);
					}
					
				});
				
				// 查询数据
				jsonWr.beginArray("values");
				for(Object[] values : listRecs)
				{
					jsonWr.beginArray(null);
					{
						jsonWr.addKeyValue(null, values[0]);
						jsonWr.addKeyValue(null, values[1]);
						jsonWr.addKeyValue(null, values[2]);
					}
					jsonWr.endArray();
				}
				jsonWr.endArray();

			}
			jsonWr.endMap();			
		}
	}
	
	public void outputResultToJson(String jsonPath, ASTResult astResult, SMTJsonWriter jsonWr) throws Exception
	{
		// 将生成的cube进行组合
		List<ASTMergeGroup> listMergeGroup = mergeASTResult(astResult);
		
		// 输出组合后的cube
		for(ASTMergeGroup mergeGroup : listMergeGroup)
		{
			mergeGroup.outputGroupToJson(jsonPath, jsonWr);
		}

	}
	
	// main merge function
	private List<ASTMergeGroup> mergeASTResult(ASTResult astResult) throws Exception
	{
		List<ASTMergeGroup> listDetailMerge = new ArrayList<>();
		
		// 输出无维度summary查询结果
		mergeNoDimSummaryASTResult(astResult, listDetailMerge);
		
		// 输出无维度明细查询结果
		mergeNoDimASTResult(astResult, listDetailMerge);

		// 输出有维度的明细查询结果
		mergeHasDimASTResult(astResult, listDetailMerge);
		
		// 输出无维度的明细查询结果
		mergeFullDimASTRecord(astResult, listDetailMerge);
		
		return listDetailMerge;
	}
	
	private void mergeFullDimASTRecord(ASTResult astResult, List<ASTMergeGroup> listDetailMerge) throws Exception
	{
		for(ASTCubeRecs astCubeRecs : astResult._listRecordset)
		{
			if(astCubeRecs._recsType != ASTCubeRecsType.RECORD)
				continue;
			
			if(astCubeRecs._dimNames.size() == 0)
			{
				ASTMergeGroupTableNoDim  mergeGroup = new ASTMergeGroupTableNoDim();
				mergeGroup._posXColName = astCubeRecs._posXName;
				mergeGroup._posYColName = astCubeRecs._posYName;
				mergeGroup._devKeyColName = astCubeRecs._devKeyName;
				mergeGroup._title = astCubeRecs._title;
				mergeGroup._astCubeRecs = astCubeRecs;
				mergeGroup._listDimFilter = astCubeRecs._listDimFilter;
				listDetailMerge.add(mergeGroup);
			}
			else
			{
				ASTMergeGroupTableHasDim  mergeGroup = new ASTMergeGroupTableHasDim();
				mergeGroup._posXColName = astCubeRecs._posXName;
				mergeGroup._posYColName = astCubeRecs._posYName;
				mergeGroup._devKeyColName = astCubeRecs._devKeyName;
				mergeGroup._title = astCubeRecs._title;
				mergeGroup._astCubeRecs = astCubeRecs;
				mergeGroup._listDimFilter = astCubeRecs._listDimFilter;
				listDetailMerge.add(mergeGroup);
			}
		}
	}

	
	private void mergeNoDimSummaryASTResult(ASTResult astResult, List<ASTMergeGroup> listDetailMerge) throws Exception
	{
		ASTMergeGroupSummary mergeGroup = null;
		for(ASTCubeRecs astCubeRecs : astResult._listRecordset)
		{
			if(astCubeRecs._recsType != ASTCubeRecsType.SUMMARY)
				continue;
			
			if(mergeGroup == null)
			{
				mergeGroup = new ASTMergeGroupSummary();
				listDetailMerge.add(mergeGroup);
				mergeGroup._title = astCubeRecs._title;
			}
			
			mergeGroup._listCubeRecs.add(astCubeRecs);
		}
	}
	
	private void mergeHasDimASTResult(ASTResult astResult, List<ASTMergeGroup> listDetailMerge) throws Exception
	{
		for(ASTCubeRecs astCubeRecs : astResult._listRecordset)
		{
			if(astCubeRecs._recsType != ASTCubeRecsType.VALUE)
				continue;
			
			if(astCubeRecs._dimNames.size() > 0)
			{
				ASTMergeGroupDetail mergeGroup = new ASTMergeGroupDetail();
				listDetailMerge.add(mergeGroup);
				mergeGroup._title = astCubeRecs._title;

				ASTMergeChart mergeChart = new ASTMergeChart();
				mergeChart._recsValue = new DBRecords();
				mergeChart._recsValue.initColumn(new String[]{"time", "name", "value"});

				for(int i = 0; i < astCubeRecs._dimValues.size(); i ++)
				{
					ASTCubeRecsValue astCubeRecsValue = astCubeRecs._mapDimId2Recs.get(i);
					if(astCubeRecsValue == null || astCubeRecsValue._timeRange._timeField == null)
						continue;
					
					mergeChart._startTime = astCubeRecsValue._timeRange._startTime;
					mergeChart._chartType = astCubeRecsValue._chartType;
					for(DBRecord rec : astCubeRecsValue._recsValue.getRecords())
					{
						mergeChart._recsValue.addRecord(new Object[] {
							rec.getString(astCubeRecsValue._timeRange._timeField),
							astCubeRecsValue._title,
							rec.getString(astCubeRecsValue._groupField),
						});
					}
				}
				
				if(mergeChart._recsValue != null)
					mergeGroup._listRecsValue.add(mergeChart);
			}
		}
	}
	
	private void mergeNoDimASTResult(ASTResult astResult, List<ASTMergeGroup> listDetailMerge) throws Exception
	{
		ASTMergeGroupDetail mergeGroup = null;
		Date mergeTime = null;
		for(ASTCubeRecs astCubeRecs : astResult._listRecordset)
		{
			if(astCubeRecs._recsType != ASTCubeRecsType.VALUE)
				continue;
			
			if(astCubeRecs._dimNames.size() == 0)
			{
				ASTCubeRecsValue astCubeRecsValue = astCubeRecs._mapDimId2Recs.get(-1);
				Date[] curTime = new Date[1];
				
				// stCubeRecs.isSameStartTime必须放第一个，因为要取值
				if(!astCubeRecs.isSameStartTime(mergeTime, curTime) || mergeGroup == null || !mergeGroup._title.equals(astCubeRecs._title))
				{
					mergeTime = curTime[0];
					mergeGroup = new ASTMergeGroupDetail();
					mergeGroup._title = astCubeRecs._title;
					listDetailMerge.add(mergeGroup);
				}
				
				ASTMergeChart mergeChart = new ASTMergeChart();
				mergeGroup._listRecsValue.add(mergeChart);
				
				// 添加时间过滤
				if(!astCubeRecs._isRawRS)
				{
					{
						SMTJsonWriter jsonFilter = mergeGroup.prepareFilterJson("time_range_1");
						jsonFilter.addKeyValue("type", "time_range");
						jsonFilter.addKeyValue("update", "set");
						jsonFilter.addKeyValue("title", "时间范围");
						jsonFilter.addKeyValue("start_value", astCubeRecsValue._timeRange._startTime);
						jsonFilter.addKeyValue("end_value", astCubeRecsValue._timeRange._endTime);

						long deltaDays = (astCubeRecsValue._timeRange._endTime.getTime() - astCubeRecsValue._timeRange._startTime.getTime()) / 1000 / 24 / 3600 - 60;
						jsonFilter.addKeyValue("time_step", deltaDays > 0 ? "month" : "day");

						
						jsonFilter.beginArray("start_path");
						{
							jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathStartTime);
						}
						jsonFilter.endArray();
						
						jsonFilter.beginArray("end_path");
						{
							jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathEndTime);		
						}
						jsonFilter.endArray();
					}
					
					if(astCubeRecsValue._timeRange._title2 != null)
					{
						if(astCubeRecsValue._timeRange._startTime.equals(astCubeRecsValue._timeRange._startTime2))
						{
							SMTJsonWriter jsonFilter = mergeGroup.prepareFilterJson("time_range_1");
							
							jsonFilter.beginArray("start_path");
							{
								jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathStartTime2);
							}
							jsonFilter.endArray();
							
							jsonFilter.beginArray("end_path");
							{
								jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathEndTime2);		
							}
							jsonFilter.endArray();	
						}
						else
						{
							SMTJsonWriter jsonFilter = mergeGroup.prepareFilterJson("time_range_2");
							jsonFilter.addKeyValue("type", "time_range");
							jsonFilter.addKeyValue("update", "set");
							jsonFilter.addKeyValue("title", "时间范围");
							jsonFilter.addKeyValue("start_value", astCubeRecsValue._timeRange._startTime2);
							jsonFilter.addKeyValue("end_value", astCubeRecsValue._timeRange._endTime2);

							long deltaDays = (astCubeRecsValue._timeRange._endTime.getTime() - astCubeRecsValue._timeRange._startTime.getTime()) / 1000 / 24 / 3600 - 60;
							jsonFilter.addKeyValue("time_step", deltaDays > 0 ? "month" : "day");
							
							jsonFilter.beginArray("start_path");
							{
								jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathStartTime2);
							}
							jsonFilter.endArray();
							
							jsonFilter.beginArray("end_path");
							{
								jsonFilter.addKeyValue(null, astCubeRecsValue._timeRange._pathEndTime2);		
							}
							jsonFilter.endArray();							
						}
					}
					
					if(astCubeRecsValue._timeRange._pathTimeSteps != null)
					{
						SMTJsonWriter jsonFilter = mergeGroup.prepareFilterJson("time_step");
						jsonFilter.addKeyValue("type", "time_step");
						jsonFilter.addKeyValue("update", "set");
						jsonFilter.addKeyValue("title", "步长");
						jsonFilter.addKeyValue("step_value", astCubeRecsValue._timeRange._timeStep);
						jsonFilter.beginArray("step_path");
						{
							for(String path : astCubeRecsValue._timeRange._pathTimeSteps)
							{
								jsonFilter.addKeyValue(null, path);
							}
						}	
						jsonFilter.endArray();
					}
				}
				
				mergeChart._startTime = astCubeRecsValue._timeRange._startTime;
				mergeChart._chartType = astCubeRecsValue._chartType;
				mergeChart._recsValue = new DBRecords();
				mergeChart._recsValue.initColumn(new String[]{"time", "name", "value"});
				for(DBRecord rec : astCubeRecsValue._recsValue.getRecords())
				{
					mergeChart._recsValue.addRecord(new Object[] {
						rec.getString(astCubeRecsValue._timeRange._timeField),
						astCubeRecsValue._title,
						rec.getString(astCubeRecsValue._groupField),
					});
				}
			}
		}


	}
}