package com.example.demo.service;

import com.example.demo.model.DictItem;
import com.example.demo.model.DictType;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;

/**
 * 字典管理服务。
 * <p>支持数据字典的维护，包括字典类型和字典项的新增、编辑、删除、查询。</p>
 */
@Service
public class DictService {

    private final Map<Long, DictType> typeMap = new ConcurrentHashMap<>();
    private final Map<Long, DictItem> itemMap = new ConcurrentHashMap<>();
    private final AtomicLong typeIdCounter = new AtomicLong(1);
    private final AtomicLong itemIdCounter = new AtomicLong(1);

    public DictService() {
        long t1 = typeIdCounter.getAndIncrement();
        typeMap.put(t1, new DictType(t1, "业务类型", "business_type", 1));
        long t2 = typeIdCounter.getAndIncrement();
        typeMap.put(t2, new DictType(t2, "用户状态", "user_status", 1));

        itemMap.put(itemIdCounter.getAndIncrement(), new DictItem(1L, t1, "请假", "leave", 1));
        itemMap.put(itemIdCounter.getAndIncrement(), new DictItem(2L, t1, "报销", "expense", 2));
        itemMap.put(itemIdCounter.getAndIncrement(), new DictItem(3L, t1, "采购", "purchase", 3));
        itemMap.put(itemIdCounter.getAndIncrement(), new DictItem(4L, t2, "启用", "1", 1));
        itemMap.put(itemIdCounter.getAndIncrement(), new DictItem(5L, t2, "停用", "0", 2));
    }

    // ========== 字典类型 CRUD ==========

    /**
     * 新增字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 创建新的字典类型。
     */
    public DictType addDictType(DictType type) {
        long id = typeIdCounter.getAndIncrement();
        type.setId(id);
        if (type.getStatus() == null) type.setStatus(1);
        typeMap.put(id, type);
        return type;
    }

    /**
     * 编辑字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 修改已有字典类型的信息。
     */
    public DictType editDictType(DictType type) {
        DictType existing = typeMap.get(type.getId());
        if (existing == null) throw new RuntimeException("字典类型不存在");
        if (type.getTypeName() != null) existing.setTypeName(type.getTypeName());
        if (type.getTypeCode() != null) existing.setTypeCode(type.getTypeCode());
        if (type.getStatus() != null) existing.setStatus(type.getStatus());
        return existing;
    }

    /**
     * 删除字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 根据ID删除字典类型。
     */
    public void deleteDictType(Long id) {
        if (!typeMap.containsKey(id)) throw new RuntimeException("字典类型不存在");
        // 同时删除该类型下的所有字典项
        itemMap.values().removeIf(item -> item.getTypeId() != null && item.getTypeId().equals(id));
        typeMap.remove(id);
    }

    /**
     * 查询字典类型列表。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 返回所有字典类型。
     */
    public List<DictType> listDictTypes() {
        return new ArrayList<>(typeMap.values());
    }

    // ========== 字典项 CRUD ==========

    /**
     * 新增字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 为指定字典类型添加字典项。
     */
    public DictItem addDictItem(DictItem item) {
        if (!typeMap.containsKey(item.getTypeId())) throw new RuntimeException("字典类型不存在");
        long id = itemIdCounter.getAndIncrement();
        item.setId(id);
        itemMap.put(id, item);
        return item;
    }

    /**
     * 编辑字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 修改字典项的信息。
     */
    public DictItem editDictItem(DictItem item) {
        DictItem existing = itemMap.get(item.getId());
        if (existing == null) throw new RuntimeException("字典项不存在");
        if (item.getItemLabel() != null) existing.setItemLabel(item.getItemLabel());
        if (item.getItemValue() != null) existing.setItemValue(item.getItemValue());
        if (item.getSortOrder() != null) existing.setSortOrder(item.getSortOrder());
        if (item.getTypeId() != null) existing.setTypeId(item.getTypeId());
        return existing;
    }

    /**
     * 删除字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 根据ID删除字典项。
     */
    public void deleteDictItem(Long id) {
        if (!itemMap.containsKey(id)) throw new RuntimeException("字典项不存在");
        itemMap.remove(id);
    }

    /**
     * 查询字典项列表（按类型ID）。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * 根据字典类型ID查询其下所有字典项。
     */
    public List<DictItem> listDictItems(Long typeId) {
        return itemMap.values().stream()
                .filter(item -> item.getTypeId() != null && item.getTypeId().equals(typeId))
                .collect(Collectors.toList());
    }
}
