package com.moral.service.impl;

import java.text.ParseException;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import com.moral.entity.Sensor;
import com.moral.mapper.AlarmDailyMapper;
import com.moral.mapper.SensorMapper;
import com.moral.service.AlarmDailyService;
import com.moral.service.HistoryMinutelyService;

@Service
@SuppressWarnings({ "rawtypes", "unchecked" })
public class AlarmDailyServiceImpl implements AlarmDailyService {

	@Resource
	private AlarmDailyMapper alarmDailyMapper;

	@Resource
	private SensorMapper sensorMapper;

	@Resource
	private HistoryMinutelyService historyMinutelyService;

	@Override
	public Map getPieData(Map<String, Object> parameters) {
		Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
		try {
			historyMinutelyService.convertQueryParam(parameters);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		List<Map<String, Object>> alarmDatas = alarmDailyMapper.getAlarmData(parameters);
		Object dimension = parameters.get("dimension");
		if ("monitorPoint".equals(dimension)) {
			for (Map<String, Object> alarmData : alarmDatas) {
				String name = alarmData.remove("name").toString();
				alarmData.remove("sum");
				for (Map.Entry<String, Object> entry : alarmData.entrySet()) {
					String key = entry.getKey();
					Object value = entry.getValue().toString();
					if (!"0".equals(value)) {
						List list;
						Map<String, Object> map = new HashMap<String, Object>();
						if (ObjectUtils.isEmpty(resultMap.get(key))) {
							list = new ArrayList();
						} else {
							list = (List) resultMap.get(key);
						}
						map.put("name", name);
						map.put("value", value);
						list.add(map);
						resultMap.put(key, list);
					}
				}
			}
		} else {
			Map<String, Object> alarmData = alarmDatas.get(0);
			List<String> sensors = (List<String>) parameters.get("sensors");
			List list = new ArrayList();
			if (!ObjectUtils.isEmpty(alarmData)) {
				for (String key : alarmData.keySet()) {
					for (String sensor : sensors) {
						String[] split = sensor.split("-");
						if (key.equals(split[0]) && !"0".equals(alarmData.get(key).toString())) {
							Map<String, Object> map = new HashMap<String, Object>();
							if (parameters.containsKey("description")) {
								map.put("name", split[3]);
							} else {
								map.put("name", split[1]);
							}
							map.put("value", alarmData.get(key));
							list.add(map);
						}
					}
				}
			}
			resultMap.put("list", list);
		}
		return resultMap;
	}

	@Override
	public List<Integer> getAlarmDataByYear(Map<String, Object> parameters) {
		LocalDate localDate = LocalDate.now();
		parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfYear()));
		parameters.put("end", localDate.with(TemporalAdjusters.firstDayOfNextYear()));
		parameters.put("sensorKeys",
				sensorMapper.selectAll().stream().map(sensor -> sensor.getSensorKey()).collect(Collectors.toList()));
		List<Map<String, Object>> list = alarmDailyMapper.getAlarmDataByYear(parameters);
		Integer[] result = new Integer[12];
		for (int i = 0; i < result.length; i++) {
			if (ObjectUtils.isEmpty(list)) {
				break;
			}
			for (Map<String, Object> map : list) {
				Integer month = Integer.valueOf(map.get("time").toString().substring(5));
				if (i + 1 < month) {
					break;
				} else if (i + 1 == month) {
					result[i] = Integer.valueOf(map.get("sum").toString());
					list.remove(map);
					break;
				}
			}
		}
		return Arrays.asList(result);
	}

	@Override
	public List<Map<String, Object>> getAlarmDataByMonth(Map<String, Object> parameters) {
		LocalDate localDate = LocalDate.now();
		List<Sensor> sensors = sensorMapper.selectAll();
//		Iterator<Sensor> iterator = sensors.iterator();
//		while (iterator.hasNext()) {
//			if ("warn".equals(iterator.next().getSensorKey())) {
//				iterator.remove();
//			}
//		}
		parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfMonth()));
		parameters.put("end", localDate.with(TemporalAdjusters.firstDayOfNextMonth()));
		parameters.put("sensors", sensors);
		Map<String, Object> map = alarmDailyMapper.getAlarmDataByMonth(parameters);
		List<Entry<String, Object>> list = new ArrayList<Entry<String,Object>>(map.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String, Object>>() {
			@Override
			public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
				if (o2.getValue().equals(o1.getValue())) {
					return o1.getKey().compareTo(o2.getKey());
					//return Integer.compare(Integer.valueOf(o1.getKey().replace("e", "")),Integer.valueOf(o2.getKey().replace("e", "")));
				} else {
					return Integer.valueOf(o2.getValue().toString()).compareTo(Integer.valueOf(o1.getValue().toString()));
				}
			}
		});
		List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();
		for (Entry<String, Object> entry : list) {
			for (Sensor sensor : sensors) {
				if (!entry.getValue().toString().equals("0") && entry.getKey().equals(sensor.getSensorKey())) {
					Map<String, Object> map2 = new HashMap<String, Object>();
					map2.put(sensor.getDescription(), entry.getValue());
					resultList.add(map2);
					sensors.remove(sensor);
					break;
				}
			}
		}

		return resultList;
	}

}