package org.springblade.mdm.basesetting.machine.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.MybatisUtils;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BizServiceImpl;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.basesetting.machine.mapper.MachineMapper;
import org.springblade.mdm.basesetting.machine.vo.MachineQueryVO;
import org.springblade.mdm.basesetting.machine.vo.MachineSaveVO;
import org.springblade.mdm.basesetting.machine.vo.MachineVO;
import org.springblade.mdm.basesetting.producedivision.service.MdmDeptService;
import org.springblade.mdm.commons.service.MachineDirTranslator;
import org.springblade.mdm.commons.service.ParamService;
import org.springblade.mdm.machinefile.entity.MachineFile;
import org.springblade.mdm.machinefile.filewatch.DynamicDirectoryWatcher;
import org.springblade.mdm.machinefile.filewatch.MachineFileChangeListener;
import org.springblade.mdm.machinefile.filewatch.WatchInfo;
import org.springblade.mdm.machinefile.service.MachineFileService;
import org.springblade.mdm.program.service.ProgramAnnotationService;
import org.springblade.system.feign.ISysClient;
import org.springblade.system.pojo.entity.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Optional;

@Service
public class MachineService extends BizServiceImpl<MachineMapper, Machine> {
	@Autowired
	private ISysClient sysClient;
	@Autowired
	private DynamicDirectoryWatcher dynamicDirectoryWatcher;
	@Autowired
	private ParamService paramService;
	@Autowired
	private MachineDirTranslator machineDirTranslator;

	@Transactional(rollbackFor = Exception.class)
	public void saveMachine(MachineSaveVO vo) throws IOException {
		checkMachine(vo);
		if(existsByCode(vo.getCode(),null)){
			throw new ServiceException("机床编码已存在:"+vo.getCode());
		}
		if(existsByEquipmentCode(vo.getEquipmentCode(),null)){
			throw new ServiceException("设备编号已存在:"+vo.getEquipmentCode());
		}

		Machine machine = new Machine();
		BeanUtil.copyProperties(vo, machine);
		machine.setId(null);
		this.save(machine);
		makeMachineDirs(machine);
		addDirWatcher(machine);
	}


	void makeMachineDirs(Machine machine) throws IOException {
		Path dir;
		if(StringUtils.isNotBlank(machine.getProgSendDir())){
			createDirIsNotExists(machineDirTranslator.trans(machine.getProgSendDir()));
		}

		if(StringUtils.isNotBlank(machineDirTranslator.trans(machine.getProgReceiveDir()))){
			createDirIsNotExists(machineDirTranslator.trans(machine.getProgReceiveDir()));
		}

		if(StringUtils.isNotBlank(machineDirTranslator.trans(machine.getProgTempDir()))){
			createDirIsNotExists(machineDirTranslator.trans(machine.getProgTempDir()));
		}
	}

	void createDirIsNotExists(String pathdir) throws IOException {
		Path dir = Paths.get(pathdir);
		if(!Files.exists(dir)){
			Files.createDirectories(dir);
		}
	}
	void addDirWatcher(Machine machine){
		String type = paramService.networkType();
		if(type.equals(ParamService.NETWORK_TYPE_SHEMI)){
			//涉密网不需要监控目录
			return;
		}
		try {
			MachineFileService machineFileService = SpringUtil.getBean(MachineFileService.class);
			ProgramAnnotationService annoService = SpringUtil.getBean(ProgramAnnotationService.class);

			if(StringUtils.isNotBlank(machine.getProgSendDir())) {

				String sendDir = machineDirTranslator.trans(machine.getProgSendDir());

				WatchInfo watchInfoSend = new WatchInfo();
				watchInfoSend.setMachine(machine);
				watchInfoSend.setDirType(MachineFile.DIR_TYPE_SEND);
				watchInfoSend.setPath(sendDir);

				Path path = Paths.get(sendDir);
				if(!dynamicDirectoryWatcher.containsPath(path)) {
					dynamicDirectoryWatcher.addDirectory(path,
						new MachineFileChangeListener(machineFileService,
							annoService,
							watchInfoSend));
				}
			}

			if(StringUtils.isNotBlank(machine.getProgReceiveDir())) {

				String recDir = machineDirTranslator.trans(machine.getProgReceiveDir());

				WatchInfo watchInfoRec = new WatchInfo();
				watchInfoRec.setMachine(machine);
				watchInfoRec.setDirType(MachineFile.DIR_TYPE_REC);
				watchInfoRec.setPath(recDir);
				Path path = Paths.get(recDir);
				if(!dynamicDirectoryWatcher.containsPath(path)) {
					dynamicDirectoryWatcher.addDirectory(path,
						new MachineFileChangeListener(machineFileService,
							annoService,
							watchInfoRec));
				}
			}

			if(StringUtils.isNotBlank(machine.getProgTempDir())) {
				String tempDir = machineDirTranslator.trans(machine.getProgTempDir());
				WatchInfo watchInfoTemp = new WatchInfo();
				watchInfoTemp.setMachine(machine);
				watchInfoTemp.setDirType(MachineFile.DIR_TYPE_TEMP);
				watchInfoTemp.setPath(tempDir);
				Path path = Paths.get(machine.getProgTempDir());
				if(!dynamicDirectoryWatcher.containsPath(path)) {
					dynamicDirectoryWatcher.addDirectory(path,
						new MachineFileChangeListener(machineFileService,
							annoService,
							watchInfoTemp));
				}
			}
		} catch (Exception e) {
			log.error("增加机床监控异常",e);
			throw new RuntimeException(e);
		}
	}
	/**
	 * 检查机床录入数据
	 * @param vo 录入的表单数据VO
	 */
	void checkMachine(MachineSaveVO vo){
		if(Func.isEmpty(vo.getCode())){
			throw new ServiceException("机床编码不能为空");
		}

		if(Func.isEmpty(vo.getName())){
			throw new ServiceException("机床类型不能为空");
		}

		if(Func.isEmpty(vo.getMachineGroupCode())){
			throw new ServiceException("所属组织不能为空");
		}

		if(Func.isEmpty(vo.getMachineSpec())){
			throw new ServiceException("机床类型不能为空");
		}
	}

	/**
	 * 根据机床编码判断机床是否存在
	 * @param code 机床编码
	 * @param excludeId 排除id
	 * @return 是否存在
	 */
	boolean existsByCode(String code,Long excludeId){
		return this.lambdaQuery().eq(Machine::getCode, code).ne(excludeId!=null,Machine::getId, excludeId).count()>0;
	}

	/**
	 * 根据 设备编号判断机床是否存在
	 * @param equipmentCode 设备编号
	 * @param excludeId 排除id
	 * @return 是否存在
	 */
	boolean existsByEquipmentCode(String equipmentCode,Long excludeId){
		return this.lambdaQuery().eq(Machine::getEquipmentCode, equipmentCode).ne(excludeId!=null,Machine::getId, excludeId).count()>0;
	}


	/**
	 * 修改机床信息
	 * @param vo
	 * @return
	 */
	public boolean updateMachine(MachineSaveVO vo) throws Exception {

		checkMachine(vo);
		if(existsByCode(vo.getCode(),vo.getId())){
			throw new ServiceException("机床编码已存在:"+vo.getCode());
		}
		if(existsByEquipmentCode(vo.getEquipmentCode(),vo.getId())){
			throw new ServiceException("设备编号已存在:"+vo.getEquipmentCode());
		}
		Machine machine = this.getById(vo.getId());

		Machine machineBak = new Machine();
		BeanUtil.copyProperties(machine, machineBak);

		machine.setMachineSpec(vo.getMachineSpec());
		machine.setCode(vo.getCode());
		machine.setEquipmentCode(vo.getEquipmentCode());
		machine.setName(vo.getName());
		machine.setMachineGroupCode(vo.getMachineGroupCode());
		machine.setManufacturer(vo.getManufacturer());
		machine.setOperator(vo.getOperator());
		machine.setControlSystem(vo.getControlSystem());
		machine.setOwnerDept(vo.getOwnerDept());
		machine.setProgSendDir(vo.getProgSendDir());
		machine.setProgReceiveDir(vo.getProgReceiveDir());
		machine.setProgTempDir(vo.getProgTempDir());
		machine.setStatus(vo.getStatus());
		machine.setRemark(vo.getRemark());
		machine.setSendDirExpiryHours(vo.getSendDirExpiryHours());
		machine.setReceiveDirExpiryHours(vo.getReceiveDirExpiryHours());

		boolean updateR = this.updateById(machine);
		removeDirWatcher(machineBak);
		addDirWatcher(machine);

		return updateR;
	}

	/**
	 * 去掉目录监控
	 * @param machine
	 * @throws Exception
	 */
	private void removeDirWatcher(Machine machine) throws Exception {
		String type = paramService.networkType();
		if(type.equals(ParamService.NETWORK_TYPE_SHEMI)){
			//涉密网不需要监控目录
			return;
		}
		if(StringUtils.isNotBlank(machine.getProgSendDir())) {
			dynamicDirectoryWatcher.removeDirectory(Paths.get(machine.getProgSendDir()));
		}

		if(StringUtils.isNotBlank(machine.getProgReceiveDir())) {
			dynamicDirectoryWatcher.removeDirectory(Paths.get(machine.getProgReceiveDir()));
		}

		if(StringUtils.isNotBlank(machine.getProgTempDir())) {
			dynamicDirectoryWatcher.removeDirectory(Paths.get(machine.getProgTempDir()));
		}
	}

	/**
	 * 查询分页
	 * @param query 查询参数
	 * @return 分页数据
	 */
	public IPage<MachineVO> pageQuery(MachineQueryVO query) {

		if (query.getDeptId() != null) {
			R<Dept> rs = sysClient.getDept(query.getDeptId());
			if(rs.isSuccess()){
				query.setDeptAncestors(rs.getData().getAncestors()+","+rs.getData().getId());
			}
		}
		return this.getBaseMapper().pageQuery(Condition.getPage(query), query);
	}

	/**
	 * 查询详情
	 * @param id 机床id
	 * @return
	 */
	public MachineVO detail(long id) {
		Machine machine = this.getById(id);

		MachineVO vo = new MachineVO();
		BeanUtil.copyProperties(machine, vo);

		return vo;
	}

	/**
	 * 产生机床回传结构数据
	 * @param id
	 */
	/*
	public void genMachineFileBackDirs(Long id) throws IOException {
		Machine machine = this.getById(id);
		if(Func.isNotBlank(machine.getProgReceiveDir())){
			if(isLegalDirectoryPath(machine.getProgReceiveDir())) {
				Path path = Paths.get(machine.getProgReceiveDir());
				Files.createDirectories(path);
			}else{
				throw new RuntimeException("非法的目录格式");
			}
		}
	}*/

	/**
	 * 判断是否是合法的目录格式
	 * @param path
	 * @return
	 */
	static boolean isLegalDirectoryPath(String path) {
		// 基础检查
		if (path == null || path.trim().isEmpty()) {
			return false;
		}

		// 使用NIO检查路径格式
		Path nioPath;
		try {
			nioPath = Paths.get(path);
			if (!nioPath.normalize().toString().equals(path)) {
				return false; // 路径不规范
			}
		} catch (InvalidPathException ex) {
			return false;
		}

		return true;

	}

	/**
	 * 根据机床编码获取机床
	 * @param machineCode 机床编码
	 * @return
	 */
	public Machine getByCode(String machineCode) {
		return this.lambdaQuery().eq(Machine::getCode, machineCode).one();
	}

	/**
	 * 获取所有启用状态的机床列表
	 * @return 机床列表
	 */
    public List<Machine> getEnableMachines() {
		return lambdaQuery().eq(Machine::getStatus,Machine.STATUS_ENABLE).list();
    }

	public String escapeSqlWildcard(String value) {
		if (StringUtils.isBlank(value)) {
			return value;
		}
		return value.replace("\\", "\\\\")
			.replace("%", "\\%")
			.replace("_", "\\_");
	}
	/**
	 * 根据下发路径的注释查询机床
	 * @param sendPathLine 下发路径注释文本
	 */
    public Machine getMachineBySendPathAnnotation(String sendPathLine) {
		//路径为空，不匹配任何机器
		if(StringUtils.isBlank(sendPathLine)){
			return null;
		}
		//去掉末尾括号(发那科) ,末尾路径分隔符
		String oriPath = StringUtils.removeEnd(StringUtils.removeEnd(StringUtils.removeEnd(sendPathLine,")"),"/"),"\\");

		String tempPathRepl1 = StringUtils.replace(oriPath,"/","\\");//反斜杠版本的路径
		String tempPathRepl2 = StringUtils.replace(oriPath,"\\","/");//正斜杠版本的路径

		//去掉前2位可能的注释(*-)。
		String sendPath1 = escapeSqlWildcard(StringUtils.trim(StringUtils.substring(tempPathRepl1,2)));
		String sendPath2 = escapeSqlWildcard(StringUtils.trim(StringUtils.substring(tempPathRepl2,2)));

		Optional<Machine> machineOpt = lambdaQuery().eq(Machine::getStatus,Machine.STATUS_ENABLE).and(w -> {
			w.like(Machine::getProgSendDir,sendPath1).or().like(Machine::getProgSendDir,sendPath2);
		}).last("limit 1").oneOpt();

		return machineOpt.orElse(null);
    }

	/**
	 * 根据设备编号查询机床
	 * @param equipmentCode 设备编号
	 * @return 机床对象
	 */
	public Machine getByEquipmentCode(String equipmentCode) {
		return this.lambdaQuery().eq(Machine::getEquipmentCode, equipmentCode).one();
	}
}