/*
 *    Copyright (c) 2018-2025, ztt All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * Neither the name of the pig4cloud.com developer nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * Author: ztt
 */
package com.chinaztt.mes.basic.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.chinaztt.mes.basic.dto.ParamPlusDto;
import com.chinaztt.mes.basic.entity.Param;
import com.chinaztt.mes.basic.entity.ParamJoinTemplate;
import com.chinaztt.mes.basic.excel.ParamData;
import com.chinaztt.mes.basic.mapper.ParamJoinTemplateMapper;
import com.chinaztt.mes.basic.mapper.ParamMapper;
import com.chinaztt.mes.basic.service.ParamService;
import com.chinaztt.mes.basic.util.DictUtils;
import com.chinaztt.mes.common.feign.DictApi;
import com.chinaztt.mes.common.util.easyexcel.template.ParamTemplate;
import com.chinaztt.ztt.admin.api.entity.SysDictItem;
import com.chinaztt.ztt.common.core.util.R;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * 工序参数表
 *
 * @author sunxl
 * @date 2021-01-14 15:24:37
 */
@AllArgsConstructor
@Service
public class ParamServiceImpl extends ServiceImpl<ParamMapper, Param> implements ParamService {
	private ParamJoinTemplateMapper paramJoinTemplateMapper;
	private DictUtils dictUtils;

	private DictApi dictApi;

	@Override
	@Transactional(rollbackFor = Exception.class)
	public R<Boolean> fullSave(ParamPlusDto param) {
		int noCount = baseMapper.selectCount(Wrappers.<Param>lambdaQuery().eq(Param::getCode, param.getCode()));
		if (noCount > 0) {
			return R.failed("编号重复");
		}
		List<SysDictItem> second_param = dictUtils.getDict("second_param");
		List<SysDictItem> third_param = dictUtils.getDict("third_param");
		Param father=new Param();
		father.setCode(param.getCode());
		father.setParameterItem(param.getParameterItem());
		baseMapper.insert(father);
		//二级参数
		param.getSecondId().forEach(s->{
			Param second=new Param();
			SysDictItem sysDictItem = second_param.stream().filter(p -> p.getId().equals(Integer.valueOf(String.valueOf(s)))).collect(Collectors.toList()).get(0);
			second.setParameterItem(sysDictItem.getLabel());
			second.setCode(""+s);
			second.setParentId(father.getId());
			baseMapper.insert(second);
			//三级
			param.getThirdId().forEach(t->{
				Param third=new Param();
				SysDictItem sysThirdDictItem = third_param.stream().filter(p -> p.getId().equals(Integer.valueOf(String.valueOf(t)))).collect(Collectors.toList()).get(0);
				third.setParameterItem(sysThirdDictItem.getLabel());
				third.setCode(""+t);
				third.setParentId(second.getId());
				baseMapper.insert(third);
			});
		});
		return R.ok();
	}

	@Override
	public R<Boolean> fullUpdate(Param param) {
		int noCount = baseMapper.selectCount(Wrappers.<Param>lambdaQuery().ne(Param::getId, param.getId()).eq(Param::getCode, param.getCode()));
		if (noCount > 0) {
			return R.failed("编号重复");
		}
		baseMapper.updateById(param);
		return R.ok();
	}

	@Override
	public IPage<List<Param>> getTechnologyParamPage(Page page, Long id, QueryWrapper<Param> ew) {
		return baseMapper.getTechnologyParamPage(page, id, ew);
	}


	@Override
	public void importExcel(List<ParamData> list) {
		if (CollectionUtil.isEmpty(list)) {
			return;
		}
		//获取字典的数组值
		List<SysDictItem> dict = dictUtils.getDict("technology_param");
		for (ParamData data : list) {
			Param param = new Param();
			dict.forEach(a -> {
				if (a.getLabel().equals(data.getType())) {
					param.setType(a.getValue());
				}
			});
			if (param.getType() == null) {
				log.error("工序参数类型:" + data.getType() + "不存在");
				continue;
			}
			param.setCode(data.getCode());
			int noCount = baseMapper.selectCount(Wrappers.<Param>lambdaQuery().ne(Param::getId, param.getId()).eq(Param::getCode, data.getCode()));
			if (noCount > 0) {
				throw new RuntimeException(data.getCode() + "编号重复");
			}
			param.setParameterItem(data.getParameterItem());
			param.setUnit(data.getUnit());
			// 下拉选项类型手动处理参数格式
			if (!StringUtils.equals("2", param.getType())) {
				param.setParameterFormat(data.getParameterFormat());
			}
			baseMapper.insert(param);
		}
	}

	@Override
	public boolean delete(Long id) {
		int count = paramJoinTemplateMapper.selectCount(Wrappers.<ParamJoinTemplate>lambdaQuery().eq(ParamJoinTemplate::getTechnologyOperationParamId, id));
		if (count > 0) {
			throw new RuntimeException("该参数已经被引用，不可删除");
		}
		baseMapper.deleteById(id);
		return true;
	}

	@Override
	public String checkItemRepeat(Param param) {
		List<Param> repeatList = baseMapper.selectList(Wrappers.<Param>lambdaQuery().eq(Param::getParameterItem, param.getParameterItem()).ne(Param::getId, param.getId()));
		if (CollectionUtil.isNotEmpty(repeatList)) {
			return repeatList.stream().map(p -> p.getCode()).collect(Collectors.joining(","));
		} else {
			return null;
		}
	}

	private String codeMake() {
		// 固定字符串  GX + 年月日 + 01
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
		String yrar = formatter.format(LocalDateTime.now());
		String code = "GX" + yrar;
		List<String> parameterItem = baseMapper.getNos(code);
		if (CollectionUtil.isEmpty(parameterItem)) {
			code = code + "01";
		}
		return code;
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void importExcelPlus(List<ParamTemplate> paramTemplates) {
		//二级参数id 133
		//三级参数 134
		List<SysDictItem> dictTwo = dictUtils.getDict("second_param");
		List<SysDictItem> dictThree = dictUtils.getDict("third_param");
		List<Integer> count = new ArrayList<Integer>();
		int num = 0;
		for (int i = 0; i < paramTemplates.size(); i++) {
			if (StringUtils.isNotEmpty(paramTemplates.get(i).getParamItem())) {
				count.add(num);
			}
			num++;
		}
		count.add(paramTemplates.size());

		System.out.println(count);
		List<List<ParamTemplate>> list = new ArrayList<>();
		paramTemplates.forEach(p -> {
			Optional.ofNullable(p.getParamItemTwo()).ifPresent(t -> {
				int size = dictTwo.stream().filter(d -> Objects.equals(p.getParamItemTwo(), d.getLabel())).collect(Collectors.toList()).size();
				if (size < 1) {
					throw new RuntimeException(("字典中无此二级参数,请检查后再次导入，参数为：---------》" + p.getParamItemTwo()));
				}
			});
			Optional.ofNullable(p.getParamItemThree()).ifPresent(t -> {
				int size = dictThree.stream().filter(d -> Objects.equals(p.getParamItemThree(), d.getLabel())).collect(Collectors.toList()).size();
				if (size < 1) {
					throw new RuntimeException(("字典中无此三级参数,请检查后再次导入，参数为：---------》" + p.getParamItemThree()));
				}
			});
		});
		for (int i = 0; i < paramTemplates.size(); i++) {
			for (int j = 0; j < count.size(); j++) {
				if(i==count.get(j)-1){

				}else {

				}
			}
		}
		list.forEach(l->{
			System.out.println("======================");
			l.forEach(System.out::println);
		});
	}

}