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.*;
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> typeStore = new ConcurrentHashMap<>();
    private final AtomicLong typeIdGen = new AtomicLong(1);

    /** 字典项存储 */
    private final Map<Long, DictItem> itemStore = new ConcurrentHashMap<>();
    private final AtomicLong itemIdGen = new AtomicLong(1);

    public DictService() {
        initMockData();
    }

    private void initMockData() {
        DictType dt1 = new DictType(1L, "性别", "gender", 1, "2024-01-01 00:00:00");
        DictType dt2 = new DictType(2L, "状态", "status", 1, "2024-01-01 00:00:00");
        typeStore.put(1L, dt1);
        typeStore.put(2L, dt2);

        itemStore.put(1L, new DictItem(1L, 1L, "男", "M", 1));
        itemStore.put(2L, new DictItem(2L, 1L, "女", "F", 2));
        itemStore.put(3L, new DictItem(3L, 2L, "启用", "1", 1));
        itemStore.put(4L, new DictItem(4L, 2L, "停用", "0", 2));

        typeIdGen.set(3);
        itemIdGen.set(5);
    }

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

    /**
     * 新增字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param dictType 字典类型信息
     * @return 已保存的字典类型
     */
    public DictType saveType(DictType dictType) {
        if (dictType.getTypeId() == null) {
            dictType.setTypeId(typeIdGen.getAndIncrement());
        }
        if (dictType.getCreateTime() == null) {
            dictType.setCreateTime(java.time.LocalDateTime.now().toString().replace("T", " "));
        }
        if (dictType.getStatus() == null) {
            dictType.setStatus(1);
        }
        typeStore.put(dictType.getTypeId(), dictType);
        return dictType;
    }

    /**
     * 编辑字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param dictType 包含更新信息的字典类型
     * @return 更新后的字典类型
     */
    public DictType updateType(DictType dictType) {
        DictType existing = typeStore.get(dictType.getTypeId());
        if (existing == null) return null;
        if (dictType.getTypeName() != null) existing.setTypeName(dictType.getTypeName());
        if (dictType.getTypeCode() != null) existing.setTypeCode(dictType.getTypeCode());
        if (dictType.getStatus() != null) existing.setStatus(dictType.getStatus());
        return existing;
    }

    /**
     * 删除字典类型。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param typeId 字典类型ID
     * @return 是否删除成功
     */
    public boolean deleteTypeById(Long typeId) {
        // 同时删除该类型下的所有字典项
        itemStore.values().removeIf(item -> item.getTypeId().equals(typeId));
        return typeStore.remove(typeId) != null;
    }

    /**
     * 查询字典类型列表。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param typeName 类型名称（可选，模糊匹配）
     * @return 字典类型列表
     */
    public List<DictType> listTypes(String typeName) {
        return typeStore.values().stream()
                .filter(t -> typeName == null || t.getTypeName().contains(typeName))
                .collect(Collectors.toList());
    }

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

    /**
     * 新增字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param dictItem 字典项信息
     * @return 已保存的字典项
     */
    public DictItem saveItem(DictItem dictItem) {
        if (dictItem.getItemId() == null) {
            dictItem.setItemId(itemIdGen.getAndIncrement());
        }
        itemStore.put(dictItem.getItemId(), dictItem);
        return dictItem;
    }

    /**
     * 编辑字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param dictItem 包含更新信息的字典项
     * @return 更新后的字典项
     */
    public DictItem updateItem(DictItem dictItem) {
        DictItem existing = itemStore.get(dictItem.getItemId());
        if (existing == null) return null;
        if (dictItem.getItemLabel() != null) existing.setItemLabel(dictItem.getItemLabel());
        if (dictItem.getItemValue() != null) existing.setItemValue(dictItem.getItemValue());
        if (dictItem.getSortOrder() != null) existing.setSortOrder(dictItem.getSortOrder());
        if (dictItem.getTypeId() != null) existing.setTypeId(dictItem.getTypeId());
        return existing;
    }

    /**
     * 删除字典项。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param itemId 字典项ID
     * @return 是否删除成功
     */
    public boolean deleteItemById(Long itemId) {
        return itemStore.remove(itemId) != null;
    }

    /**
     * 根据字典类型ID查询字典项列表。
     *
     * @requirement(name="字典管理", id="SRS-F-01-004")
     * @param typeId 字典类型ID
     * @return 字典项列表
     */
    public List<DictItem> listItems(Long typeId) {
        return itemStore.values().stream()
                .filter(item -> item.getTypeId().equals(typeId))
                .sorted(Comparator.comparingInt(DictItem::getSortOrder))
                .collect(Collectors.toList());
    }
}
