package com.moral.monitor.service.impl;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
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 org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import com.moral.monitor.dao.AccountEntityMapper;
import com.moral.monitor.dao.HistoryEntityMapper;
import com.moral.monitor.entity.AccountEntity;
import com.moral.monitor.entity.AccountEntityExample;
import com.moral.monitor.service.OrganizationService;
import com.moral.monitor.service.ScreenService;
import com.moral.monitor.util.BusinessException;
import com.moral.monitor.util.ResourceUtil;

@Service
@SuppressWarnings("unused")
public class ScreenServiceImpl implements ScreenService {

	@Autowired
	private AccountEntityMapper accountMapper;

	@Autowired
	private HistoryEntityMapper historyMapper;

	@Autowired
	private OrganizationService organizationService;

	public List<AccountEntity> getAccountLists(String account, String password) {
		AccountEntityExample example = new AccountEntityExample();
		example.or().andAccountEqualTo(account).andPasswordEqualTo(password);
		return accountMapper.selectByExample(example);
	}

	public Map<String, Object> getMonthDataByEquipment(final Map<String, Object> parameters) throws Exception {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		// 1.0 实际标准值
		resultMap.put("standard", ResourceUtil.getValue(parameters.get("macKey") + "-standard"));

		// 2.0 AQI 指数
		Date date = new Date();
		// 昨日00:00:00
		parameters.put("start", DateUtils.truncate(DateUtils.addDays(date, -1), Calendar.DATE));
		// 今日00:00:00
		parameters.put("end", DateUtils.truncate(date, Calendar.DATE));
		String[] macKeys = { "e1", "e2", "e10", "e11", "e15", "e16" };
		final String[] IAQIValues = ResourceUtil.getArrValue("IAQI");
		ExecutorService threadPool = Executors.newCachedThreadPool();
		CompletionService<Double> cs = new ExecutorCompletionService<Double>(threadPool);
		for (final String macKey : macKeys) {
			cs.submit(new Callable<Double>() {
				@Override
				public Double call() throws Exception {
					Double result = null;
					double avg = 0, minMacKey = 0, maxMacKey = 0, minIAQI = 0, maxIAQI = 0;
					Map<String, Object> map = new HashMap<String, Object>(parameters);
					map.put("macKey", macKey);
					Map<String, Object> average = historyMapper.getMonthAverageBySensor(map);
					if (!ObjectUtils.isEmpty(average)) {
						avg = (Double) average.get("average");
						String[] macKeyValues = ResourceUtil.getArrValue(macKey);
						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) {
							result = 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]);
							result = calculateIAQI(maxIAQI, minIAQI, maxMacKey, minMacKey, avg);
						}
					}
					return result;
				}
			});
		}

		// 3.0 本月平均值
		Map<String, Object> average = null;
		Map<String, Object> map = new HashMap<String, Object>(parameters);
		// 每月一日的数据取上月的数据
		if (1 == Calendar.getInstance().get(Calendar.DAY_OF_MONTH)) {
			// 上个月1日00:00:00
			map.put("start", DateUtils.truncate(DateUtils.addMonths(date, -1), Calendar.MONTH));
		} else {
			// 这个月1日00:00:00
			map.put("start", DateUtils.truncate(date, Calendar.MONTH));
		}
		average = historyMapper.getMonthAverageBySensor(map);
		if (ObjectUtils.isEmpty(average)) {
			resultMap.put("average", "N/A");
		} else {
			resultMap.put("average", String.format("%.2f", average.get("average")));
		}
		
		List<Double> IAQIs = new ArrayList<Double>();
		for (String macKey : macKeys) {
			IAQIs.add(cs.take().get());
		}
		
		if (ObjectUtils.isEmpty(IAQIs)) {
			resultMap.put("AQI", "N/A");
		} 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, Object> getAverageByAll(Map<String, Object> parameters) {
		Map<String, Object> result = new LinkedHashMap<String, Object>();

		setOrgIdsByAccount(parameters);
		parameters.put("macKey", "all");
		Date date = new Date();
		// 当前时间 -10分钟
		parameters.put("start", DateUtils.addMinutes(date, -10));
		// 当前时间 -5分钟
		parameters.put("end", DateUtils.addMinutes(date, -5));
		List<Map<String, Object>> averageByAll = historyMapper.getAverageByAll(parameters);

		for (Map<String, Object> map : averageByAll) {
			result.put((String) map.get("mac_key"), map.get("avg"));
		}
		return result;
	}

	@Override
	public Map<String, Object> getEquipmentStates(Map<String, Object> parameters) {
		Map<String, Object> result = new HashMap<String, Object>();
		setOrgIdsByAccount(parameters);
		List<Map<String, Object>> list = historyMapper.getEquipmentStates(parameters);
		Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
		for (Map<String, Object> map : list) {
			Long count = (Long) map.get("count");
			all += count;
			switch ((Integer) map.get("state")) {
			case 0:
				normal = count;
				break;
			case 4:
				stop = count;
				break;
			default:
				abnormal += count;
			}
		}
		result.put("all", all);
		result.put("normal", normal);
		result.put("abnormal", abnormal);
		result.put("stop", stop);
		return result;
	}

	public void setOrgIdsByAccount(Map<String, Object> parameters) {
		String accountId = (String) parameters.get("accountId");
		if (!StringUtils.isNumeric((String) parameters.get("accountId"))) {
			throw new BusinessException("accountId 参数不合法！");
		}

		AccountEntity account = accountMapper.selectByPrimaryKey((Integer.valueOf(accountId)));
		if (ObjectUtils.isEmpty(account)) {
			throw new BusinessException(accountId + "该账号不存在！");
		}
		String orgId = account.getOrganization();
		// 不是摩瑞尔账号的需要根据组织来获取数据权限
		
		if (!("-1".equals(orgId) || ResourceUtil.getValue("orgId").equals(orgId))) {
			Set<String> orgIds = organizationService.getChildOrganizationIds(orgId);
			parameters.put("orgIds", orgIds);
		}
	}

	private double calculateIAQI(double maxIAQI, double minIAQI, double maxMacKey, double minMacKey, double avg) {
		return (maxIAQI - minIAQI) * (avg - minMacKey) / (maxMacKey - minMacKey) + minIAQI;
	}

	@Override
	public Map<String, Object> getAverageBySensor(Map<String, Object> parameters) {
		Map<String, Object> result = new LinkedHashMap<String, Object>();

		setOrgIdsByAccount(parameters);
		Date date = new Date();
		// 当前时间 -1小时
		parameters.put("start", DateUtils.addHours(date, -1));
		parameters.put("end", date);
		List<Map<String, Object>> averageByAll = historyMapper.getAverageByAll(parameters);

		for (Map<String, Object> map : averageByAll) {
			result.put((String) map.get("name"), map.get("avg"));
		}
		return result;
	}

}