package org.jeecg.modules.dnc.service.impl;

import com.jeecg.weibo.exception.BusinessException;
import org.jeecg.modules.dnc.dto.ComponentHierarchy;
import org.jeecg.modules.dnc.dto.TransferPackage;
import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.dnc.mapper.*;
import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class DataImportService {
    private static final Logger logger = LoggerFactory.getLogger(DataImportService.class);

    @Autowired
    private ProductInfoMapper productMapper;

    @Autowired
    private ComponentInfoMapper componentMapper;

    @Autowired
    private PartsInfoMapper partsMapper;

    @Autowired
    private ProcessSpecVersionMapper psvMapper;

    @Autowired
    private ProcessStreamMapper processMapper;

    @Autowired
    private WorkStepMapper workStepMapper;

    @Autowired
    private ProductMixMapper productMixMapper;

    @Autowired
    private PermissionStreamNewMapper permissionStreamNewMapper;

    @Autowired
    private DeviceManagementMapper deviceManagementMapper;

    @Autowired
    private DeviceTypeMapper deviceTypeMapper;

    @Autowired
    private DocInfoMapper docInfoMapper;

    @Autowired
    private DocFileMapper docFileMapper;

    @Autowired
    private DocRelativeMapper docRelativeMapper;

    @Autowired
    private CutterMapper cutterMapper;

    @Autowired
    private GuideCardBatchMapper guideCardBatchMapper;

    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private IMdcProductionService mdcProductionService;

    @Autowired
    private IProductPermissionService productPermissionService;

    @Autowired
    private IProductDepartmentService productDepartmentService;

    @Autowired
    private IComponentPermissionService componentPermissionService;

    @Autowired
    private IComponentDepartmentService componentDepartmentService;

    @Autowired
    private IPartsPermissionService partsPermissionService;

    @Autowired
    private IPartsDepartmentService partsDepartmentService;

    @Autowired
    private IProcessSpecVersionPermissionService processSpecVersionPermissionService;

    @Autowired
    private IProcessSpecVersionDepartmentService processSpecVersionDepartmentService;

    @Autowired
    private IProcessStreamPermissionService processStreamPermissionService;

    @Autowired
    private IProcessionDepartmentService processionDepartmentService;

    @Autowired
    private IWorkStepPermissionService workStepPermissionService;

    @Autowired
    private IWorkStepDepartmentService workStepDepartmentService;

    @Transactional(rollbackFor = Exception.class)
    public void importTransferPackage(TransferPackage transferPackage) {
        try {
            logger.info("开始导入传输包数据, 类型: {}", transferPackage.getDataType());

            // 保存产品
            if (transferPackage.getTraceChain() != null &&
                    transferPackage.getTraceChain().getProduct() != null) {
                saveProduct(transferPackage.getTraceChain().getProduct());
            }

            // 保存部件层级
            if (transferPackage.getTraceChain() != null &&
                    transferPackage.getTraceChain().getComponentHierarchy() != null) {
                saveComponentHierarchy(transferPackage.getTraceChain().getComponentHierarchy());
            }

            // 保存零件
            if (transferPackage.getTraceChain() != null &&
                    transferPackage.getTraceChain().getParts() != null) {
                saveParts(transferPackage.getTraceChain().getParts());
            }

            // 保存工艺规程
            if (transferPackage.getTraceChain() != null &&
                    transferPackage.getTraceChain().getProcessSpec() != null) {
                saveProcessSpec(transferPackage.getTraceChain().getProcessSpec());
            }

            // 保存工序
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getProcess() != null) {
                saveProcess(transferPackage.getTraceChain().getProcess());
            }

            // 保存工步
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getWorkStep() != null) {
                saveWorkSteps(transferPackage.getTraceChain().getWorkStep());
            }

            // 保存结构树
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getTreePath() != null) {
                saveTreePath(transferPackage.getTraceChain().getTreePath());
            }

            // 保存设备类
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getDeviceManagement() != null) {
                saveDeviceManagement(transferPackage.getTraceChain().getDeviceManagement());
            }

            // 保存设备类对应信息
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getDeviceType() != null) {
                saveDeviceType(transferPackage.getTraceChain().getDeviceType());
            }

            // 保存文档
            if (transferPackage.getTraceChain() != null&&
                    transferPackage.getTraceChain().getDocInfo() != null) {
                saveDocInfo(transferPackage.getTraceChain().getDocInfo());
            }

            // 保存文件
            if (transferPackage.getTraceChain() !=null&&
                    transferPackage.getTraceChain().getDocFile() != null) {
                saveDocFile(transferPackage.getTraceChain().getDocFile());
            }

            // 保存文档文件对应关系
            if (transferPackage.getDocRelative() !=null){
                saveDocRelative(transferPackage.getDocRelative());
            }

            // 保存刀具系统
            if (transferPackage.getTraceChain() !=null&&
                    transferPackage.getTraceChain().getCutterList() != null) {
                saveCutterList(transferPackage.getTraceChain().getCutterList());
            }

            //保存数控程序加工确认表
            if (transferPackage.getTraceChain() !=null&&
                    transferPackage.getTraceChain().getGuideCardBatch() != null) {
                saveGuideCardBatch(transferPackage.getTraceChain().getGuideCardBatch());
            }

            logger.info("数据导入成功");
        } catch (DuplicateKeyException e) {
            logger.warn("主键冲突: {}", e.getMessage());
            throw new BusinessException("数据已存在，无法重复导入");
        } catch (DataIntegrityViolationException e) {
            logger.error("数据完整性违反: {}", e.getMessage());
            throw new BusinessException("数据不完整，请检查必填字段");
        } catch (Exception e) {
            logger.error("数据导入失败: {}", e.getMessage(), e);
            throw new BusinessException("数据导入失败: " + e.getMessage());
        }
    }

    private void saveProduct(ProductInfo product) {
        if (productMapper.selectById(product.getProductId()) == null) {
            productMapper.insert(product);
            logger.debug("产品已保存: {}", product.getProductId());
        } else {
            productMapper.updateById(product);
            logger.debug("产品已更新: {}", product.getProductId());
        }
    }

    private void saveComponentHierarchy(ComponentHierarchy hierarchy) {
        for (ComponentInfo component : hierarchy.getComponents()) {
            if (componentMapper.selectById(component.getComponentId()) == null) {
                componentMapper.insert(component);
                logger.debug("部件已保存: {}", component.getComponentId());
            } else {
                componentMapper.updateById(component);
                logger.debug("部件已更新: {}", component.getComponentId());
            }
        }
    }

    private void saveParts(PartsInfo parts) {
        if (partsMapper.selectById(parts.getPartsId()) == null) {
            partsMapper.insert(parts);
            logger.debug("零件已保存: {}", parts.getPartsId());
        } else {
            partsMapper.updateById(parts);
            logger.debug("零件已更新: {}", parts.getPartsId());
        }
    }

    private void saveProcessSpec(ProcessSpecVersion processSpec) {
        if (psvMapper.selectById(processSpec.getId()) == null) {
            psvMapper.insert(processSpec);
            logger.debug("工艺规程已保存: {}", processSpec.getId());
        } else {
            psvMapper.updateById(processSpec);
            logger.debug("工艺规程已更新: {}", processSpec.getId());
        }
    }

    private void saveProcess(ProcessStream process) {
        if (processMapper.selectById(process.getProcessId()) == null) {
            processMapper.insert(process);
            logger.debug("工序已保存: {}", process.getProcessId());
        } else {
            processMapper.updateById(process);
            logger.debug("工序已更新: {}", process.getProcessId());
        }
    }

    private void saveWorkSteps(WorkStep workStep) {
        if (workStepMapper.selectById(workStep.getId()) == null) {
            workStepMapper.insert(workStep);
            logger.debug("工步已保存: {}", workStep.getId());
        } else {
            workStepMapper.updateById(workStep);
            logger.debug("工步已更新: {}", workStep.getId());
        }
    }

    private void saveTreePath(List<ProductMix> productMixList){
        for (ProductMix productMix : productMixList) {
            if (productMixMapper.selectById(productMix.getId()) == null) {
                productMixMapper.insert(productMix);
                logger.debug("产品组合已保存: {}", productMix.getId());
            } else {
                productMixMapper.updateById(productMix);
                logger.debug("产品组合已更新: {}", productMix.getId());
            }
        }
    }

    private void saveDeviceManagement(DeviceManagement deviceManagement) {
        if (deviceManagementMapper.selectById(deviceManagement.getId()) == null) {
            deviceManagementMapper.insert(deviceManagement);
            logger.debug("设备类信息已保存: {}", deviceManagement.getId());
        } else {
            deviceManagementMapper.updateById(deviceManagement);
            logger.debug("设备类信息已更新: {}", deviceManagement.getId());
        }
    }

    private void saveDeviceType(DeviceType deviceType) {
        if (deviceTypeMapper.selectById(deviceType.getId()) == null) {
            deviceTypeMapper.insert(deviceType);
            logger.debug("设备类已保存: {}", deviceType.getId());
        } else {
            deviceTypeMapper.updateById(deviceType);
            logger.debug("设备类已更新: {}", deviceType.getId());
        }
    }

    private void saveDocInfo(DocInfo docInfo) {
        if (docInfoMapper.selectById(docInfo.getDocId()) == null) {
            docInfoMapper.insert(docInfo);
            logger.debug("文档已保存: {}", docInfo.getDocId());
        } else {
            docInfoMapper.updateById(docInfo);
            logger.debug("文档已更新: {}", docInfo.getDocId());
        }
    }

    private void saveDocFile(DocFile docFile) {
        if (docFileMapper.selectById(docFile.getFileId()) == null) {
            docFileMapper.insert(docFile);
            logger.debug("文档文件已保存: {}", docFile.getFileId());
        } else {
            docFileMapper.updateById(docFile);
            logger.debug("文档文件已更新: {}", docFile.getFileId());
        }
    }

    private void saveDocRelative(DocRelative docRelative) {
        if (docRelativeMapper.selectById(docRelative.getId()) == null) {
            docRelativeMapper.insert(docRelative);
            logger.debug("文档对应关系已保存: {}", docRelative.getId());
        } else {
            docRelativeMapper.updateById(docRelative);
            logger.debug("文档对应关系已更新: {}", docRelative.getId());
        }
    }

    private void saveCutterList(List<Cutter> cutterList) {
        for (Cutter cutter : cutterList) {
            if (cutterMapper.selectById(cutter.getId()) == null) {
                cutterMapper.insert(cutter);
                logger.debug("刀具已保存: {}", cutter.getId());
            } else {
                cutterMapper.updateById(cutter);
                logger.debug("刀具已更新: {}", cutter.getId());
            }
        }
    }

    private void saveGuideCardBatch(GuideCardBatch guideCardBatch) {
        if (guideCardBatchMapper.selectById(guideCardBatch.getId()) == null) {
            guideCardBatchMapper.insert(guideCardBatch);
            logger.debug("程序加工确认表已保存: {}", guideCardBatch.getId());
        } else {
            guideCardBatchMapper.updateById(guideCardBatch);
            logger.debug("程序加工确认表已更新: {}", guideCardBatch.getId());
        }
    }
}