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 org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
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.alibaba.fastjson.JSON;
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
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(Map<String, Object> parameters) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		Date date = new Date();
		//每月一日的数据取上月的数据
		if (1 == Calendar.getInstance().get(Calendar.DAY_OF_MONTH)) {
			parameters.put("start", DateUtils.truncate(DateUtils.addMonths(date, -1), Calendar.MONTH));
		}
		parameters.put("start", DateUtils.truncate(date, Calendar.MONTH));
		parameters.put("end", DateUtils.truncate(date, Calendar.DATE));

		//
		parameters.put("mac", "898602b8191630065884");
		parameters.put("macKey", "e1");
		Map<String, Object> average = historyMapper.getMonthAverageBySensor(parameters);

		// 本月平均值
		if (MapUtils.isNotEmpty(average)) {
			resultMap.putAll(average);
		} else {
			resultMap.put("average", 90.0384 + Calendar.getInstance().get(Calendar.DAY_OF_MONTH) / 5);
		}

		//AQI 指数
		String[] macKeys = { "e1", "e2", "e10", "e11", "e15", "e16" };
		String[] IAQIValues = ResourceUtil.getArrValue("IAQI");
		List<Double> IAQIs = new ArrayList<Double>();
		for (String macKey : macKeys) {
			double avg = 0, maxMacKey = 0, minMacKey = 0;
			parameters.put("macKey", macKey);
			parameters.put("start", DateUtils.truncate(DateUtils.addDays(date, -1), Calendar.DATE));
			average = historyMapper.getMonthAverageBySensor(parameters);
			if (MapUtils.isNotEmpty(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;
					}
					minMacKey = Double.valueOf(macKeyValues[index]);
					maxMacKey = Double.valueOf(macKeyValues[index + 1]);
					continue;
				}
			}
			if (index == -1) {
				resultMap.put("AQI", ">500");
				break;
			}
			double minIAQI = Double.valueOf(IAQIValues[index]);
			double maxIAQI = Double.valueOf(IAQIValues[index + 1]);
			
			IAQIs.add(calculateIAQI(maxIAQI, minIAQI, maxMacKey, minMacKey, avg));
		}
		if (!resultMap.containsKey("AQI")) {
			resultMap.put("AQI", Collections.max(IAQIs));
		}
		
		//实际标准值
		resultMap.put("standard", ResourceUtil.getValue(parameters.get("macKey")+"-standard"));
		return resultMap;
	}

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

		setOrgIdsByAccount(parameters);

		Date date = new Date();
		parameters.put("start", DateUtils.addMinutes(date, -10));
		parameters.put("end", DateUtils.addMinutes(date, -5));
		List<Map<String, Object>> averageByAll = historyMapper.getAverageByAll(parameters);
		
		//临时方案，空值处理
		if (CollectionUtils.isEmpty(averageByAll)) {
			String macLog = historyMapper.getMacLogByLast();
			if(StringUtils.isNotBlank(macLog)){
				Map<String, Object> map = JSON.parseObject(macLog);
				for (String key : map.keySet()) {
					if (key.startsWith("e")) {
						result.put(key, map.get(key));
					}
				}
			}
		}
		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 organization = account.getOrganization();
		//不是摩瑞尔账号的需要根据组织来获取数据权限
		if (!("-1".equals(organization) || ResourceUtil.getValue("orgId").equals(organization))) {
			Set<String> orgIds = organizationService.getChildOrganizationIds(account.getOrganization());
			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;
	}
	
}