package com.moral.service.impl;

import java.util.*;

import javax.annotation.Resource;

import com.moral.common.bean.Constants;
import com.moral.common.bean.PageBean;
import com.moral.common.util.ExampleUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import com.github.pagehelper.PageHelper;
import com.moral.common.util.ValidateUtil;
import com.moral.entity.Device;
import com.moral.mapper.DeviceMapper;
import com.moral.service.AccountService;
import com.moral.service.DeviceService;
import tk.mybatis.mapper.entity.Example;

@Service
public class DeviceServiceImpl implements DeviceService {

	@Resource
	private DeviceMapper deviceMapper;

	@Resource
	private AccountService accountService;
    private Class ENTITY_CLASS = Device.class;
	@Override
	public Map<String, Object> getDeviceStatesByAccount(Map<String, Object> parameters) {
		ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");
		Map<String, Object> result = new HashMap<String, Object>();
		accountService.setOrgIdsByAccount(parameters);
		List<Map<String, Object>> list = deviceMapper.getDeviceStatesByAccount(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.valueOf((String) 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;
	}
	
	@Override
	@Transactional
	public void saveOrUpdateDevice(Device device) {
		ValidateUtil.notNull(device, "param.is.null");
		ValidateUtil.notEmpty(device.getMac(), "param.is.null");
		Device queryDevice = new Device();
		queryDevice.setMac(device.getMac());
		queryDevice = deviceMapper.selectOne(queryDevice);
		Date operateDate = new Date();
		device.setInstallTime(operateDate);
		if (ObjectUtils.isEmpty(queryDevice)) {
			device.setCreateTime(operateDate);
			device.setState("4");
			device.setIsDelete(Constants.IS_DELETE_FALSE);
			deviceMapper.insertSelective(device);
		}else {
			device.setId(queryDevice.getId());
			deviceMapper.updateByPrimaryKeySelective(device);
		}
	}

	@Override
	public List<Device> getInstallDevicesByOperateUser(Integer uid, Integer pageIndex, Integer pageSize) {
		ValidateUtil.notNull(uid, "param.is.null");
		Device device = new Device();
		device.setOperateUserId(uid);
		PageHelper.startPage(pageIndex, pageSize);
		List<Device> devices = deviceMapper.select(device);
		return devices;
	}

	@Override
	public Device getDeviceByMac(String mac) {
		ValidateUtil.notEmpty(mac, "param.is.null");
		Device device = new Device();
		device.setMac(mac);
		device = deviceMapper.selectOne(device);
		return device;
	}

	@Override
	public PageBean queryByPageBean(PageBean pageBean) {
		Example example = ExampleUtil.generateExample(ENTITY_CLASS,pageBean);
		List<Example.Criteria> criteriaList = example.getOredCriteria();
		if(criteriaList!=null&&criteriaList.size()>0){
			for(Example.Criteria cri : criteriaList){
				cri.andNotEqualTo("isDelete", Constants.IS_DELETE_TRUE);
			}
		}else {
			example.or().andNotEqualTo("isDelete",Constants.IS_DELETE_TRUE);
		}
		if(pageBean.getPageSize()>0){
			PageHelper.startPage(pageBean.getPageIndex(),pageBean.getPageSize());
		}
		List<Device> organizationList = deviceMapper.selectWithRelationData(example);
		return new PageBean(organizationList);
	}

	@Override
	public void deleteByIds(Integer[] ids) {
		Device device = new Device();
		device.setIsDelete(Constants.IS_DELETE_TRUE);
		if(ids!=null&&ids.length>0){
			if(ids.length==1){
				device.setId(ids[0]);
				deviceMapper.updateByPrimaryKeySelective(device);
			}else{
				Example example = new Example(ENTITY_CLASS);
				example.or().andIn("id", Arrays.asList(ids));
				deviceMapper.updateByExampleSelective(device,example);
			}

		}
	}

	@Override
	public void addOrModify(Device device){
		try{
			if(device.getId()==null){
				device.setIsDelete(Constants.IS_DELETE_FALSE);
				deviceMapper.insertSelective(device);
			}else{
				deviceMapper.updateByPrimaryKeySelective(device);
			}
		}
		catch (Exception ex){
			throw  ex;
		}
	}

	@Override
	public List<Device> getDevicesByMonitorPointId(Integer monitorPointId) {
		Device device = new Device();
		device.setMonitorPointId(monitorPointId);
		device.setIsDelete(Constants.IS_DELETE_FALSE);
		return deviceMapper.select(device);
	}

}