package com.moral.service.impl;

import static org.apache.commons.lang3.time.DateUtils.addDays;
import static org.apache.commons.lang3.time.DateUtils.truncate;
import static org.springframework.util.ObjectUtils.isEmpty;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.annotation.Resource;

import org.apache.commons.lang3.time.DateUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import com.moral.common.util.CalculateUtils;
import com.moral.common.util.ResourceUtil;
import com.moral.common.util.ValidateUtil;
import com.moral.entity.Device;
import com.moral.mapper.HistoryMinutelyMapper;
import com.moral.mapper.DeviceMapper;
import com.moral.mapper.SensorMapper;
import com.moral.service.HistoryMinutelyService;

@Service
public class HistoryMinutelyServiceImpl implements HistoryMinutelyService {

	@Resource
	private HistoryMinutelyMapper historyMinutelyMapper;

	@Resource
	private DeviceMapper deviceMapper;

	@Resource
	private SensorMapper sensorMapper;

	private Set<String> sensorKeys = new HashSet<String>();

	@Override
	public Map<String, Object> getDayAQIByDevice(Map<String, Object> parameters) {
		ValidateUtil.notNull(parameters.get("mac"), "param.is.null");
		Date date = new Date();
		// 昨日00:00:00
		parameters.put("start", truncate(addDays(date, -1), Calendar.DATE));
		// 今日00:00:00
		parameters.put("end", truncate(date, Calendar.DATE));
		Map<String, Double> average = historyMinutelyMapper.getDayAQIByDevice(parameters);
		return getAQIByDataMap(average);
	}

	private Map<String, Object> getAQIByDataMap(Map<String, Double> average) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		if (isEmpty(average)) {
			resultMap.put("AQI", "N/V");
		} else {
			String[] IAQIValues = ResourceUtil.getArrValue("IAQI");
			Set<Double> IAQIs = new HashSet<Double>();
			for (Map.Entry<String, Double> entry : average.entrySet()) {
				double minMacKey = 0, maxMacKey = 0, minIAQI = 0, maxIAQI = 0;
				String[] macKeyValues = ResourceUtil.getArrValue(entry.getKey());
				Double avg = entry.getValue();
				if (isEmpty(avg)) {
					IAQIs.add(null);
				} else {
					int index = -1;
					for (int i = 0; i < macKeyValues.length; i++) {
						if (avg <= Double.valueOf(macKeyValues[i])) {
							if (i == 0) {
								index = i;
							} else {
								index = i - 1;
							}
							break;
						}
					}
					if (index == -1) {
						IAQIs.add(Double.MAX_VALUE);
					} else {
						minMacKey = Double.valueOf(macKeyValues[index]);
						maxMacKey = Double.valueOf(macKeyValues[index + 1]);
						minIAQI = Double.valueOf(IAQIValues[index]);
						maxIAQI = Double.valueOf(IAQIValues[index + 1]);
						Double result = CalculateUtils.calculateIAQI(maxIAQI, minIAQI, maxMacKey, minMacKey, avg);
						IAQIs.add(result);
					}
				}
			}
			IAQIs.remove(null);
			if (isEmpty(IAQIs)) {
				resultMap.put("AQI", "N/V");
			} else {
				Double AQI = Collections.max(IAQIs);
				if (AQI == Double.MAX_VALUE) {
					resultMap.put("AQI", IAQIValues[IAQIValues.length - 1]);
				} else {
					resultMap.put("AQI", String.format("%.0f", AQI));
				}
			}
		}
		return resultMap;
	}

	public Map<String, List<Object>> getMonitorPointOrDeviceAvgData4Compare(Map<String, Object> parameters) throws Exception {
		Map<String, List<Object>> resultMap = new HashMap<String, List<Object>>();
		if (ObjectUtils.isEmpty(parameters)) {
			resultMap.put("c", null);
			return resultMap;
		}
		List<Map<String, Object>> resultList = getMonitorPointOrDeviceAvgData(parameters);
		
		List<Object> timeList = new ArrayList<Object>();
		List<Object> dataList = new ArrayList<Object>();
		String sensorKey = (String) parameters.get("sensorKey");
		for (Map<String, Object> map : resultList) {
			String time = map.get("time").toString();
			time =time.substring(time.length() - 2);
			timeList.add(time);
			dataList.add(map.get(sensorKey));
		}
		String part = (String) parameters.get("part");
		resultMap.put("time" + part, timeList);
		resultMap.put("data" + part, dataList);
		return resultMap;
	}
	
	@Override
	public Map<String, List<Object>> getCompareReport(Map<String, Object> parameters) throws Exception {
		Map<String, List<Object>> resultMap = new HashMap<String, List<Object>>();
		Map<String, Object> parametersA = new HashMap<String, Object>();
		Map<String, Object> parametersB = new HashMap<String, Object>();
		if (parameters.containsKey("time") && parameters.containsKey("monitorPoint")) {
			parametersA.put("part", "A");
			parametersA.putAll(parameters);
			parametersA.remove("timeb");
		}
		if (parameters.containsKey("timeb") && parameters.containsKey("monitorPointb")) {
			parametersB.putAll(parameters);
			parametersB.put("part", "B");
			parametersB.put("time", parametersB.get("timeb"));
			parametersB.put("monitorPoint", parametersB.get("monitorPointb"));
			if (parameters.containsKey("macb")) {
				parametersB.put("mac", parametersB.get("macb"));
			}
			parametersB.remove("timeb");
		}
		List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
		list.add(parametersA);
		list.add(parametersB);
		ExecutorService threadPool = Executors.newCachedThreadPool();
		CompletionService<Map<String, List<Object>>> cs = new ExecutorCompletionService<Map<String, List<Object>>>(threadPool);
		for (Map<String, Object> map : list) {
			cs.submit(new Callable<Map<String, List<Object>>>() {
				@Override
				public Map<String, List<Object>> call() throws Exception {
					return getMonitorPointOrDeviceAvgData4Compare(map);
				}
			});
			
		}
		for (Map<String, Object> map : list) {
			resultMap.putAll(cs.take().get());
		}
		if (resultMap.containsKey("timeA") && resultMap.containsKey("timeB")) {
			List<Object> timeA = resultMap.get("timeA");
			List<Object> timeB = resultMap.get("timeB");
			List<Object> time = new ArrayList<Object>(timeA);
			List<Object> time1 = new ArrayList<Object>(timeB);
			List<Object> dataA = resultMap.get("dataA");
			List<Object> dataB = resultMap.get("dataB");
			List<Object> resultA = new ArrayList<Object>();
			List<Object> resultB = new ArrayList<Object>();
			time1.removeAll(time);
			time.addAll(time1);
			time.sort(new Comparator<Object>() {
				@Override
				public int compare(Object o1, Object o2) {
					return Integer.compare(Integer.valueOf(o1.toString()), Integer.valueOf(o2.toString()));
				}
			});
			for (int i = 0; i < time.size(); i++) {
				Object object = time.get(i);
				int indexA = timeA.indexOf(object);
				if (indexA > -1) {
					resultA.add(i, dataA.get(indexA));
				}else {
					resultA.add("-");
				}
				int indexB = timeB.indexOf(object);
				if (indexB > -1) {
					resultB.add(i, dataB.get(indexB));
				}else {
					resultB.add("-");
				}
			}
			resultMap.put("dataA", resultA);
			resultMap.put("dataB", resultB);
			resultMap.put("time", time);
		} else if (resultMap.containsKey("timeA")) {
			resultMap.put("time", resultMap.get("timeA"));
		} else {
			resultMap.put("time", resultMap.get("timeB"));
		}
		return resultMap;
	}

	
	@Override
	public List<Map<String, Object>> getMonitorPointOrDeviceAvgData(Map<String, Object> parameters) throws Exception {
		List<Map<String, Object>> resul ;

		String type = (String) parameters.get("type");
		String time = (String) parameters.get("time");
		String format = (String) parameters.get("format");
		Date start = DateUtils.parseDate(time, format), end = null ;
		if (parameters.containsKey("timeb")) {
			end = DateUtils.parseDate((String)parameters.get("timeb"), format);
		} else {
			switch (type) {
			case "year":
				end = DateUtils.addYears(start, 1);
				break;
			case "month":
				end = DateUtils.addMonths(start, 1);
				break;
			case "day":
				end = DateUtils.addDays(start, 1);
				break;
			case "hour":
				end = DateUtils.addHours(start, 1);
				break;
			}
			
		}
		parameters.put("start", start);
		parameters.put("end", end);

		if (parameters.containsKey("sensorKey")) {
			String sensorKey = (String) parameters.get("sensorKey");
			String sensorKeyColumn = "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
			parameters.put("sensorKeyColumn", sensorKeyColumn);
		}

		if (!parameters.containsKey("mac")) {
			resul = new ArrayList<Map<String,Object>>();
			Integer monitorPointId = Integer.valueOf((String) parameters.get("monitorPoint"));
			List<Map<String, Object>> deviceVersions = deviceMapper.getDeviceVersionIdByMonitorPoint(monitorPointId);
			ExecutorService threadPool = Executors.newCachedThreadPool();
			CompletionService<List<Map<String, Object>>> cs = new ExecutorCompletionService<List<Map<String, Object>>>(threadPool);
			List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
			for (Map<String, Object> map : deviceVersions) {
				cs.submit(new Callable<List<Map<String, Object>>>() {
					@Override
					public List<Map<String, Object>> call() throws Exception {
						Map<String, Object> parameter = new HashMap<String, Object>(parameters);
						Integer deviceVersionId = (Integer) map.get("deviceVersionId");
						if (!parameter.containsKey("sensorKeyColumn")) {
							List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(deviceVersionId);
							String sensorKeyColumn = getSensorKeyColumnBySensors(sensors);
							parameter.put("sensorKeyColumn", sensorKeyColumn);
							parameters.put("sensors", sensorKeys);
						}
						List<String> macs = deviceMapper.getDeviceMacByMonitorPointAndDeviceVersion(monitorPointId, deviceVersionId);
						if (ObjectUtils.isEmpty(macs) || macs.contains("null") ) {
							return new ArrayList<Map<String,Object>>();
						}else {
							parameter.put("macs", macs);
							return historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameter);
						}
					}
				});
			}
			for (Map<String, Object> map : deviceVersions) {
				list.addAll(cs.take().get());
			}
			Map<String, Map<String, Number[]>> result = new LinkedHashMap<String, Map<String, Number[]>>();
			for (Map<String, Object> map : list) {
				time = (String) map.get("time");
				map.remove("time");
				Map<String, Number[]> times = new HashMap<String, Number[]>();
				if (result.containsKey(time)) {
					times = (Map<String, Number[]>) result.get(time);
				} 
				for (Map.Entry<String,Object> entry  : map.entrySet()) {
					String sensorKey = entry.getKey();
					Number[] doubles = new Number[3];
					Double sum = (Double) entry.getValue();
					Integer count = 1;
					if (times.containsKey(sensorKey)) {
						doubles = times.get(sensorKey);
						sum = (Double) doubles[0] + sum;
						count = (Integer) doubles[1] + 1;
					} 
					doubles[0] = sum;
					doubles[1] = count;
					doubles[2] = new BigDecimal(sum / count).setScale(3, RoundingMode.HALF_UP).doubleValue();
					times.put(sensorKey, doubles);
				}
				result.put(time, times);
			}
			Iterator<Entry<String, Map<String, Number[]>>> iterator = result.entrySet().iterator();
			while(iterator.hasNext()){  
				Entry<String, Map<String, Number[]>> entry = iterator.next();
				String resultTime = entry.getKey();
				Map<String, Number[]> value = entry.getValue();
				Map<String, Object> resultMap = new HashMap<String, Object>();
				resultMap.put("time", resultTime);
				for (String sensorKey : value.keySet()) {
					resultMap.put(sensorKey, value.get(sensorKey)[2]);
				}
				resul.add(resultMap);
			}
			
		} else {
			if (!parameters.containsKey("sensorKeyColumn")) {
				String mac = (String) parameters.get("mac");
				Device device = new Device();
				device.setMac(mac);
				device = deviceMapper.selectOne(device);
				List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(device.getDeviceVersionId());
				String sensorKeyColumn = getSensorKeyColumnBySensors(sensors);
				parameters.put("sensorKeyColumn", sensorKeyColumn);
				parameters.put("sensors", sensorKeys);
				
			}
			resul = historyMinutelyMapper.getMonitorPointOrDeviceAvgData(parameters);
		}
		return resul;
	}

	private String getSensorKeyColumnBySensors(List<Map<String, Object>> sensors) {
		String sensorKeyColumn = "";
		for (int i = 0; i < sensors.size(); i++) {
			String sensorKey = (String) sensors.get(i).get("sensor_key");
			String name = (String) sensors.get(i).get("name");
			if (i == sensors.size() - 1) {
				sensorKeyColumn += "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey;
			} else {
				sensorKeyColumn += "AVG(json -> '$." + sensorKey + "[0]') " + sensorKey + ",";
			}
			sensorKeys.add(sensorKey + "-" + name);
		}
		return sensorKeyColumn;
	}

}