package com.ruoyi.production.service.impl;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.config.AliDingConfig;
import com.ruoyi.framework.util.AliDingUtils;
import com.ruoyi.production.dto.ProductMaterialDto;
import com.ruoyi.production.dto.ProductMaterialGroupDto;
import com.ruoyi.production.enums.MaterialConfigTypeEnum;
import com.ruoyi.production.mapper.ProductMaterialMapper;
import com.ruoyi.production.pojo.ProductMaterial;
import com.ruoyi.production.pojo.ProductMaterialConfig;
import com.ruoyi.production.pojo.ProductMaterialSku;
import com.ruoyi.production.service.ProductMaterialConfigService;
import com.ruoyi.production.service.ProductMaterialService;
import com.ruoyi.production.service.ProductMaterialSkuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;

/**
 * <br>
 * 产品物料信息接口实现类
 * </br>
 *
 * @author deslrey
 * @version 1.0
 * @since 2026/03/11 16:36
 */
@Slf4j
@Service
public class ProductMaterialServiceImpl extends ServiceImpl<ProductMaterialMapper, ProductMaterial> implements ProductMaterialService {

    @Autowired
    private AliDingConfig aliDingConfig;

    @Autowired
    private ProductMaterialConfigService productMaterialConfigService;

    @Autowired
    private ProductMaterialSkuService productMaterialSkuService;

    /**
     * 同步锁，防止手动和定时任务同时执行
     */
    private final ReentrantLock syncLock = new ReentrantLock();

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void loadProductMaterialData() {
        syncProductMaterialData(1);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void syncProductMaterialJob() {
        syncProductMaterialData(2);
    }

    /**
     * 同步数据
     */
    @Transactional(rollbackFor = Exception.class)
    public void syncProductMaterialData(Integer dataSyncType) {
        if (!syncLock.tryLock()) {
            log.warn("同步正在进行中，本次 {} 同步请求被跳过", dataSyncType == 1 ? "手动" : "定时任务");
            return;
        }

        try {


            JSONArray searchConditions = new JSONArray();
            JSONObject statusCondition = new JSONObject();
            statusCondition.put("key", "processInstanceStatus");
            JSONArray statusValueArray = new JSONArray();
            statusValueArray.add("COMPLETED");
            statusCondition.put("value", statusValueArray);
            statusCondition.put("type", "ARRAY");
            statusCondition.put("operator", "in");
            statusCondition.put("componentName", "SelectField");
            searchConditions.add(statusCondition);

            JSONObject resultCondition = new JSONObject();
            resultCondition.put("key", "processApprovedResult");
            JSONArray resultValueArray = new JSONArray();
            resultValueArray.add("agree");
            resultCondition.put("value", resultValueArray);
            resultCondition.put("type", "ARRAY");
            resultCondition.put("operator", "in");
            resultCondition.put("componentName", "SelectField");
            searchConditions.add(resultCondition);

            String searchFieldJson = searchConditions.toJSONString();

            JSONArray dataArr = AliDingUtils.getFormDataList(aliDingConfig, aliDingConfig.getMaterialCodeFormUuid(), searchFieldJson, productMaterialSkuService, ProductMaterialSku::getFormModifiedTime);

            if (dataArr.isEmpty()) {
                log.info("没有更多新数据需要同步");
                return;
            }

            // 解析并保存数据
            List<ProductMaterialSku> list = parseProductMaterials(dataArr, dataArr.size());
            if (!list.isEmpty()) {
                // 处理更新或新增
                int affected = processSaveOrUpdate(list);
                log.info("物料数据同步完成，共同步 {} 条数据", affected);
            }

        } catch (Exception e) {
            log.error("同步物料编码异常", e);
        } finally {
            // 释放锁
            syncLock.unlock();
        }
    }

    private List<ProductMaterialSku> parseProductMaterials(JSONArray dataArr, Integer totalCount) {
        List<ProductMaterialSku> list = new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();

        for (int i = 0; i < dataArr.size(); i++) {
            JSONObject item = dataArr.getJSONObject(i);
            String formInstanceId = item.getString("formInstanceId");

            JSONObject originator = item.getJSONObject("originator");
            String originatorName = originator != null && originator.containsKey("userName") ? originator.getJSONObject("userName").getString("nameInChinese") : "未知";
            JSONObject formData = item.getJSONObject("formData");
            //  处理物料主表数据
            ProductMaterial material = new ProductMaterial();
            material.setProductName(formData.getString("textField_l92f36f5"));
            material.setUnit(formData.getString("textField_la147lnw"));
            material.setRemark(formData.getString("textareaField_l92f36f9"));

            String materialType = formData.getString("selectField_l92f36fb");
            String inventoryCat = formData.getString("selectField_la154noy");
            material.setMaterialTypeId(getOrCreateConfigId(materialType, MaterialConfigTypeEnum.MATERIAL_TYPE.name()));
            material.setInventoryCategoryId(getOrCreateConfigId(inventoryCat, MaterialConfigTypeEnum.INVENTORY_CAT.name()));

            Long materialId = getOrCreateMaterial(material);

            //  处理物料规格数据
            ProductMaterialSku sku = new ProductMaterialSku();
            sku.setProductId(materialId);
            sku.setFormInstanceId(formInstanceId);
            sku.setIdentifierCode(formData.getString("textField_l92h77ju"));
            sku.setMaterialCode(formData.getString("textField_l92f36f2"));
            sku.setModel(formData.getString("textField_l92f36f6"));
            sku.setSupplyType(formData.getString("selectField_la14k51j"));
            sku.setOriginatorName(originatorName);
            sku.setOriginatorOrg("宁夏中创绿能实业集团有限公司");
            sku.setFormModifiedTime(AliDingUtils.parseUtcTime(item.getString("modifiedTimeGMT")));
            sku.setCreateTime(now);
            sku.setUpdateTime(now);

            list.add(sku);
        }
        return list;
    }

    private Long getOrCreateMaterial(ProductMaterial material) {
        LambdaQueryWrapper<ProductMaterial> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductMaterial::getProductName, material.getProductName());

        ProductMaterial exist = this.getOne(queryWrapper);
        if (exist == null) {
            material.setCreateTime(LocalDateTime.now());
            material.setUpdateTime(LocalDateTime.now());
            this.save(material);
            return material.getId();
        } else {
            // 如果已存在，但关键属性发生变化，则进行更新（以宜搭数据为准）
            boolean needUpdate = false;
            if (material.getMaterialTypeId() != null && !material.getMaterialTypeId().equals(exist.getMaterialTypeId())) {
                exist.setMaterialTypeId(material.getMaterialTypeId());
                needUpdate = true;
            }
            if (material.getInventoryCategoryId() != null && !material.getInventoryCategoryId().equals(exist.getInventoryCategoryId())) {
                exist.setInventoryCategoryId(material.getInventoryCategoryId());
                needUpdate = true;
            }
            if (StringUtils.isNotEmpty(material.getUnit()) && !material.getUnit().equals(exist.getUnit())) {
                exist.setUnit(material.getUnit());
                needUpdate = true;
            }
            if (needUpdate) {
                exist.setUpdateTime(LocalDateTime.now());
                this.updateById(exist);
            }
            return exist.getId();
        }
    }

    private Integer getOrCreateConfigId(String name, String type) {
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        ProductMaterialConfig config = productMaterialConfigService.getOne(new LambdaQueryWrapper<ProductMaterialConfig>().eq(ProductMaterialConfig::getConfigName, name).eq(ProductMaterialConfig::getConfigType, type));
        if (config == null) {
            config = new ProductMaterialConfig();
            config.setConfigName(name);
            config.setConfigType(type);
            productMaterialConfigService.save(config);
        }
        return config.getId();
    }

    private int processSaveOrUpdate(List<ProductMaterialSku> list) {
        if (list == null || list.isEmpty()) {
            return 0;
        }
        int affected = 0;

        for (ProductMaterialSku sku : list) {

            LambdaQueryWrapper<ProductMaterialSku> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(ProductMaterialSku::getProductId, sku.getProductId())
                    .eq(ProductMaterialSku::getModel, sku.getModel());

            if (StringUtils.isNotEmpty(sku.getMaterialCode())) {
                wrapper.eq(ProductMaterialSku::getMaterialCode, sku.getMaterialCode());
            } else {
                wrapper.isNull(ProductMaterialSku::getMaterialCode);
            }

            ProductMaterialSku exist = productMaterialSkuService.getOne(wrapper);
            if (exist == null) {
                productMaterialSkuService.save(sku);
                affected++;
                log.info("新增物料规格 {}", sku.getModel());
            } else {
                if (exist.getFormModifiedTime() == null || !exist.getFormModifiedTime().equals(sku.getFormModifiedTime())) {
                    sku.setId(exist.getId());
                    sku.setCreateTime(exist.getCreateTime());
                    productMaterialSkuService.updateById(sku);

                    affected++;
                    log.info("更新物料规格 {}", sku.getModel());
                }
            }
        }
        return affected;
    }

    @Override
    public List<ProductMaterialGroupDto> ProductMaterialList(Integer type) {
        List<ProductMaterialConfig> configList = productMaterialConfigService.list(new LambdaQueryWrapper<ProductMaterialConfig>()
                .eq(ProductMaterialConfig::getConfigType, MaterialConfigTypeEnum.MATERIAL_TYPE.name())
        );
        if (CollectionUtils.isEmpty(configList)) {
            return new ArrayList<>();
        }
        List<ProductMaterialGroupDto> result = new ArrayList<>();
        Map<Integer, List<ProductMaterialDto>> materialMap = new HashMap<>();
        if (type != null && type == 2) {
            List<ProductMaterial> materialList = this.list(new LambdaQueryWrapper<ProductMaterial>()
                    .select(
                            ProductMaterial::getId,
                            ProductMaterial::getMaterialTypeId,
                            ProductMaterial::getInventoryCategoryId,
                            ProductMaterial::getProductName
                    )
            );
            materialMap = materialList.stream()
                    .map(this::convert)
                    .collect(Collectors.groupingBy(ProductMaterialDto::getMaterialTypeId));
        }

        for (ProductMaterialConfig config : configList) {
            ProductMaterialGroupDto dto = new ProductMaterialGroupDto();
            dto.setConfigId(config.getId());
            dto.setConfigName(config.getConfigName());
            if (type != null && type == 2) {
                dto.setMaterialList(materialMap.getOrDefault(config.getId(), new ArrayList<>()));
            }
            result.add(dto);
        }
        return result;
    }


    @Override
    public List<ProductMaterialGroupDto> productMaterialListByQuery(String materialName, Integer materialTypeId) {

        if (StringUtils.isEmpty(materialName) && materialTypeId == null) {
            return new ArrayList<>();
        }

        LambdaQueryWrapper<ProductMaterial> wrapper = new LambdaQueryWrapper<>();
        //  只查询需要的字段数据
        wrapper.select(
                ProductMaterial::getId,
                ProductMaterial::getMaterialTypeId,
                ProductMaterial::getInventoryCategoryId,
                ProductMaterial::getProductName
        );
        if (StringUtils.isNotEmpty(materialName)) {
            wrapper.like(ProductMaterial::getProductName, materialName);
        }
        if (materialTypeId != null) {
            wrapper.eq(ProductMaterial::getMaterialTypeId, materialTypeId);
        }
        List<ProductMaterial> materials = this.list(wrapper);
        if (CollectionUtils.isEmpty(materials)) {
            return new ArrayList<>();
        }
        Map<Integer, List<ProductMaterialDto>> map = materials.stream()
                .map(this::convert)
                .collect(Collectors.groupingBy(ProductMaterialDto::getMaterialTypeId));

        List<ProductMaterialConfig> configList = productMaterialConfigService.list(new LambdaQueryWrapper<ProductMaterialConfig>()
                .eq(ProductMaterialConfig::getConfigType, MaterialConfigTypeEnum.MATERIAL_TYPE.name()));

        List<ProductMaterialGroupDto> result = new ArrayList<>();
        for (ProductMaterialConfig config : configList) {
            List<ProductMaterialDto> dtoList = map.get(config.getId());
            if (CollectionUtils.isEmpty(dtoList)) {
                continue;
            }
            ProductMaterialGroupDto dto = new ProductMaterialGroupDto();
            dto.setConfigId(config.getId());
            dto.setConfigName(config.getConfigName());
            dto.setMaterialList(dtoList);
            result.add(dto);
        }

        return result;
    }

    private ProductMaterialDto convert(ProductMaterial m) {
        ProductMaterialDto dto = new ProductMaterialDto();
        dto.setId(m.getId());
        dto.setProductName(m.getProductName());
        dto.setMaterialTypeId(m.getMaterialTypeId());
        dto.setInventoryCategoryId(m.getInventoryCategoryId());
        return dto;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addProductMaterial(ProductMaterial productMaterial) {
        validateProductMaterial(productMaterial, false);
        if (existsMaterialName(productMaterial.getProductName(), null)) {
            throw new ServiceException("物料名称已存在");
        }
        LocalDateTime now = LocalDateTime.now();
        if (productMaterial.getCreateTime() == null) {
            productMaterial.setCreateTime(now);
        }
        productMaterial.setUpdateTime(now);
        if (!this.save(productMaterial)) {
            throw new ServiceException("新增物料失败");
        }
        log.info("新增物料成功 materialName={}", productMaterial.getProductName());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateProductMaterial(ProductMaterial productMaterial) {
        validateProductMaterial(productMaterial, true);
        ProductMaterial exist = this.getById(productMaterial.getId());
        if (exist == null) {
            throw new ServiceException("物料不存在");
        }
        if (existsMaterialName(productMaterial.getProductName(), productMaterial.getId())) {
            throw new ServiceException("物料名称已存在");
        }
        productMaterial.setUpdateTime(LocalDateTime.now());
        if (!this.updateById(productMaterial)) {
            throw new ServiceException("修改物料失败");
        }
        log.info("修改物料成功 id={}", productMaterial.getId());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteProductMaterial(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new ServiceException("请选择至少一条数据");
        }
        if (!this.removeByIds(ids)) {
            throw new ServiceException("删除物料失败");
        }
        log.info("删除物料成功 ids={}", ids);
    }

    private void validateProductMaterial(ProductMaterial productMaterial, boolean requireId) {
        if (productMaterial == null) {
            throw new ServiceException("参数不能为空");
        }
        if (requireId && productMaterial.getId() == null) {
            throw new ServiceException("主键ID不能为空");
        }
        if (StringUtils.isEmpty(productMaterial.getProductName())) {
            throw new ServiceException("物料名称不能为空");
        }
    }

    private boolean existsMaterialName(String materialName, Long excludeId) {
        if (StringUtils.isEmpty(materialName)) {
            return false;
        }
        LambdaQueryWrapper<ProductMaterial> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductMaterial::getProductName, materialName);
        if (excludeId != null) {
            queryWrapper.ne(ProductMaterial::getId, excludeId);
        }
        return this.count(queryWrapper) > 0;
    }
}