/**
 * Copyright (C) 2014-2050 SOUI团队
 * All rights reserved.
 * 
 * @file       stree.hpp
 * @brief      树模板--提供对一般的数据类型实现树结构
 * @version    v1.0      
 * @author     soui      
 * @date       2014-07-13
 * 
 * Describe    此类是下拉窗口的父类 只需要派生该类即可
 *
 *              version: 1.0　2003-10-24 实现基本功能
 *                       2.0  2004-12-29 增加两个遍历接口，修改内存释放部分可能存在的bug
 *                       2.1  2006-10-17 为节点增加一个hChildLast数据,以加快在数据插入时的速度
 *                       2.2  2008-10-16 修改一个遍历接口的问题
 *                       2.3  2011-10-17 将数据释放的接口从回调函数改成虚函数
 */
#if !defined(AFX_STREE_H__D2332B4E_2C7E_4357_BE22_EC55BF496C1C__INCLUDED_)
#define AFX_STREE_H__D2332B4E_2C7E_4357_BE22_EC55BF496C1C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef SASSERT
#define SASSERT(x)
#endif

//typedef ULONG_PTR HSTREEITEM;

#define STVI_ROOT    ((HSTREEITEM)0xFFFF0000)//=TVI_ROOT
#define STVI_FIRST    ((HSTREEITEM)0xFFFF0001)//=TVI_FIRST
#define STVI_LAST    ((HSTREEITEM)0xFFFF0002)//=TVI_LAST
#define STVN_ROOT    ((HSTREENODE)(ULONG_PTR)0xFFFF0000)//=STVN_ROOT
#define STVN_FIRST    ((HSTREENODE)(ULONG_PTR)0xFFFF0001)//=STVN_FIRST
#define STVN_LAST    ((HSTREENODE)(ULONG_PTR)0xFFFF0002)//=STVN_LAST
#define STVL_ROOT    ((PSTREELINK)(ULONG_PTR)0xFFFF0000)

/**
 * @class      CSTree 模板类
 * @brief      CSTree 模板类
 * 
 * Describe    CSTree 模板类
 */
template<class T>
class CSTree  
{
    /**
     * @class      _STREENODE
     * @brief      节点结构体
     * 
     * Describe    节点结构体
     */
    typedef struct _STREENODE{
        struct _STREENODE *hParent;      /**< 父节点 */
        struct _STREENODE *hChildFirst;  /**< 第一个子节点 */
        struct _STREENODE *hChildLast;   /**< 最后一个子节点 */
        struct _STREENODE *hPrevSibling; /**< 兄节点 */
        struct _STREENODE *hNextSibling; /**< 弟节点 */
        T data;                          /**< 数据 */
    }STREENODE,*HSTREENODE;

    /**
     * @class      _STREELINK
     * @brief      树结点的链接
     * 
     * Describe    此结构体用于连接树节点
     */
    typedef struct _STREELINK{
        HSTREENODE  hParent;       /**< 父节点 */
        HSTREENODE  hChildFirst;   /**< 第一个子节点 */
        HSTREENODE  hChildLast;    /**< 最后一个子节点 */
        HSTREENODE  hPrevSibling;  /**< 兄节点 */
        HSTREENODE  hNextSibling;  /**< 弟节点 */
    }STREELINK,*PSTREELINK;
    
    /**
     * 回调函数
     * @brief    下拉窗口鼠标左键按下事件
     * @param    T *:当前遍历到的结点的数据
     * @param    LPARAM:回调时使用的参数
     * @return   FALSE－继续，TRUE－中断遍历
     *
     * Describe  遍历一个树结点的回调函数原型，
     */
    typedef BOOL (*CBTRAVERSING)(T*,LPARAM);

public:
    /**
     * CSTree::CSTree
     * @brief    构造函数
     *
     * Describe  构造函数
     */  
    CSTree()
    {
        m_hRootFirst=NULL;
        m_hRootLast=NULL;
    }

    /**
     * CSTree::~CSTree
     * @brief    析构函数
     *
     * Describe  析构函数
     */ 
    virtual ~CSTree(){DeleteAllItems();}

    /**
     * CSTree::DeleteAllItems
     * @brief    删除所有节点
     *
     * Describe  删除所有节点
     */
    void DeleteAllItems(){
        if(m_hRootFirst)
        {
            FreeNode(STVN_ROOT);
            m_hRootFirst=NULL;
            m_hRootLast=NULL;
        }
    }
    
    /**
     * CSTree::GetNextSiblingItem
     * @brief    获取下一个兄弟
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回HSTREEITEM
     *
     * Describe  获取下一个兄弟
     */
    static HSTREEITEM GetNextSiblingItem(HSTREEITEM hItem){
        PSTREELINK pLink= (PSTREELINK)hItem;
        SASSERT(pLink&&pLink!=STVL_ROOT);
        return (HSTREEITEM)pLink->hNextSibling;
    }

    /**
     * CSTree::GetPrevSiblingItem
     * @brief    获取上一个兄弟
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回HSTREEITEM
     *
     * Describe  获取上一个兄弟
     */
    static HSTREEITEM GetPrevSiblingItem(HSTREEITEM hItem)
    {
        PSTREELINK pLink= (PSTREELINK)hItem;
        SASSERT(pLink&&pLink!=STVL_ROOT);
        return (HSTREEITEM)pLink->hPrevSibling;
    }
    
    /**
     * CSTree::GetParentItem
     * @brief    获取父结点
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回HSTREEITEM
     *
     * Describe  获取父结点
     */
    static HSTREEITEM GetParentItem(HSTREEITEM hItem)
    {
        PSTREELINK pLink= (PSTREELINK)hItem;
        SASSERT(pLink&&pLink!=STVL_ROOT);
        return (HSTREEITEM)pLink->hParent;
    }
    
    /**
     * CSTree::GetItemLevel
     * @brief    获取结点层数
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回int
     *
     * Describe  获取结点层数
     */
    static int GetItemLevel(HSTREEITEM hItem)
    {
        int nRet=-1;
        if(hItem==STVI_ROOT) hItem=NULL;
        while(hItem)
        {
            nRet++;
            hItem=GetParentItem(hItem);
        }
        return nRet;
    }
    
    /**
     * GetRootItem
     * @brief    获取指定节点的根节点
     * @param    HSTREEITEM hItem -- 当前节点 
     * @return   HSTREEITEM 根节点
     *
     * Describe  
     */
    static HSTREEITEM GetRootItem(HSTREEITEM hItem)
    {
        HSTREEITEM hParent=hItem;
        while(GetParentItem(hParent))
        {
            hParent = GetParentItem(hParent);
        }
        return hParent;
    }
    
    /**
     * CSTree::GetChildItem
     * @brief    获取第一个子结点
     * @param    HSTREEITEM hItem  -- 节点
     * @param    BOOL bFirst       -- 是否第一个节点
     * @return   返回HSTREEITEM
     *
     * Describe  获取第一个子结点
     */
    HSTREEITEM GetChildItem(HSTREEITEM hItem,BOOL bFirst=TRUE) const
    {
        HSTREENODE hsNode= (HSTREENODE)hItem;
        SASSERT(hsNode);
        if(hsNode==STVN_ROOT)
        {
            if(bFirst)
                return (HSTREEITEM)m_hRootFirst;
            else
                return (HSTREEITEM)m_hRootLast;
        }
        else
        {
            if(bFirst)
                return (HSTREEITEM)hsNode->hChildFirst;
            else
                return (HSTREEITEM)hsNode->hChildLast;
        }
    }
    
    /**
     * CSTree::GetChildrenCount
     * @brief    获取子结点数量
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回int
     *
     * Describe  获取子结点数量
     */
    int GetChildrenCount(HSTREEITEM hItem) const
    {
        int nRet=0;
        HSTREEITEM hChild=GetChildItem(hItem);
        while(hChild)
        {
            nRet++;
            hChild=GetNextSiblingItem(hChild);
        }
        return nRet;
    }

    /**
     * CSTree::DeleteItem
     * @brief    删除一个节点，可以被派生类重载
     * @param    HSTREEITEM hItem  -- 节点
     *
     * Describe  删除一个节点，可以被派生类重载
     */
    virtual void DeleteItem(HSTREEITEM hItem)
    {
        HSTREENODE hsNode= (HSTREENODE)hItem;
        SASSERT(hsNode);
        if(hsNode==STVN_ROOT)
        {
            FreeNode(STVN_ROOT);
            m_hRootFirst=NULL;
            m_hRootLast=NULL;
            return;
        }
        STREENODE nodeCopy=*hsNode;
        BOOL bRootFirst=hsNode==m_hRootFirst;
        BOOL bRootLast=hsNode==m_hRootLast;
        FreeNode(hsNode);

        if(nodeCopy.hPrevSibling)//has prevsibling
            nodeCopy.hPrevSibling->hNextSibling=nodeCopy.hNextSibling;
        else if(nodeCopy.hParent)//parent's first child
            nodeCopy.hParent->hChildFirst=nodeCopy.hNextSibling;
        if(nodeCopy.hNextSibling)// update next sibling's previous sibling
            nodeCopy.hNextSibling->hPrevSibling=nodeCopy.hPrevSibling;
        else if(nodeCopy.hParent)//parent's last child
            nodeCopy.hParent->hChildLast=nodeCopy.hPrevSibling;
        //update root item
        if(bRootFirst)    m_hRootFirst=nodeCopy.hNextSibling;
        if(bRootLast)   m_hRootLast=nodeCopy.hPrevSibling;
    }

    /**
     * CSTree::DeleteItemEx
     * @brief    删除一个结点分枝，如果该结点的父结点没有其它子节点则一起删除
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回BOOL
     *
     * Describe  删除一个结点分枝，如果该结点的父结点没有其它子节点则一起删除
     */
    BOOL DeleteItemEx(HSTREEITEM hItem)
    {
        if(GetChildItem(hItem)) return FALSE;
        while(hItem && !GetChildItem(hItem))
        {
            HSTREEITEM hParent=GetParentItem(hItem);
            DeleteItem(hItem);
            hItem=hParent;
        }
        return TRUE;
    }

    /**
     * CSTree::GetItem
     * @brief    获取结点中保存的数据
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回T
     *
     * Describe  获取结点中保存的数据
     */
    static T GetItem(HSTREEITEM hItem){
        SASSERT(hItem!=STVI_ROOT);
        HSTREENODE hsNode= (HSTREENODE)hItem;
        SASSERT(hsNode);
        return hsNode->data;
    }
    
    /**
     * CSTree::GetItem
     * @brief    获取结点中保存的数据
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回T
     *
     * Describe  获取结点中保存的数据
     */
    static T& GetItemRef(HSTREEITEM hItem){
        SASSERT(hItem!=STVI_ROOT);
        HSTREENODE hsNode= (HSTREENODE)hItem;
        SASSERT(hsNode);
        return hsNode->data;
    }
    
    /**
     * CSTree::GetItemPt
     * @brief    获取结点中保存的数据
     * @param    HSTREEITEM hItem  -- 节点
     * @return   返回T*
     *
     * Describe  获取结点中保存的数据
     */
    static T *GetItemPt(HSTREEITEM hItem){
        SASSERT(hItem!=STVI_ROOT);
        HSTREENODE hsNode= (HSTREENODE)hItem;
        SASSERT(hsNode);
        return &hsNode->data;
    }

    /**
     * CSTree::InsertItem
     * @brief    插入一个新结点
     * @param    const T &data -- 结点数据
     * @param    HSTREEITEM hParent -- 新结点的父结点
     * @param    HSTREEITEM hInsertAfter -- 新结点的前一个兄弟结点
     * @return   返回HSTREEITEM 新结点的指针
     *
     * Describe  获取结点中保存的数据
     */
    HSTREEITEM InsertItem(const T &data,HSTREEITEM hParent=STVI_ROOT,HSTREEITEM hInsertAfter=STVI_LAST){
        HSTREENODE hParentNode=(HSTREENODE) hParent;
        HSTREENODE hInsertAfterNode=(HSTREENODE) hInsertAfter;
        if(hParentNode==STVN_ROOT)
            hParentNode=NULL;
        SASSERT(hInsertAfter);
        if(hInsertAfterNode!=STVN_FIRST && hInsertAfterNode!=STVN_LAST)
        {
            if(hInsertAfterNode->hParent!=hParentNode) return NULL;
            if(hInsertAfterNode->hNextSibling==NULL) hInsertAfterNode=STVN_LAST;
        }

        HSTREENODE hInserted=new STREENODE;
        hInserted->data=data;
        hInserted->hParent=hParentNode;
        hInserted->hChildFirst=NULL;
        hInserted->hChildLast=NULL;

        if(hInsertAfterNode==STVN_FIRST)
        {
            hInserted->hPrevSibling=NULL;
            if(hParentNode==NULL)//root
            {
                hInserted->hNextSibling=m_hRootFirst;
                if(m_hRootFirst) m_hRootFirst->hPrevSibling=hInserted;
                m_hRootFirst=hInserted;
                if(m_hRootLast==NULL) m_hRootLast=hInserted;
            }else    //has parent
            {
                hInserted->hNextSibling=hParentNode->hChildFirst;
                if(hInserted->hNextSibling)
                {
                    hInserted->hNextSibling->hPrevSibling=hInserted;
                    hParentNode->hChildFirst=hInserted;
                }else
                {
                    hParentNode->hChildLast=hParentNode->hChildFirst=hInserted;
                }
            }
        }else if(hInsertAfterNode==STVN_LAST)
        {
            hInserted->hNextSibling=NULL;
            if(hParentNode==NULL)//root
            {
                hInserted->hPrevSibling=m_hRootLast;
                if(m_hRootLast) m_hRootLast->hNextSibling=hInserted;
                m_hRootLast=hInserted;
                if(!m_hRootFirst) m_hRootFirst=hInserted;
            }else
            {
                hInserted->hPrevSibling=hParentNode->hChildLast;
                if(hParentNode->hChildLast) 
                {
                    hInserted->hPrevSibling->hNextSibling=hInserted;
                    hParentNode->hChildLast=hInserted;
                }else
                {
                    hParentNode->hChildLast=hParentNode->hChildFirst=hInserted;
                }                
            }
        }else
        {
            HSTREENODE hNextSibling=hInsertAfterNode->hNextSibling;
            hInserted->hPrevSibling=hInsertAfterNode;
            hInserted->hNextSibling=hNextSibling;
            hNextSibling->hPrevSibling = hInsertAfterNode->hNextSibling = hInserted;
        }
        return (HSTREEITEM)hInserted;
    }

    /**
     * CSTree::TraversingRecursion
     * @brief    采用递归方式遍历一个树结点
     * @param    HSTREEITEM hItem -- 起始结点
     * @param    CBTRAVERSING funTraversing -- 执行实际操作的回调函数
     * @param    LPARAM lParam -- 回调时使用的参数
     * @return   返回HSTREEITEM
     *
     * Describe  采用递归方式遍历一个树结点
     */
    HSTREEITEM TraversingRecursion(HSTREEITEM hItem,CBTRAVERSING funTraversing,LPARAM lParam)
    {
        SASSERT(hItem);
        if(hItem!=STVI_ROOT)
        {
            if(funTraversing(GetItemPt(hItem),lParam)) return hItem;
        }
        HSTREEITEM hChild=GetChildItem(hItem);
        while(hChild)
        {
            HSTREEITEM hTmp=GetChildItem(hChild);
            if(hTmp)
            {
                HSTREEITEM hRet=TraversingRecursion(hTmp,funTraversing,lParam);
                if(hRet) return hRet;
            }else
            {
                if(funTraversing(GetItemPt(hChild),lParam)) return hChild;
            }
            hChild=GetNextSiblingItem(hChild);
        }
        return NULL;
    }
   
    /**
     * CSTree::TraversingSequence
     * @brief    按顺序方式从指定结点开始查找后面的结点，包括自己的子节点及自己向下的兄弟结点
     * @param    HSTREEITEM hItem -- 起始结点
     * @param    CBTRAVERSING funTraversing -- 执行实际操作的回调函数
     * @param    LPARAM lParam -- 回调时使用的参数
     * @return   返回HSTREEITEM
     *
     * Describe  按顺序方式从指定结点开始查找后面的结点，包括自己的子节点及自己向下的兄弟结点
     */
    HSTREEITEM TraversingSequence(HSTREEITEM hItem,CBTRAVERSING funTraversing,LPARAM lParam)
    {
        if(!m_hRootFirst) return NULL;
        if(hItem!=STVI_ROOT)
        {
            if(funTraversing(GetItemPt(hItem),lParam)) return hItem;
        }
        HSTREEITEM hNext=GetNextItem(hItem);
        while(hNext)
        {
            if(funTraversing(GetItemPt(hNext),lParam)) return hNext;
            hNext=GetNextItem(hNext);
        }
        return NULL;
    }

    /**
     * CSTree::GetRootItem
     * @brief    获取根节点
     * @param    BOOL bFirst -- 是否从根节点
     * @return   返回HSTREEITEM 
     *
     * Describe  获取根节点
     */
    HSTREEITEM GetRootItem(BOOL bFirst=TRUE){
        return (HSTREEITEM)(bFirst?m_hRootFirst:m_hRootLast);
    }

    /**
     * CSTree::GetDesendants
     * @brief    获取结点的子孙结点数
     * @param    HSTREEITEM hItem -- 起始结点
     * @return   返回int
     *
     * Describe  获取结点的子孙结点数
     */
    int GetDesendants(HSTREEITEM hItem)
    {
        int nRet=0;
        HSTREEITEM hChild=GetChildItem(hItem);
        while(hChild)
        {
            nRet += 1+GetDesendants(hChild);
            hChild=GetNextSiblingItem(hChild);
        }
        return nRet;
    }

    /**
     * CSTree::GetNextItem
     * @brief    获取当前结点的下一个结点
     * @param    HSTREEITEM hItem -- 当前结点
     * @return   返回HSTREEITEM  当前结点的下一个结点
     *
     * Describe  获取当前结点的下一个结点
     * 如果当前结点有子结点，则返回自己的第一个子结点，
     * 否则如果有向下的兄弟结点，则返回自己向下兄弟结点、
     * 否则搜索自己的父结点的向下兄弟结点
     */
    HSTREEITEM GetNextItem(HSTREEITEM hItem) const
    {
        if(hItem==STVI_ROOT) return (HSTREEITEM)m_hRootFirst;

        HSTREEITEM hRet=GetChildItem(hItem);
        if(hRet) return hRet;
        HSTREEITEM hParent=hItem;
        while(hParent)
        {
            hRet=GetNextSiblingItem(hParent);
            if(hRet) return hRet;
            hParent=GetParentItem(hParent);
        }
        return NULL;
    }

    /**
     * CSTree::GetNextItem
     * @brief    获取当前结点的下一个结点
     * @param    HSTREEITEM hItem -- 当前结点
     * @param    int &nLevel -- 当前结点(hItem)与目标结点(return)的层次关系,
     *                          1-父子关系，0－兄弟关系，-n－子->父的兄弟
     * @return   返回HSTREEITEM  当前结点的下一个结点
     *
     * Describe  获取当前结点的下一个结点
     *           如果当前结点有子结点，则返回自己的第一个子结点，
     *           否则如果有向下的兄弟结点，则返回自己向下兄弟结点、
     *           否则搜索自己的父结点的向下兄弟结点
     */
    HSTREEITEM GetNextItem(HSTREEITEM hItem,int &nLevel) const
    {
        if(hItem==STVI_ROOT)
        {
            nLevel=1;
            return (HSTREEITEM)m_hRootFirst;
        }

        HSTREEITEM hRet=GetChildItem(hItem);
        if(hRet)
        {
            nLevel=1;
            return hRet;
        }
        HSTREEITEM hParent=hItem;
        nLevel=0;
        while(hParent)
        {
            hRet=GetNextSiblingItem(hParent);
            if(hRet) return hRet;
            nLevel--;
            hParent=GetParentItem(hParent);
        }
        return NULL;
    }
        
    void SortChildren(HSTREEITEM hItem,int (__cdecl *funSort)(void *,const void *,const void *), void * pCtx)
    {
        int nChilds = GetChildrenCount(hItem);
        if(nChilds>1)
        {
            HSTREEITEM *pChilds = new HSTREEITEM[nChilds];
            HSTREEITEM hChild = GetChildItem(hItem);
            pChilds[0] = hChild;
            for(int i=1;i<nChilds;i++)
            {
                 hChild = GetNextSiblingItem(hChild);
                 pChilds[i]= hChild;
            }
            //调用qsort排序
            qsort_s(pChilds,nChilds,sizeof(HSTREEITEM),funSort,pCtx);
            //重新整理链表
            for(int i=0;i<nChilds-1;i++)
            {
                HSTREENODE node = (HSTREENODE)pChilds[i];
                node->hNextSibling = (HSTREENODE)pChilds[i+1];
            }
            for(int i=1;i<nChilds;i++)
            {
                HSTREENODE node = (HSTREENODE)pChilds[i];
                node->hPrevSibling = (HSTREENODE)pChilds[i-1];
            }
            HSTREENODE node = (HSTREENODE)pChilds[0];
            node->hPrevSibling = NULL;
            node = (HSTREENODE)pChilds[nChilds-1];
            node->hNextSibling = NULL;
            if(hItem!=STVI_ROOT)
            {
                HSTREENODE parent = (HSTREENODE)hItem;
                parent->hChildFirst = (HSTREENODE)pChilds[0];
                parent->hChildLast = (HSTREENODE)pChilds[nChilds-1];
            }else
            {
                m_hRootFirst = (HSTREENODE)pChilds[0];
                m_hRootLast = (HSTREENODE)pChilds[nChilds-1];
            }
            delete []pChilds;
            
        }
        //子节点排序
        HSTREEITEM hChild = GetChildItem(hItem);
        while(hChild)
        {
            HSTREENODE node = (HSTREENODE)hChild;
            if(node->hChildFirst && node->hChildLast && node->hChildFirst != node->hChildLast)
            {
                SortChildren(hChild,funSort,pCtx);
            }
            hChild = GetNextSiblingItem(hChild);
        }

    }
private:
    /**
     * CSTree::FreeNode
     * @brief    采用后序遍历的方式释放结点占用的空间
     * @param    HSTREENODE hsNode -- 当前结点
     *
     * Describe  采用后序遍历的方式释放结点占用的空间
     */
    void FreeNode(HSTREENODE hsNode)
    {
        SASSERT(hsNode);
        HSTREENODE hSibling=(HSTREENODE)GetChildItem((HSTREEITEM)hsNode);
        while(hSibling)
        {
            HSTREENODE hNextSibling=hSibling->hNextSibling;
            FreeNode(hSibling);
            hSibling=hNextSibling;
        }
        if(hsNode!=STVN_ROOT)
        {
            OnNodeFree(hsNode->data);
            delete hsNode;
        }
    }

protected:
    /**
     * CSTree::OnNodeFree
     * @brief    在派生类中实现数据的释放操作
     * @param    T & data -- 数据
     *
     * Describe  在派生类中实现数据的释放操作
     */
    virtual void OnNodeFree(T & data){}

    HSTREENODE  m_hRootFirst;  /**< 第一个根节点 */
    HSTREENODE  m_hRootLast;   /**< 最后一个根节点 */
};

#endif // !defined(AFX_STREE_H__D2332B4E_2C7E_4357_BE22_EC55BF496C1C__INCLUDED_)