#include "stdafx.h"
#include "PortsPage.h"
#include "ClusterPortsDlg.h"
#include "HostPortsDlg.h"
#include "Document.h"
#include "wlbsparm.h"
#include "ResourceString.h"
#include "MNLBUIData.h"

#include <vector>
#include <map>
#include <algorithm>
using namespace std;

BEGIN_MESSAGE_MAP(PortsPage, CPropertyPage)
    ON_BN_CLICKED(IDC_BUTTON_ADD, OnButtonAdd)
    ON_BN_CLICKED(IDC_BUTTON_DEL, OnButtonDel)
    ON_BN_CLICKED(IDC_BUTTON_MODIFY, OnButtonModify)
    ON_NOTIFY( NM_DBLCLK, IDC_LIST_PORT_RULE, OnDoubleClick )
    ON_NOTIFY( LVN_ITEMCHANGED, IDC_LIST_PORT_RULE, OnSelchanged )
    ON_NOTIFY( LVN_COLUMNCLICK, IDC_LIST_PORT_RULE, OnColumnClick )
    ON_WM_HELPINFO()        
    ON_WM_CONTEXTMENU()        
    END_MESSAGE_MAP()

    PortsPage::PortData::PortData()
{
    wchar_t buf[Common::BUF_SIZE];
    swprintf( buf, L"%d", CVY_MIN_PORT );
    start_port = buf;

    swprintf( buf, L"%d", CVY_MAX_PORT );
    end_port = buf;

    protocol = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH );
    mode = GETRESOURCEIDSTRING( IDS_REPORT_MODE_MULTIPLE );
    load = GETRESOURCEIDSTRING( IDS_REPORT_LOAD_EQUAL );
    affinity = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_SINGLE );
}


PortsPage::PortsPage( ClusterData*        p_clusterData,
                      UINT                ID)
        : m_clusterData( p_clusterData ),
          m_isClusterLevel( true ),
          CPropertyPage(ID),
          m_sort_column( -1 )
{}

PortsPage::PortsPage( const _bstr_t&       myMachineName,
                      ClusterData*        p_clusterData,
                      UINT                ID)
        : m_clusterData( p_clusterData ),
          machine( myMachineName ),
          m_isClusterLevel( false ),
          CPropertyPage(ID),
          m_sort_column( -1 )
{}


PortsPage:: ~PortsPage()
{}

void PortsPage::DoDataExchange(CDataExchange* pDX)
{
    CPropertyPage::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_LIST_PORT_RULE, m_portList);

    DDX_Control(pDX, IDC_BUTTON_ADD, buttonAdd );

    DDX_Control(pDX, IDC_BUTTON_MODIFY, buttonModify );

    DDX_Control(pDX, IDC_BUTTON_DEL, buttonDel );
}

void
PortsPage::OnOK()
{
    CPropertyPage::OnOK();
}

BOOL
PortsPage::OnKillActive()
{
    // get present port rules
    vector<PortData> ports;
    getPresentPorts( &ports );
    
    // now form the new port structure.
    PortDataELB elbPortRule;
    PortDataULB ulbPortRule;
    PortDataF   fPortRule;
    PortDataD   dPortRule;

    map< long, PortDataELB> portELB;
    map< long, PortDataULB> portULB;
    map< long, PortDataD> portD;
    map< long, PortDataF> portF;

    for( int i = 0; i < ports.size(); ++i )
    {
        // check which type of port rule it is.
        //

        if( ports[i].mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_MULTIPLE )
            &&
            ports[i].load == GETRESOURCEIDSTRING( IDS_REPORT_LOAD_EQUAL )
            )
        {
            // equal load balanced
            elbPortRule._startPort = _wtoi( ports[i].start_port );

            elbPortRule._endPort = _wtoi( ports[i].end_port );

            if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH ) )
            {
                elbPortRule._trafficToHandle = MNLBPortRule::both;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP ) )
            {
                elbPortRule._trafficToHandle = MNLBPortRule::tcp;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP ) )
            {
                elbPortRule._trafficToHandle = MNLBPortRule::udp;
            }

            if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_NONE ) )
            {
                elbPortRule._affinity = MNLBPortRule::none;
            }
            else if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_SINGLE ) )
            {
                elbPortRule._affinity = MNLBPortRule::single;
            }
            else if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_CLASSC ) )
            {
                elbPortRule._affinity = MNLBPortRule::classC;
            }

            elbPortRule._key = elbPortRule._startPort;

            portELB[ elbPortRule._startPort ] = elbPortRule;
        }
        else if( ports[i].mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_MULTIPLE )
                 &&
                 ports[i].load != GETRESOURCEIDSTRING( IDS_REPORT_LOAD_EQUAL )
                 )
        {
            // unequal load balanced
            ulbPortRule._startPort = _wtoi( ports[i].start_port );

            ulbPortRule._endPort = _wtoi( ports[i].end_port );

            if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH ) )
            {
                ulbPortRule._trafficToHandle = MNLBPortRule::both;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP ) )
            {
                ulbPortRule._trafficToHandle = MNLBPortRule::tcp;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP ) )
            {
                ulbPortRule._trafficToHandle = MNLBPortRule::udp;
            }

            if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_NONE ) )
            {
                ulbPortRule._affinity = MNLBPortRule::none;
            }
            else if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_SINGLE ) )
            {
                ulbPortRule._affinity = MNLBPortRule::single;
            }
            else if( ports[i].affinity == GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_CLASSC ) )
            {
                ulbPortRule._affinity = MNLBPortRule::classC;
            }

            if( ports[i].key == -1 
                ||
                ( m_clusterData->portULB.find( ports[i].key )
                  ==
                  m_clusterData->portULB.end() )
                )
            {
                // new port rule.

                // user may change the rule completely if so
                // consider it as new.
                if( m_isClusterLevel == true )
                {
                    map< _bstr_t, HostData >::iterator top;
                    for( top = m_clusterData->hosts.begin();
                         top != m_clusterData->hosts.end();                 
                         ++top )
                    {
                        // default value is 50 load weight
                        // for each machine
                        ulbPortRule.machineMapToLoadWeight[(*top).first] = 50;
                    }
                }
                else
                {
                    ulbPortRule.machineMapToLoadWeight = 
                        m_clusterData->portULB[ ports[i].key ].machineMapToLoadWeight;

                    ulbPortRule.machineMapToLoadWeight[machine]
                        = _wtoi( ports[i].load );
                }
            }
            else
            {
                // existing port rule.
                ulbPortRule.machineMapToLoadWeight = 
                    m_clusterData->portULB[ ports[i].key ].machineMapToLoadWeight;

                if( m_isClusterLevel == false )
                {
                    ulbPortRule.machineMapToLoadWeight[machine]
                        = _wtoi( ports[i].load );
                }
            }

            ulbPortRule._key = ulbPortRule._startPort;

            portULB[ ulbPortRule._startPort ] = ulbPortRule;
        }
        else if( ports[i].mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_SINGLE ) )
        {
            // failover
            fPortRule._startPort = _wtoi( ports[i].start_port );

            fPortRule._endPort = _wtoi( ports[i].end_port );

            if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH ) )
            {
                fPortRule._trafficToHandle = MNLBPortRule::both;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP ) )
            {
                fPortRule._trafficToHandle = MNLBPortRule::tcp;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP ) )
            {
                fPortRule._trafficToHandle = MNLBPortRule::udp;
            }

            if( ports[i].key == -1
                ||
                ( m_clusterData->portF.find( ports[i].key )
                  ==
                  m_clusterData->portF.end() )
                )
            {
                // new port rule.
                // by default make priority equal to host id.

                if( m_isClusterLevel == true )
                {
                    map< _bstr_t, HostData >::iterator top;
                    for( top = m_clusterData->hosts.begin();
                         top != m_clusterData->hosts.end();                 
                         ++top )
                    {
                        fPortRule.machineMapToPriority[(*top).first] = (*top).second.hp.hID;
                    }
                }
                else
                {
                    fPortRule.machineMapToPriority = 
                        m_clusterData->portF[ ports[i].key ].machineMapToPriority;

                    fPortRule.machineMapToPriority[machine]
                        = _wtoi( ports[i].priority );
                }
            }
            else
            {
                fPortRule.machineMapToPriority = 
                    m_clusterData->portF[ ports[i].key ].machineMapToPriority;

                if( m_isClusterLevel == false )
                {
                    fPortRule.machineMapToPriority[machine]
                        = _wtoi( ports[i].priority );
                }
            }

            fPortRule._key = fPortRule._startPort;

            portF[ fPortRule._startPort ] = fPortRule;
        }
        else if( ports[i].mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_DISABLED ) )
        {
            // disabled
            dPortRule._startPort = _wtoi( ports[i].start_port );

            dPortRule._endPort = _wtoi( ports[i].end_port );

            if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH ) )
            {
                dPortRule._trafficToHandle = MNLBPortRule::both;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP ) )
            {
                dPortRule._trafficToHandle = MNLBPortRule::tcp;
            }
            else if( ports[i].protocol == GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP ) )
            {
                dPortRule._trafficToHandle = MNLBPortRule::udp;
            }

            dPortRule._key = dPortRule._startPort;

            portD[ dPortRule._startPort ] = dPortRule;
        }
    }

    m_clusterData->portELB = portELB;
    m_clusterData->portULB = portULB;
    m_clusterData->portF =   portF;
    m_clusterData->portD =   portD;

    return CPropertyPage::OnKillActive();
}

BOOL
PortsPage::OnInitDialog()
{
    CPropertyPage::OnInitDialog();

    // the size of columns is equal 
    // to core.  Wish there were some defines somewhere.
    //
    m_portList.InsertColumn( 0, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_START ) , 
                             LVCFMT_LEFT, 
                             43 );
    m_portList.InsertColumn( 1, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_END ), 
                             LVCFMT_LEFT, 
                             43 );
    m_portList.InsertColumn( 2, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_PROTOCOL ),
                             LVCFMT_LEFT, 
                             51 );
    m_portList.InsertColumn( 3, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_MODE ),
                             LVCFMT_LEFT, 
                             53 );
    m_portList.InsertColumn( 4, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_PRIORITY ),
                             LVCFMT_LEFT, 
                             45 );

    // load is bigger than core size of 39, because we could be saying "unequal"
    m_portList.InsertColumn( 5, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_LOAD ),
                             LVCFMT_LEFT, 
                             53 );
    m_portList.InsertColumn( 6, 
                             GETRESOURCEIDSTRING( IDS_HEADER_P_AFFINITY ),
                             LVCFMT_LEFT, 
                             47 );

    m_portList.SetExtendedStyle( m_portList.GetExtendedStyle() | LVS_EX_FULLROWSELECT );

    SetControlData();

    int numItems = m_portList.GetItemCount();

    if( numItems > 0 )
    {
        buttonModify.EnableWindow( TRUE );
        
        buttonDel.EnableWindow( TRUE );
        
        if( numItems >= CVY_MAX_USABLE_RULES )
        {
            // greater should not happen, 
            // but just to be sure.
            
            buttonAdd.EnableWindow( FALSE );
        }            
        else
        {
            buttonAdd.EnableWindow( TRUE );
        }

        // make selection the first item in list.
        //
        m_portList.SetItemState( 0, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
    }
    else
    {
        buttonAdd.EnableWindow( TRUE );
        
        // disable the edit and remove buttons.
        buttonModify.EnableWindow( FALSE );
            
        buttonDel.EnableWindow( FALSE );
    }

    return TRUE;
}

void
PortsPage::SetControlData()
{
    int index = 0;
    map< long, PortDataELB>::iterator topELB;
    for( topELB = m_clusterData->portELB.begin();
         topELB != m_clusterData->portELB.end();
         ++topELB )
    {

        wchar_t buf[Common::BUF_SIZE];

        // start port
        swprintf( buf, L"%d", (*topELB).second._startPort );
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.pszText = buf;
        item.lParam = (*topELB).second._startPort;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        swprintf( buf, L"%d", (*topELB).second._endPort );
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        switch( (*topELB).second._trafficToHandle )
        {
            case MNLBPortRule::both :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH );
                break;

            case MNLBPortRule::tcp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP );
                break;

            case MNLBPortRule::udp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode 
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_MODE_MULTIPLE );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );
                
        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_LOAD_EQUAL );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	 
        switch( (*topELB).second._affinity )
        {
            case MNLBPortRule::none :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_NONE );
                break;

            case MNLBPortRule::single :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_SINGLE );
                break;

            case MNLBPortRule::classC :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_CLASSC );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        ++index;
    }

    index = 0;
    map< long, PortDataULB>::iterator topULB;
    for( topULB = m_clusterData->portULB.begin();
         topULB != m_clusterData->portULB.end();
         ++topULB )
    {

        wchar_t buf[Common::BUF_SIZE];

        // start port
        swprintf( buf, L"%d", (*topULB).second._startPort );
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.lParam = (*topULB).second._startPort;
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        swprintf( buf, L"%d", (*topULB).second._endPort );
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        switch( (*topULB).second._trafficToHandle )
        {
            case MNLBPortRule::both :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH );
                break;

            case MNLBPortRule::tcp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP );
                break;

            case MNLBPortRule::udp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode 
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_MODE_MULTIPLE );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );
                
        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        if( m_isClusterLevel == true )
        {
            item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_LOAD_UNEQUAL );
        }
        else
        {
            swprintf( buf, L"%d", (*topULB).second.machineMapToLoadWeight[machine] );            
            item.pszText = buf;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	 
        switch( (*topULB).second._affinity )
        {
            case MNLBPortRule::none :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_NONE );
                break;

            case MNLBPortRule::single :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_SINGLE );
                break;

            case MNLBPortRule::classC :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_AFFINITY_CLASSC );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        ++index;
    }

    index = 0;
    map< long, PortDataF>::iterator topF;
    for( topF = m_clusterData->portF.begin();
         topF != m_clusterData->portF.end();
         ++topF )
    {

        wchar_t buf[Common::BUF_SIZE];

        // start port
        swprintf( buf, L"%d", (*topF).second._startPort );
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.lParam = (*topF).second._startPort;
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        swprintf( buf, L"%d", (*topF).second._endPort );
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        switch( (*topF).second._trafficToHandle )
        {
            case MNLBPortRule::both :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH );
                break;

            case MNLBPortRule::tcp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP );
                break;

            case MNLBPortRule::udp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode 
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_MODE_SINGLE );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );
                
        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        if( m_isClusterLevel )
        {
            item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_NA );
        }
        else
        {
            swprintf( buf, L"%d", (*topF).second.machineMapToPriority[machine] );
            item.pszText = buf;
        }            

        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        ++index;
    }

    index = 0;
    map< long, PortDataD>::iterator topD;
    for( topD = m_clusterData->portD.begin();
         topD != m_clusterData->portD.end();
         ++topD )
    {

        wchar_t buf[Common::BUF_SIZE];

        // start port
        swprintf( buf, L"%d", (*topD).second._startPort );
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.lParam = (*topD).second._startPort;
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        swprintf( buf, L"%d", (*topD).second._endPort );
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = buf;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        switch( (*topD).second._trafficToHandle )
        {
            case MNLBPortRule::both :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_BOTH );
                break;

            case MNLBPortRule::tcp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_TCP );
                break;

            case MNLBPortRule::udp :
                item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_PROTOCOL_UDP );
                break;
        }
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode 
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_MODE_DISABLED );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );
                
        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        item.pszText = GETRESOURCEIDSTRING(IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	 
        item.pszText = GETRESOURCEIDSTRING( IDS_REPORT_EMPTY );
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        ++index;
    }
}

void
PortsPage::OnButtonAdd()
{
    PortData portData;
    
    ClusterPortsDlg clusterPortRuleDialog( portData, this );
  
    int rc = clusterPortRuleDialog.DoModal();
    if( rc != IDOK )
    {
        return;
    }
    else
    {
        // add this port rule.
        int index = 0;

        // start port
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.lParam = -1;
        item.pszText = portData.start_port;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = portData.end_port;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        item.pszText = portData.protocol;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = portData.mode;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        item.pszText = portData.priority;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        item.pszText = portData.load;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	 
        item.pszText = portData.affinity;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // check if max port limit reached.
        if( m_portList.GetItemCount() >= CVY_MAX_USABLE_RULES )
        {
            // as max port rule limit reached.
            // disable further additions.
            buttonAdd.EnableWindow( FALSE );

            buttonDel.EnableWindow( TRUE );

            buttonModify.EnableWindow( TRUE );                

            buttonDel.SetFocus();
        }
        else
        {
            buttonAdd.EnableWindow( TRUE );
            buttonDel.EnableWindow( TRUE );
            buttonModify.EnableWindow( TRUE );                
        }

        // set focus to this item
        m_portList.SetItemState( index, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
    }
}

void
PortsPage::OnButtonDel()
{
    // get the current selection.
    POSITION pos = m_portList.GetFirstSelectedItemPosition();
    if( pos == NULL )
    {
        return;
    }

    int index = m_portList.GetNextSelectedItem( pos );

    // delete it.
    m_portList.DeleteItem( index );

    // if this was the last port rule.
    if( m_portList.GetItemCount() == 0 )
    {
        // as no more port rules in list
        // disable modify and remove buttons.
        // also set focus to add button

        buttonAdd.EnableWindow( TRUE );

        buttonModify.EnableWindow( FALSE );

        buttonDel.EnableWindow( FALSE );
        
        buttonAdd.SetFocus();
    }
    else
    {
        // enable the add, modify button.
        buttonAdd.EnableWindow( TRUE );

        buttonModify.EnableWindow( TRUE );

        buttonDel.EnableWindow( TRUE );

        // make selection the first item in list.
        //
        m_portList.SetItemState( 0, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );

    }
}


void
PortsPage::OnButtonModify()
{
    // get the current selection.
    POSITION pos = m_portList.GetFirstSelectedItemPosition();
    if( pos == NULL )
    {
        return;
    }

    int index = m_portList.GetNextSelectedItem( pos );

    PortData portData;
    
    wchar_t buffer[Common::BUF_SIZE];
    m_portList.GetItemText( index, 0, buffer, Common::BUF_SIZE );
    portData.start_port = buffer;

    m_portList.GetItemText( index, 1, buffer, Common::BUF_SIZE );
    portData.end_port = buffer;

    m_portList.GetItemText( index, 2, buffer, Common::BUF_SIZE );
    portData.protocol = buffer;

    m_portList.GetItemText( index, 3, buffer, Common::BUF_SIZE );
    portData.mode = buffer;

    m_portList.GetItemText( index, 4, buffer, Common::BUF_SIZE );
    portData.priority = buffer;

    m_portList.GetItemText( index, 5, buffer, Common::BUF_SIZE );
    portData.load = buffer;

    m_portList.GetItemText( index, 6, buffer, Common::BUF_SIZE );
    portData.affinity = buffer;

    ClusterPortsDlg clusterPortRuleDialog( portData, this, index );

    HostPortsDlg hostPortRuleDialog( portData, this );

    int rc;
    if( m_isClusterLevel == true )
    {
        rc = clusterPortRuleDialog.DoModal();        
    }
    else
    {
        rc = hostPortRuleDialog.DoModal();        
    }
        
    if( rc != IDOK )
    {
        return;
    }
    else
    {
        // delete the old item and add the new item.
        // before you delete the old item find its param 
        // value
        DWORD key = m_portList.GetItemData( index );
        m_portList.DeleteItem( index );

        // as this is being modified the 
        // key remains the old one.

        // start port
        LVITEM item;
        item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        item.iItem = index;
        item.iSubItem = 0;
        item.iImage = 2;
        item.lParam = key;
        item.pszText = portData.start_port;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.InsertItem( &item );

        // end port
        item.mask = LVIF_TEXT;
        item.iItem = index;
        item.iSubItem = 1;	 
        item.pszText = portData.end_port;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // protocol
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 2;	 
        item.pszText = portData.protocol;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // mode
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 3;	 
        item.pszText = portData.mode;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // priority
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 4;	 
        item.pszText = portData.priority;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // load
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 5;	 
        item.pszText = portData.load;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // affinity
        item.mask = LVIF_TEXT; 
        item.iItem = index;
        item.iSubItem = 6;	 
        item.pszText = portData.affinity;
        item.cchTextMax = Common::BUF_SIZE;
        m_portList.SetItem( &item );

        // set focus to this item
        m_portList.SetItemState( index, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
    }
}

void
PortsPage::OnDoubleClick( NMHDR * pNotifyStruct, LRESULT * result )
{
    if( buttonModify.IsWindowEnabled() == TRUE )
    {
        OnButtonModify();
    }
}

void
PortsPage::OnSelchanged( NMHDR * pNotifyStruct, LRESULT * result )
{
    // if it is not cluster level, which means host level.
    if( m_isClusterLevel == false )
    {
        // get the current selection.
        POSITION pos = m_portList.GetFirstSelectedItemPosition();
        if( pos == NULL )
        {
            return;
        }

        // disable the add, and delete buttons.
        // enable the modify button only if the
        // selection is an unequal load balanced
        // or single host port rule.

        buttonAdd.EnableWindow( FALSE );
        
        buttonDel.EnableWindow( FALSE );

        // initially disable modify button
        buttonModify.EnableWindow( FALSE );


        int index = m_portList.GetNextSelectedItem( pos );

        PortData portData;
    
        wchar_t buffer[Common::BUF_SIZE];

        m_portList.GetItemText( index, 3, buffer, Common::BUF_SIZE );
        portData.mode = buffer;
        if(  portData.mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_MULTIPLE ) )
        {
            m_portList.GetItemText( index, 5, buffer, Common::BUF_SIZE );
            portData.load = buffer;

            if( portData.load != GETRESOURCEIDSTRING( IDS_REPORT_LOAD_EQUAL ) )
            {
                buttonModify.EnableWindow( TRUE );
            }
        }
        else if(  portData.mode == GETRESOURCEIDSTRING( IDS_REPORT_MODE_SINGLE ) )
        {
            buttonModify.EnableWindow( TRUE );
        }
    }
}

BOOL
PortsPage::OnHelpInfo (HELPINFO* helpInfo )
{
    if( helpInfo->iContextType == HELPINFO_WINDOW )
    {
        ::WinHelp( static_cast<HWND> ( helpInfo->hItemHandle ), CVY_CTXT_HELP_FILE, HELP_WM_HELP, (ULONG_PTR ) g_aHelpIDs_IDD_DIALOG_PORTS);
    }

    return TRUE;
}

void
PortsPage::OnContextMenu( CWnd* pWnd, CPoint point )
{
    ::WinHelp( m_hWnd, CVY_CTXT_HELP_FILE, HELP_CONTEXTMENU, (ULONG_PTR ) g_aHelpIDs_IDD_DIALOG_PORTS);
}

void
PortsPage::OnColumnClick( NMHDR * pNotifyStruct, LRESULT * result )
{
    // get present port rules in list.
    vector<PortData> ports;
    getPresentPorts( &ports );

    LPNMLISTVIEW lv = ( LPNMLISTVIEW) pNotifyStruct;

    // sort these port rules depending upon the header which has
    // been clicked.

    switch( lv->iSubItem )
    {
        case 0 :
            // user has clicked start port.
            sort( ports.begin(), ports.end(), comp_start_port() );
            break;

        case 1:
            // user has clicked end port            
            sort( ports.begin(), ports.end(), comp_end_port() );

            break;

        case 2:
            // user has clicked protocol
            sort( ports.begin(), ports.end(), comp_protocol() );
            break;

        case 3:
            // user has clicked mode
            sort( ports.begin(), ports.end(), comp_mode() );
            break;

        case 4:
            // user has clicked priority
            if( m_isClusterLevel == true )
            {
                sort( ports.begin(), ports.end(), comp_priority_string() );
            }
            else
            {
                sort( ports.begin(), ports.end(), comp_priority_int() );
            }
            break;

        case 5:
            // user has clicked load
            if( m_isClusterLevel == true )
            {
                sort( ports.begin(), ports.end(), comp_load_string() );
            }
            else
            {
                sort( ports.begin(), ports.end(), comp_load_int() );
            }


            break;

        case 6:
            // user has clicked affinity
            sort( ports.begin(), ports.end(), comp_affinity() );
            break;

        default:
            break;
    }

    /* If we are sorting by the same column we were previously sorting by, 
       then we reverse the sort order. */
    if( m_sort_column == lv->iSubItem )
    {
        m_sort_ascending = !m_sort_ascending;
    }
    else
    {
        // default sort is ascending.
        m_sort_ascending = true;
    }
    
    m_sort_column = lv->iSubItem;

    int portIndex;
    int itemCount = m_portList.GetItemCount();
    for( int index = 0; index < itemCount; ++index )
    {
        if( m_sort_ascending == true )
        {
            portIndex = index;
        }
        else
        {
            portIndex = ( itemCount - 1 ) - index;
        }

        m_portList.SetItemData( index, ports[portIndex].key );
        m_portList.SetItemText( index, 0, ports[portIndex].start_port );
        m_portList.SetItemText( index, 1, ports[portIndex].end_port );
        m_portList.SetItemText( index, 2, ports[portIndex].protocol );
        m_portList.SetItemText( index, 3, ports[portIndex].mode );
        m_portList.SetItemText( index, 4, ports[portIndex].priority );
        m_portList.SetItemText( index, 5, ports[portIndex].load );        
        m_portList.SetItemText( index, 6, ports[portIndex].affinity );        
    }

    return;
}


void
PortsPage::getPresentPorts( vector<PortData>* ports )
{
    // get all the port rules presently in the list.
    for( int index = 0; index < m_portList.GetItemCount(); ++index )
    {
        PortData portData;
        wchar_t buffer[Common::BUF_SIZE];

        portData.key = m_portList.GetItemData( index );

        m_portList.GetItemText( index, 0, buffer, Common::BUF_SIZE );
        portData.start_port = buffer;
        
        m_portList.GetItemText( index, 1, buffer, Common::BUF_SIZE );
        portData.end_port = buffer;

        m_portList.GetItemText( index, 2, buffer, Common::BUF_SIZE );
        portData.protocol = buffer;
        
        m_portList.GetItemText( index, 3, buffer, Common::BUF_SIZE );
        portData.mode = buffer;
        
        m_portList.GetItemText( index, 4, buffer, Common::BUF_SIZE );
        portData.priority = buffer;
        
        m_portList.GetItemText( index, 5, buffer, Common::BUF_SIZE );
        portData.load = buffer;
        
        m_portList.GetItemText( index, 6, buffer, Common::BUF_SIZE );
        portData.affinity = buffer;

        ports->push_back( portData );
    }
}