/*
 *    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.IdWorker;
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.concurrent.atomic.AtomicInteger;
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<SysDictItem> type = dictUtils.getDict("technology_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()));
				}
			});

			Optional.ofNullable(p.getParamType()).ifPresent(t -> {
				int size = type.stream().filter(d -> Objects.equals(p.getParamType(), d.getLabel())).collect(Collectors.toList()).size();
				if (size < 1) {
					throw new RuntimeException(("字典中无此参数类型,请检查后再次导入，类型为：---------》" + p.getParamType()));
				}
			});
		});

		List<List<ParamTemplate>>listParamTemplates = new ArrayList<List<ParamTemplate>>();
			for (int j = 0; j < count.size()-1; j++) {
				List<ParamTemplate> paramTemplateLists = new ArrayList<>();
				for (int i = count.get(j); i < count.get(j+1); i++) {
					paramTemplateLists.add(paramTemplates.get(i));
				}
				listParamTemplates.add(paramTemplateLists);
			}
		List<List<Param>>paramList=new ArrayList<>();
		AtomicInteger nums = new AtomicInteger();
		List<Long>secondIds=new ArrayList();
		for (int i = 0; i < listParamTemplates.size(); i++) {
			List<ParamTemplate> l = listParamTemplates.get(i);
			List<Param>paramList1=new ArrayList<>();
			ParamTemplate paramTemplate = l.get(0);
			Param paramFirst=new Param();
			paramFirst.setCode("ZS-CS"+IdWorker.getIdStr());
			//一级参数
			String paramItem = paramTemplate.getParamItem();
			paramFirst.setParameterItem(paramItem);
			if(l.size()<=1){
				Optional.ofNullable(paramTemplate.getParamType()).ifPresent(o->{
					List<SysDictItem> collect = type.stream().filter(t -> Objects.equals(paramTemplate.getParamType(), t.getLabel())).collect(Collectors.toList());
					paramFirst.setType(collect.get(0).getValue());
				});
				paramFirst.setParameterFormat(paramTemplate.getParamFormat());
				paramFirst.setUnit(paramTemplate.getUnit());
			}
			paramFirst.setId(IdWorker.getId());
			paramList1.add(paramFirst);
			if(l.size()>1){
				for (int k = 0; k < l.size(); k++) {
					ParamTemplate c = l.get(k);
					if(c.getParamItemTwo()!=null){
						Param second=new Param();
						second.setId(IdWorker.getId());
						secondIds.add(second.getId());
						second.setCode(dictTwo.stream().filter(d -> Objects.equals(c.getParamItemTwo(), d.getLabel())).collect(Collectors.toList()).get(0).getId()+"");
						second.setParameterItem(c.getParamItemTwo());
						if(c.getParamItemThree()==null){
							second.setType(type.stream().filter(d -> Objects.equals(c.getParamType(), d.getLabel())).collect(Collectors.toList()).get(0).getValue());
							second.setParameterFormat(c.getParamFormat());
							second.setUnit(c.getUnit());
						}
						second.setParentId(paramList1.get(0).getId());
						paramList1.add(second);
					}
					if (c.getParamItemThree()!=null){
						Param third=new Param();
						third.setId(IdWorker.getId());
						long paramItemTwo = secondIds.get(secondIds.size()-1);
						//System.out.println(nums.get()+"所属二级======》"+secondIds.get(secondIds.size()-1));
						third.setParentId(paramItemTwo);
						third.setParameterItem(c.getParamItemThree());
						third.setCode(dictThree.stream().filter(d -> Objects.equals(c.getParamItemThree(), d.getLabel())).collect(Collectors.toList()).get(0).getId()+"");
						third.setType(type.stream().filter(d -> Objects.equals(c.getParamType(), d.getLabel())).collect(Collectors.toList()).get(0).getValue());
						third.setParameterFormat(c.getParamFormat());
						third.setUnit(c.getUnit());
						paramList1.add(third);
					}
				}
			}
			paramList.add(paramList1);
		}
		paramList.forEach(p->{
			p.forEach(cc->{
				baseMapper.insert(cc);
			});
		});
	}

}