package com.ld.igds.view.manager;

import com.ld.igds.common.CoreSerService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.RedisConst;
import com.ld.igds.grain.dto.GrainSerCableData;
import com.ld.igds.io.RemoteCommonService;
import com.ld.igds.io.RemoteManager;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.BaseRequest;
import com.ld.igds.io.request.GrainSerConfRequest;
import com.ld.igds.io.response.BaseResponse;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 系统管理-粮情分机管理
 *
 * @author andy.jia
 */
@Component(SysGrainMacManager.BEAN_ID)
public class SysGrainMacManager {

	public static final String BEAN_ID = "sys.grainMacManager";

	@Autowired
	private RemoteManager remoteManager;
	@Autowired
	private ExeOrderService exeOrderService;

	@Autowired
	private RedisUtil redisUtil;

	@Autowired
	private CoreSerService coreSerService;

	private RemoteCommonService remoteCommonService;

	/**
	 * 读取粮情分机配置参数
	 *
	 * @param data
	 * @return
	 */
	public String readConf(DeviceSer data) {
		if (StringUtils.isEmpty(data.getProtocol())) {
			return "执行失败，当前分机未配置协议！";
		}
		try {
			GrainSerConfRequest request = new GrainSerConfRequest();
			request.setCompanyId(data.getCompanyId());
			request.setCableX(data.getCableX());
			request.setCableY(data.getCableY());
			request.setCableZ(data.getCableZ());
			request.setIp(data.getIp());
			request.setPort(data.getPort());
			request.setBizType(BizType.SYS.getCode());
			request.setSerId(data.getId());
			request.setCableFormat(data.getCableFormat());
			request.setCableType(data.getCableType());
			request.setPowerModel(data.getPowerModel());
			request.setOrgId(data.getOrgId());

			// 避免重复发送命令和添加操作记录
			ExeRequest exeRequest = new ExeRequest(request);
			exeOrderService.checkExecute(exeRequest);

			remoteCommonService = remoteManager.getRemoteCommonService(data
					.getProtocol());

			if (null == remoteCommonService) {
				return "执行失败，当前分机配置的协议系统没有实现。";
			}

			BaseResponse result = remoteCommonService.readConf(request);

			// 添加缓存
			if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
				exeOrderService.addCache(exeRequest);

				return "指令发送成功，待终端执行反馈。";
			}

			return "指令发送失败，原因：" + result.getMsg();

		} catch (Exception e) {
			return "系统执行异常，原因：" + e.getMessage();
		}

	}

	/**
	 * @param data
	 * @return
	 */
	public String writeConf(DeviceSer data) {
		if (StringUtils.isEmpty(data.getProtocol())) {
			return "执行失败，当前分机未配置协议！";
		}
		if (data.getCableX() == 0 || data.getCableY() == 0
				|| data.getCableZ() == 0) {
			return "执行失败，层行列信息未配置！";
		}

		if (StringUtils.isEmpty(data.getCableFormat())
				|| StringUtils.isEmpty(data.getCableType())) {
			return "执行失败，电缆制式和电缆类型必填！";
		}
		try {
			GrainSerConfRequest request = new GrainSerConfRequest();
			request.setCompanyId(data.getCompanyId());
			request.setCableX(data.getCableX());
			request.setCableY(data.getCableY());
			request.setCableZ(data.getCableZ());
			request.setIp(data.getIp());
			request.setPort(data.getPort());
			request.setBizType(BizType.SYS.getCode());
			request.setSerId(data.getId());
			request.setCableFormat(data.getCableFormat());
			request.setCableType(data.getCableType());
			// request.setPowerModel(data.getPowerModel());
			request.setOrgId(data.getOrgId());
			request.setSerName(data.getName());

			// 避免重复发送命令和添加操作记录
			ExeRequest exeRequest = new ExeRequest(request);
			exeOrderService.checkExecute(exeRequest);

			remoteCommonService = remoteManager.getRemoteCommonService(data
					.getProtocol());

			if (null == remoteCommonService) {
				return "执行失败，当前分机配置的协议系统没有实现。";
			}

			BaseResponse result = remoteCommonService.writeConf(request);

			// 添加缓存
			if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
				exeOrderService.addCache(exeRequest);

				return "指令发送成功，待终端执行反馈。";
			}

			return "指令发送失败，原因：" + result.getMsg();

		} catch (Exception e) {
			return "系统执行异常，原因：" + e.getMessage();
		}
	}

	/**
	 * 初始化电缆
	 *
	 * @param data
	 * @return
	 */
	public String initCable(DeviceSer data) {
		if (StringUtils.isEmpty(data.getProtocol())) {
			return "执行失败，当前分机未配置协议！";
		}
		try {
			BaseRequest request = new BaseRequest();
			request.setCompanyId(data.getCompanyId());
			request.setIp(data.getIp());
			request.setPort(data.getPort());
			request.setBizType(BizType.SYS.getCode());
			request.setSerId(data.getId());

			// 避免重复发送命令和添加操作记录
			ExeRequest exeRequest = new ExeRequest(request);
			exeOrderService.checkExecute(exeRequest);

			remoteCommonService = remoteManager.getRemoteCommonService(data
					.getProtocol());

			if (null == remoteCommonService) {
				return "执行失败，当前分机配置的协议系统没有实现。";
			}

			BaseResponse result = remoteCommonService.initCable(request);

			// 添加缓存
			if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
				exeOrderService.addCache(exeRequest);

				return "指令发送成功，待终端执行反馈。";
			}

			return "指令发送失败，原因：" + result.getMsg();

		} catch (Exception e) {
			return "系统执行异常，原因：" + e.getMessage();
		}
	}

	/**
	 * 手动端口连接
	 *
	 * @param data
	 * @return
	 */
	public String destoryCon(DeviceSer data) {
		if (StringUtils.isEmpty(data.getProtocol())) {
			return "执行失败，当前分机未配置协议！";
		}
		try {
			BaseRequest request = new BaseRequest();
			request.setCompanyId(data.getCompanyId());
			request.setIp(data.getIp());
			request.setPort(data.getPort());
			request.setBizType(BizType.SYS.getCode());
			request.setSerId(data.getId());

			// 避免重复发送命令和添加操作记录
			ExeRequest exeRequest = new ExeRequest(request);
			exeOrderService.checkExecute(exeRequest);

			remoteCommonService = remoteManager.getRemoteCommonService(data
					.getProtocol());

			if (null == remoteCommonService) {
				return "执行失败，当前分机配置的协议系统没有实现。";
			}

			BaseResponse result = remoteCommonService.destroyCon(request);

			// 添加缓存
			if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
				exeOrderService.addCache(exeRequest);
				return "指令发送成功，请刷新页面查看在线状态！";
			}
			return "指令发送失败，原因：" + result.getMsg();

		} catch (Exception e) {
			return "系统执行异常，原因：" + e.getMessage();
		}
	}

	/**
	 * 粮情分机-电缆配置
	 *
	 * @param request
	 */
	public String updateGrainSerCable(GrainSerConfRequest request) {
		// 获取分机信息
		DeviceSer ser = coreSerService.getCacheSer(request.getCompanyId(),
				request.getSerId());

		if (null == ser) {
			return "系统没有找到相应的分机信息，执行失败！";
		}

		if (Constant.YN_N.equals(ser.getStatus())) {
			return "当前分机不在线！";
		}

		request.setSerName(ser.getName());
		request.setIp(ser.getIp());
		request.setPort(ser.getPort());
		request.setBizType(BizType.SYS.getCode());

		// 避免重复发送命令和添加操作记录
		ExeRequest exeRequest = new ExeRequest(request);
		exeRequest.setAddLogTag(false);
		exeOrderService.checkExecute(exeRequest);

		remoteCommonService = remoteManager.getRemoteCommonService(ser
				.getProtocol());

		if (null == remoteCommonService) {
			return "执行失败，当前分机配置的协议系统没有实现。";
		}

		BaseResponse result = remoteCommonService.updateGrainSerCable(request);

		// 添加缓存
		if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
			// exeOrderService.addCache(exeRequest);
			return "指令发送成功，请刷新页面查看在线状态！";
		}
		return "指令发送失败，原因：" + result.getMsg();
	}

	/**
	 * 粮情电缆数据采集
	 *
	 * @param request
	 * @return
	 */
	public String checkGrainCable(GrainSerConfRequest request) {
		// 获取分机信息
		DeviceSer ser = coreSerService.getCacheSer(request.getCompanyId(),
				request.getSerId());

		if (null == ser) {
			return "系统没有找到相应的分机信息，执行失败！";
		}
		if (Constant.YN_N.equals(ser.getStatus())) {
			return "当前分机不在线！";
		}

		request.setSerName(ser.getName());
		request.setIp(ser.getIp());
		request.setPort(ser.getPort());
		request.setBizType(BizType.SYS.getCode());

		// 避免重复发送命令和添加操作记录
		ExeRequest exeRequest = new ExeRequest(request);
		exeRequest.setAddLogTag(false);
		exeOrderService.checkExecute(exeRequest);

		remoteCommonService = remoteManager.getRemoteCommonService(ser
				.getProtocol());

		if (null == remoteCommonService) {
			return "执行失败，当前分机配置的协议系统没有实现。";
		}

		BaseResponse result = remoteCommonService.checkGrainSerCable(request);

		// 添加缓存
		if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
			exeOrderService.addCache(exeRequest);
			return "SUCCESS=指令发送成功，请耐心等待结果返回！";
		}
		return "指令发送失败，原因：" + result.getMsg();
	}

	public String sumGrainCable(GrainSerConfRequest request) {
		// 获取分机信息
		DeviceSer ser = coreSerService.getCacheSer(request.getCompanyId(),
				request.getSerId());

		if (null == ser) {
			return "系统没有找到相应的分机信息，执行失败！";
		}
		if (Constant.YN_N.equals(ser.getStatus())) {
			return "当前分机不在线！";
		}

		request.setSerName(ser.getName());
		request.setIp(ser.getIp());
		request.setPort(ser.getPort());
		request.setBizType(BizType.SYS.getCode());

		// 避免重复发送命令和添加操作记录
		ExeRequest exeRequest = new ExeRequest(request);
		exeRequest.setAddLogTag(false);
		exeOrderService.checkExecute(exeRequest);

		remoteCommonService = remoteManager.getRemoteCommonService(ser
				.getProtocol());

		if (null == remoteCommonService) {
			return "执行失败，当前分机配置的协议系统没有实现。";
		}

		BaseResponse result = remoteCommonService.sumGrainSerCable(request);

		// 添加缓存
		if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
			exeOrderService.addCache(exeRequest);
			return "SUCCESS=指令发送成功，请耐心等待结果返回！";
		}
		return "指令发送失败，原因：" + result.getMsg();
	}

	/**
	 * 根据参数获取 分机-通道-电缆数据
	 *
	 * @param companyId
	 * @param serId
	 * @param passCode
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<GrainSerCableData> listSerCableData(String companyId,
                                                    String serId, Integer passCode) {

		String redisKey = RedisConst.buildKey(companyId,
				RedisConst.KEY_TEMP_PREFIX, "CABLE_DATA_" + serId);

		if (null != passCode) {// 表示获取汇数据
			redisKey = RedisConst.buildKey(companyId,
					RedisConst.KEY_TEMP_PREFIX, "CABLE_DATA_" + serId + "_"
							+ passCode);
		}
		
		return (List<GrainSerCableData>) redisUtil.get(redisKey);

	}

	/**
	 * 更新粮库子系统中的仓库配置列表
	 * 
	 * @param companyId
	 * @param serId
	 * @param sn
	 * @return
	 */
	public String updateSysDepotConf(String companyId, String serId, String sn) {

		// 获取分机信息
		DeviceSer ser = coreSerService.getCacheSer(companyId, serId);

		if (null == ser) {
			return "系统没有找到相应的分机信息，执行失败！";
		}
		if (Constant.YN_N.equals(ser.getStatus())) {
			return "当前分机不在线！";
		}

		BaseRequest request = new BaseRequest();
		request.setSerName(ser.getName());
		request.setIp(ser.getIp());
		request.setPort(ser.getPort());
		request.setCompanyId(serId);
		request.setBizType(BizType.SYS.getCode());

		remoteCommonService = remoteManager.getRemoteCommonService(ser
				.getProtocol());

		if (null == remoteCommonService) {
			return "执行失败，当前分机配置的协议系统没有实现。";
		}

		BaseResponse result = remoteCommonService.updateSysDepotConf(request);

		// 添加缓存
		if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
			return "SUCCESS=指令发送成功，请耐心等待结果返回！";
		}

		return "指令发送失败，原因：" + result.getMsg();
	}

}