/**
 * 值对象抽象类
 *
 */
public abstract class ValueObject {
}

/**
 * 字段型值对象
 *
 * 表示这个值对象会使用表字段来存储。
 *
 * 并不总是表示一个单一的字段, 可能是多个字段组合而成。
 * 
 * 你可以把枚举也看做值对象，但enum是没法继承这个类的。
 */
public abstract class FieldValueObject extends ValueObject {
}

/**
 * 对象关系映射型值对象
 *
 * 表示这个值对象会使用关系数据库映射的方式来存储。
 * 这里没有使用id，需要视情况而定
 */
public abstract class OrmValueObject extends ValueObject {

    /**
     * 创建时间
     */
    protected Date created;

    /**
     * 更新时间
     */
    protected Date lastModified;
}

/**
 * 实体抽象类
 * 封装了所有实体的通用属性
 */
public abstract class Entity {
    /**
     * id
     */
    protected Long id;

    /**
     * 创建时间
     */
    protected Date created;

    /**
     * 更新时间
     */
    protected Date lastModified;

    /**
     * 是否逻辑删除
     */
    protected Boolean deleted;
}

/**
 * 聚合根 
 */
public abstract class Aggregate extends Entity{
}

/**
 * 内容类目节点
 *
 */
public class Category extends Entity {

    /**
    * 名称
    */
    private String name;

    /**
    * 层级, 0表示根
    */
    private Integer level;

    /**
    * 父节点id, 如果不存在则为0
    */
    private Long parentId;

    /**
    * 根节点id, 如果是根节点则是它本身
    */
    private Long rootId;

    /**
    * 内容类型
    */
    private ContentTypeEnum contentType;

    /**
    * 节点状态
    * 0-下架，1上架 
    */
    private CategoryStatusEnum status;

    /**
    * 节点顺序, 有小到大递增
    */
    private Integer index;

    /**
     * 节点路径, 不含它自己
     * 用于冗余
     */
    private List<Long> path;

    public boolean isOff() {
        return status!=null && StringUtils.equals(status.getCode(), CategoryStatusEnum.OFF.getCode());
    }

    public boolean isOn() {
        return status!=null && StringUtils.equals(status.getCode(), CategoryStatusEnum.ON.getCode());
    }
}

/**
 * 类目节点上的内容
 *
 */
public class Content extends Entity {

    /**
    * 所属的类目id
    */
    private Long categoryId;

    /**
    * 所属类目节点的根id, 用于冗余查询
    */
    private Long rootId;

    /**
    * 内容id
    */
    private String contentId;

    /**
    * 内容类型
    */
    private ContentTypeEnum contentType;

    /**
    * 内容在类目树上的路径(id)，,用于冗余查询
    */
    private List<Long> path;
}

@Repository
public class CategoryRepository {
    @Resource
    private CategoryDAO categoryDAO;

    // 其他方法略

    /**
     * 创建根节点
     */
    @Transactional(rollbackFor = Exception.class)
    public long addRoot(Category category) {
        CategoryDO categoryDO = CategoryConverter.toDO(category);
        categoryDAO.insert(categoryDO);
        categoryDAO.updateRootId(categoryDO.getId());
        category.setId(categoryDO.getId());
        return categoryDO.getId();
    }
}

/**
 * 类目树 - 聚合根
 * 领域对象(树)的领域方法, 本身包含了操作节点的持久化管理, 即所有操作需要满足:
 * 对树及树的节点的操作, 内存中的对象必须和持久化的保持一致, 如果进行持久化, 内存中存在的也需要进行更新, 反之亦然
 *
 * 使用树进行操作, 需要注意不要在同一个流程中对同一个对象混用树和repository进行操作, 否则会发生数据不一致
 *
 */
public class CategoryTree extends Aggregate {

    /**
     * 类目树的根节点id
     */
    final private long rootId;

    /**
     * 类目节点缓存
     * 可能不是全部的节点都会缓存
     * key: 节点id
     * value: 节点
     */
    final private Map<Long, Category> nodeMap = Maps.newHashMap();

    /**
     * 节点仓储
     */
    final private CategoryRepository categoryRepository;

    /**
     * 节点内容仓储
     */
    final private ContentRepository contentRepository;

    /**
     * 节点并发锁
     */
    final private RedisLock redisLock;

    /**
     * 初始化, 数据懒加载
     *
     * @param rootId
     * @param categoryRepository
     * @param classifiedContentRepository
     * @param redisLock
     */
    public categoryTree(Long rootId, categoryRepository categoryRepository,
                               ContentRepository contentRepository, RedisLock redisLock) {
        this.rootId = rootId;
        this.deleted = false;
        this.categoryRepository = categoryRepository;
        this.contentRepository = contentRepository;
        this.redisLock = redisLock;
    }

   // 领域方法, 见下文
   ... ...
}

@Service
public class CategoryTreeFactory {

    @Resource
    private CategoryRepository categoryRepository;

    @Resource
    private ContentRepository contentRepository;

    @Resource
    private RedisLock redisLock;

    /**
     * 通过根构造(加载)树
     * @param rootId
     * @return
     */
    public ContentCategoryTree build(long rootId) {
        ContentCategory root = categoryRepository.loadOne(rootId);
        if(root == null) {
            throw new RuntimeException("根节点不存在");
        }
        if(root.getRootId() != rootId) {
            throw new RuntimeException("rootId对应的节点不是根节点");
        }
        return new CategoryTree(rootId, categoryRepository, contentRepository, redisLock);
    }

    /**
     * 通过节点构造(加载)类目树
     *
     * @param categoryId
     * @return
     */
    public CategoryTree buildByNode(long categoryId) {
        Category category = categoryRepository.loadOne(categoryId);
        if(category == null) {
            throw new RuntimeException("类目节点不存在");
        }
        return build(category.getRootId());
    }

    /**
     * 创建一个只有根的新树
     * @param name
     * @param contentType
     * @return
     */
    public CategoryTree buildNewTree(String name, ContentTypeEnum contentType) {
        int index = 1;
        Set<String> rootNameSet = Sets.newHashSet();
        List<ContentCategory> roots = contentCategoryRepository.loadRoots();
        if(!CollectionUtils.isEmpty(roots)) {
            // 获得新的根节点的顺序
            index = roots.get(roots.size()-1).getIndex() + 1;
            roots.forEach(p->rootNameSet.add(p.getName()));
        }
        // 以后改成按类型名称排序
        if(rootNameSet.contains(name)) {
            throw new RuntimeException("根节点名称重复");
        }

        Category root = new Category();
        root.setName(name);
        root.setStatus(CategoryStatusEnum.OFF);
        root.setContentType(contentType);
        root.setIndex(index);
        // 临时设置一个id，规避持久化问题
        root.setRootId(CategoryConstant.ROOT_PARENT_ID);
        root.setParentId(CategoryConstant.ROOT_PARENT_ID);
        root.setLevel(CategoryConstant.ROOT_LEVEL);
        root.setDeleted(false);
        long rootId = categoryRepository.addRoot(root);
        return build(rootId);
    }
}

/**
 * 类目操作方法接口
 * 只适用于单个节点
 *
 */
public interface CategorySingleOperation<R> {

    /**
     * 方法接口
     * @return
     */
    R process();
}

/**

• 类目操作方法接口
• 适用于遍历时的节点

/
public interface CategoryTraverseOperation {
/*
* 方法接口
* @return
*/
void process(Long categoryNodeId);
}

    /**
     * 对一个节点进行操作模板方法
     * @param func     具体的操作
     * @param nodeId   节点id
     * @param withLock 是否加互斥锁
     * @param <R>
     * @return
     */
    private <R> R executeForOneNode(Long nodeId, boolean withLock, CategorySingleOperation<R> func) {
        Category node = nodeMap.get(nodeId);
        if(node == null) {
            node = categoryRepository.loadOne(nodeId);
            nodeMap.put(nodeId, node);
        }
        if(node == null) {
            throw new RuntimeException("待处理的节点不存在");
        }

        if(withLock) {
            if(!redisLock.acquire(buildLockKey(nodeId), SystemConstants.CATEGORY_LOCK_TIME)) {
                throw new RuntimeException("并发锁获取失败");
            }
            R r = func.process();
            redisLock.release(buildLockKey(nodeId));
            return r;
        } else {
            return func.process();
        }
    }

    /**
     * 从一个节点开始, 自上而下逐层进行操作模板方法
     * @param func     具体的操作
     * @param nodeId   节点id
     * @param withLock 是否加互斥锁
     * @return
     */
    private void executeForDownUpByLevel(Long nodeId, boolean withLock, CategoryTraverseOperation func) {
        Category node = loadOne(nodeId);
        if(node == null) {
            throw new MeiJianException(PbdErrorCodeEnum.NO_DATA.getCode(), "节点不存在!");
        }

        // 按层组装节点
        LinkedList<Category> queueForTraverse = Lists.newLinkedList();
        LinkedList<Long> stackForHandle = Lists.newLinkedList();

        queueForTraverse.offer(node);
        while(!queueForTraverse.isEmpty()) {
            Category currentNode = queueForTraverse.poll();
            stackForHandle.push(currentNode.getId());
            List<Category> children = categoryRepository.loadByParentId(currentNode.getId());
            if(!CollectionUtils.isEmpty(children)) {
                children.forEach(queueForTraverse::offer);
            }
        }

        // 自底向上处理
        while(!stackForHandle.isEmpty()) {
            Long currentCategoryId = stackForHandle.pop();
            if(withLock) {
                if(!redisLock.acquire(buildLockKey(nodeId), SystemConstants.CATEGORY_LOCK_TIME)) {
                    throw new RuntimeException("并发锁获取失败");
                }
                func.process(currentCategoryId);
                redisLock.release(buildLockKey(nodeId));
            } else {
                func.process(currentCategoryId);
            }
        }
    }

    /**
     * 增加类目节点, 序号为父节点下最大值
     * @param parentId
     * @param name
     * @param contentType
     * @return
     */
    public Long addContentCategory(Long parentId, String name, ContentTypeEnum contentType) {
        return executeForOneNode(parentId, true,  () -> {
            int index = 0;
            Category parent = loadOne(parentId);
            List<Category> children = categoryRepository.loadByParentId(parent.getId());
            if(!CollectionUtils.isEmpty(children)) {
                for(Category child: children) {
                    if(child.getIndex() > index) {
                        index = child.getIndex();
                    }
                }
            }
            index++;
            return categoryRepository.add(buildCategory(name, contentType, parent, index));
        });
    }

    /**
     * 删除节点及节点上的内容
     * 为了防止脏数据, 从底向上删
     *
     * @param categoryId
     */
    public void deleteNodes(Long categoryId) {
        executeForDownUpByLevel(categoryId, false, currentCategoryId-> {
            contentRepository.deleteByCategoryId(currentCategoryId);
            categoryRepository.delete(currentCategoryId);
        });
    }