/*
	Copyright (c) 2019 PTC Inc. and/or Its Subsidiary Companies. All Rights Reserved.
*/


/*--------------------------------------------------------------------*\
    Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProArray.h>
#include <ProMdl.h>
#include <ProDrawing.h>
#include <ProMenu.h>
#include <ProUtil.h>
#include <ProDtlgroup.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "UtilMessage.h"
#include "UtilMenu.h"
#include <ProTKRunTime.h>
#include <PTApplsUnicodeUtils.h>

#define GRP_EDIT_ADD        1
#define GRP_EDIT_REMOVE     2

/*---------------------------------------------------------------------*\
    Functions declaration
\*---------------------------------------------------------------------*/
int ProTestDtlGroupCreate (void*, int);
int ProTestDtlGroupSuppress (void*, int);
int ProTestDtlGroupResume (void*, int);
int ProTestDtlGroupExplode (void*, int);
int ProTestDtlGroupEditMenu (void*, int);
int ProTestDtlGroupEdit (void*, int);
int ProTestDtlGroupList (void*, int);
int ProTestDtlGroupSelect (ProDrawing, ProDtlgroup*);
int ProTestDtlGroupSelectMenu (ProDrawing, ProDtlgroup*);
int ProTestDtlGroupSelectByName (ProDrawing, ProDtlgroup*);
int ProTestDtlitemsCompare (ProDtlitem*, ProDtlitem*);

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupMenu()
    Purpose:    On-button function. Set up the dtl group menu
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupMenu( ProDrawing drawing )
{
    ProError    status;
    int         menu_id;    /* The identifier of the created menu */
    int         action;

    /*---------------------------------*\
    Create new menu Group
    \*---------------------------------*/

    /* Load base menu from file */
    status = ProMenuFileRegister( (char*)"Group", (char*)"tkdtlgroup.mnu", &menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestDtlGroupMenu()", 
        status, status != PRO_TK_NO_ERROR );

    /* Define menu buttons */
    ProMenubuttonActionSet( (char*)"Group", (char*)"Create", 
        (ProMenubuttonAction)ProTestDtlGroupCreate, drawing, 0);
    ProMenubuttonActionSet( (char*)"Group", (char*)"Suppress", 
        (ProMenubuttonAction)ProTestDtlGroupSuppress, drawing, 0);
    ProMenubuttonActionSet( (char*)"Group", (char*)"Resume", 
        (ProMenubuttonAction)ProTestDtlGroupResume, drawing, 0);
    ProMenubuttonActionSet( (char*)"Group", (char*)"Explode", 
        (ProMenubuttonAction)ProTestDtlGroupExplode, drawing, 0);
    ProMenubuttonActionSet( (char*)"Group", (char*)"Edit", 
        (ProMenubuttonAction)ProTestDtlGroupEditMenu, drawing, 0 );
    ProMenubuttonActionSet( (char*)"Group", (char*)"List", 
        (ProMenubuttonAction)ProTestDtlGroupList, drawing, 0 );
    ProMenubuttonActionSet( (char*)"Group", (char*)"Group", 
        (ProMenubuttonAction)ProMenuDelete, NULL, 0 );


    /*--------------------------*\
    Run menu Disp List
    \*--------------------------*/
    status = ProMenuCreate( PROMENUTYPE_MAIN, (char*)"Group", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestDtlGroupMenu()", 
        status, status != PRO_TK_NO_ERROR );
    if( status == PRO_TK_NO_ERROR )
    {
        status = ProMenuProcess( (char*)"Group", &action );
        TEST_CALL_REPORT( "ProMenuProcess()", "ProTestDtlGroupMenu()", 
            status, status != PRO_TK_NO_ERROR && status != PRO_TK_E_FOUND);
    }

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupSelectMenu()
    Purpose:    selection menu
    Returns:    0 - success; -1 - error or selection canceled
\*---------------------------------------------------------------------*/
int ProTestDtlGroupSelectMenu (
    ProDrawing drawing, 
    ProDtlgroup*    p_group)
{
    ProError err = PRO_TK_NO_ERROR;
    wchar_t **menu_strs;
    int action, status;

    err = ProUtilMenuStringsAlloc (&menu_strs);
    err = ProUtilMenuStringsStrAdd (&menu_strs, (char*)"Select");
    err = ProUtilMenuStringsStrAdd (&menu_strs, (char*)"By Name");
    
    err = ProUtilMenuStringsIntValueSelect ((char*)"SelectGroup", menu_strs, &action);
    if (err != PRO_TK_NO_ERROR)
        return -1;

    err = ProUtilMenuStringsFree (&menu_strs);
    
    if (action == 0)
        status = ProTestDtlGroupSelect (drawing, p_group);
    else if (action == 1)
        status = ProTestDtlGroupSelectByName (drawing, p_group);
    else
        status = -1;

    return status;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupSelectByName()
    Purpose:    selection menu
    Returns:    0 - success; -1 - error or selection canceled
\*---------------------------------------------------------------------*/
int ProTestDtlGroupSelectByName (
    ProDrawing drawing, 
    ProDtlgroup* p_group)
{
    ProError err = PRO_TK_NO_ERROR;
    wchar_t **menu_strs;
    ProDtlgroup *p_groups;
    ProDtlgroupdata group_data;
    ProName name;
    int action = -1, group_num = 0, i = 0, sheet = -1;

    err = ProDrawingCurrentSheetGet (drawing, &sheet);
    TEST_CALL_REPORT ("ProDrawingCurrentSheetGet()", "ProTestDtlGroupSelectByName()",
        err, err != PRO_TK_NO_ERROR);

    err = ProDrawingDtlgroupsCollect (drawing, sheet, &p_groups); 
    TEST_CALL_REPORT ("ProDrawingDtlgroupsCollect()", "ProTestDtlGroupSelectByName()",
        err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);
    if (err != PRO_TK_NO_ERROR)
        return -1;

    ProArraySizeGet (p_groups, &group_num);

    err = ProUtilMenuStringsAlloc (&menu_strs);

    for (i = 0; i < group_num; i++)
    {
        err = ProDtlgroupDataGet (&p_groups[i], &group_data);
        TEST_CALL_REPORT ("ProDtlgroupDataGet()", "ProTestDtlGroupSelectByName()",
            err, err != PRO_TK_NO_ERROR);
        if (err != PRO_TK_NO_ERROR)
            return -1;
        err = ProDtlgroupdataNameGet (group_data, name);
        TEST_CALL_REPORT ("ProDtlgroupdataNameGet()", "ProTestDtlGroupSelectByName()",
            err, err != PRO_TK_NO_ERROR);

        err = ProUtilMenuStringsWstrAdd (&menu_strs, name);

        err = ProDtlgroupdataFree (group_data);
        TEST_CALL_REPORT ("ProDtlgroupdataFree()", "ProTestDtlGroupSelectByName()",
            err, err != PRO_TK_NO_ERROR);
    }

    err = ProUtilMenuStringsIntValueSelect ((char*)"SelectGroup", menu_strs, &action);
    if (err != PRO_TK_NO_ERROR)
        return -1;

    err = ProUtilMenuStringsFree (&menu_strs);

    memcpy (p_group, &p_groups[action], sizeof (ProDtlgroup));

    ProArrayFree ((ProArray*)&p_groups);

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupList()
    Purpose:    Prints info about all groups for qcr comporison
    Returns:    0 - success; -1 - error
\*---------------------------------------------------------------------*/
int ProTestDtlGroupList (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProError err = PRO_TK_NO_ERROR;
    ProDtlgroup *p_groups;
    ProDtlgroupdata group_data;
    ProDtlitem *p_group_items;
    ProName name;
    char info_file_name[] = "group_info.txt", str[PRO_NAME_SIZE];
    FILE *fptr;
    int group_num = 0, i = 0, j = 0, sheet = -1, id = -1, items_num;

    err = ProDrawingCurrentSheetGet (drawing, &sheet);
    TEST_CALL_REPORT ("ProDrawingCurrentSheetGet()", "ProTestDtlGroupList()",
        err, err != PRO_TK_NO_ERROR);

    err = ProDrawingDtlgroupsCollect (drawing, sheet, &p_groups); 
    TEST_CALL_REPORT ("ProDrawingDtlgroupsCollect()", "ProTestDtlGroupList()",
        err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);

    ProArraySizeGet (p_groups, &group_num);

    if ((fptr = PTApplsUnicodeFopen (info_file_name, "w")) == NULL)
    {
        ProUtilMsgPrint ("gen", "TEST %0s", "Can't open info file for writing");
        return -1;
    }

    for (i = 0; i < group_num; i++)
    {
        err = ProDtlgroupDataGet(&p_groups[i], &group_data);
        TEST_CALL_REPORT ("ProDtlgroupDataGet()", "ProTestDtlGroupList()",
            err, err != PRO_TK_NO_ERROR);

        err = ProDtlgroupdataNameGet (group_data, name);
        TEST_CALL_REPORT ("ProDtlgroupdataNameGet()", "ProTestDtlGroupList()",
            err, err != PRO_TK_NO_ERROR);
        ProWstringToString (str, name);

        err = ProDtlgroupdataIdGet (group_data, &id);
        TEST_CALL_REPORT ("ProDtlgroupdataIdGet()", "ProTestDtlGroupList()",
            err, err != PRO_TK_NO_ERROR);

        ProTKFprintf (fptr, "\nGroup name: %s\nGroup Id: %d\n", str, id);
        
        err = ProDtlgroupdataItemsCollect (group_data, &p_group_items);
        TEST_CALL_REPORT ("ProDtlgroupdataItemsCollect()", "ProTestDtlGroupList()",
            err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);

        ProArraySizeGet (p_group_items, &items_num);
        
        ProTKFprintf (fptr, "hold %d items:\n", items_num);
        
        for (j = 0; j < items_num; j++)
        {
            switch (p_group_items[j].type)
            {
            case PRO_NOTE:
                ProTKFprintf (fptr, "PRO_NOTE\n");
                break;
            case PRO_DRAFT_ENTITY:
                ProTKFprintf (fptr, "PRO_DRAFT_ENTITY\n");
                break;
            case PRO_SYMBOL_INSTANCE:
                ProTKFprintf (fptr, "PRO_SYMBOL_INSTANCE\n");
                break;
            default:
                ProTKFprintf (fptr, "Unknown type %d\n", p_group_items[j].type);
                break;
            }
        }

        ProArrayFree ((ProArray*)&p_group_items);

        err = ProDtlgroupdataFree (group_data);
        TEST_CALL_REPORT ("ProDtlgroupdataFree()", "ProTestDtlGroupList()",
            err, err != PRO_TK_NO_ERROR);
    }

    ProArrayFree ((ProArray*)&p_groups);

    fclose (fptr);
    
    err = ProInfoWindowDisplay (ProStringToWstring (name, info_file_name), 
        NULL, NULL);
    TEST_CALL_REPORT ("ProInfoWindowDisplay()", "ProTestDtlGroupList()",
        err, err != PRO_TK_NO_ERROR);
            
    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupSelect()
    Purpose:    selects dtlgroup
    Returns:    0 - success; -1 - error or selection canceled
\*---------------------------------------------------------------------*/
int ProTestDtlGroupSelect (
    ProDrawing        drawing,
    ProDtlgroup*    p_group)            /*in: ProDtlgroup*/
{
    int group_num = 0, n_sel = 0, i = 0, j = 0,
        sheet = -1, items_num;
    ProDtlitem group_item, *p_group_items;
    ProDtlgroup *p_groups;
    ProDtlgroupdata group_data;
    ProSelection *p_sel = NULL;
    ProError err = PRO_TK_NO_ERROR;
    
    if (p_group == NULL)
        return -1;

    err = ProDrawingCurrentSheetGet (drawing, &sheet);
    TEST_CALL_REPORT ("ProDrawingCurrentSheetGet()", "ProTestDtlGroupSelect()",
        err, err != PRO_TK_NO_ERROR);

    err = ProDrawingDtlgroupsCollect (drawing, sheet, &p_groups); 
    TEST_CALL_REPORT ("ProDrawingDtlgroupsCollect()", "ProTestDtlGroupSelect()",
        err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);

    err = ProArraySizeGet (p_groups, &group_num);
    TEST_CALL_REPORT ("ProArraySizeGet()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);

    while (1)
    {
    ProUtilMsgPrint ("gen", "TEST %0s", "Select group" );
    err = ProSelect ((char*)"any_note,draft_ent,dtl_symbol", 1, 
        NULL, NULL, NULL, NULL, &p_sel, &n_sel);
    TEST_CALL_REPORT ("ProSelect()", "ProTestDtlGroupSelect()",
        err, err != PRO_TK_NO_ERROR);
    
    if (err != PRO_TK_NO_ERROR || n_sel < 1)
        return -1;

    err = ProSelectionModelitemGet (p_sel[0], &group_item);
    TEST_CALL_REPORT ("ProSelectionModelitemGet()", "ProTestDtlGroupSelect()",
        err, err != PRO_TK_NO_ERROR);

    for (i = 0; i < group_num; i++)
    {
        err = ProDtlgroupDataGet(&p_groups[0], &group_data);
        TEST_CALL_REPORT ("ProDtlgroupDataGet()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);

        err = ProDtlgroupdataItemsCollect (group_data, &p_group_items);
        TEST_CALL_REPORT ("ProDtlgroupdataItemsCollect()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);

        err = ProArraySizeGet (p_group_items, &items_num);
        TEST_CALL_REPORT ("ProArraySizeGet()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);

        for (j = 0; j < items_num; j++)
        {
            if (ProTestDtlitemsCompare (&group_item, &p_group_items[j]) == 0)
                break;
        }

        err = ProArrayFree ((ProArray*)&p_group_items);
        TEST_CALL_REPORT ("ProArrayFree()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);

        err = ProDtlgroupdataFree (group_data);
        TEST_CALL_REPORT ("ProDtlgroupdataFree()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);

        if (j != items_num)
            break;
    }
    if (i != group_num)
        break;
    ProUtilMsgPrint ("gen", "TEST %0s", "This item is not a group item" );
    }
        
    memcpy (p_group, &p_groups[i], sizeof (ProDtlgroup));

    err = ProArrayFree ((ProArray*)&p_groups);
    TEST_CALL_REPORT ("ProArrayFree()", "ProTestDtlGroupSelect()",
            err, err != PRO_TK_NO_ERROR);
    
    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupCreate()
    Purpose:    creates dtlgroup
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupCreate (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProSelection *p_sel = NULL;
    ProDtlgroupdata group_data;
    ProDtlgroup group;
    ProDtlitem group_item;
    ProName name, default_name;
    int i = 0, n_sel;
    ProError err = PRO_TK_NO_ERROR;

    ProStringToWstring (default_name, (char*)"group");
    ProUtilMsgPrint ("gen", "TEST %0s", "Enter group name:" );
    ProUtilStringGet (name, default_name, PRO_NAME_SIZE);

    ProUtilMsgPrint ("gen", "TEST %0s", "Select note, entity or symbol" );
    
    err = ProSelect ((char*)"any_note,draft_ent,dtl_symbol", -1, NULL, NULL, NULL, 
        NULL, &p_sel, &n_sel);
    TEST_CALL_REPORT ("ProSelect()", "ProTestDtlGroupCreate()",
        err, err != PRO_TK_NO_ERROR);
        
    if (err != PRO_TK_NO_ERROR || n_sel < 1)
        return -1;

    err = ProDtlgroupdataAlloc (drawing, name, &group_data);
    TEST_CALL_REPORT ("ProDtlgroupdataAlloc()", "ProTestDtlGroupCreate()",
        err, err != PRO_TK_NO_ERROR);

    for (i = 0; i < n_sel; i++)
    {
        err = ProSelectionModelitemGet (p_sel[i], &group_item);
        TEST_CALL_REPORT ("ProSelectionModelitemGet()", "ProTestDtlGroupCreate()",
            err, err != PRO_TK_NO_ERROR);

        err = ProDtlgroupdataItemAdd (group_data, &group_item);
        TEST_CALL_REPORT ("ProDtlgroupdataItemAdd()", "ProTestDtlGroupCreate()",
            err, err != PRO_TK_NO_ERROR);
    }

    err = ProDtlgroupCreate (drawing, group_data, &group);
    TEST_CALL_REPORT ("ProDtlgroupCreate()", "ProTestDtlGroupCreate()",
        err, err != PRO_TK_NO_ERROR);

    err = ProDtlgroupdataFree (group_data);
    TEST_CALL_REPORT ("ProDtlgroupdataFree()", "ProTestDtlGroupCreate()",
        err, err != PRO_TK_NO_ERROR);

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupSuppress()
    Purpose:    suppresses dtlgroup
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int  ProTestDtlGroupSuppress (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProDtlgroup group;
    ProError err = PRO_TK_NO_ERROR;

    if (ProTestDtlGroupSelectMenu (drawing, &group) == -1)
        return -1;
    
    err = ProDtlgroupErase (&group);
    TEST_CALL_REPORT ("ProDtlgroupErase()", "ProTestDtlGroupSuppress()",
        err, err != PRO_TK_NO_ERROR);

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupResume()
    Purpose:    resume dtlgroup
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupResume (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProDtlgroup group;
    ProError err = PRO_TK_NO_ERROR;

    if (ProTestDtlGroupSelectMenu (drawing, &group) == -1)
        return -1;
    
    err = ProDtlgroupDraw (&group);
    TEST_CALL_REPORT ("ProDtlgroupDraw()", "ProTestDtlGroupResume()",
        err, err != PRO_TK_NO_ERROR);

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupExplode()
    Purpose:    Explode dtlgroup
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupExplode (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProDtlgroup group;
    ProError err = PRO_TK_NO_ERROR;

    if (ProTestDtlGroupSelectMenu (drawing, &group) == -1)
        return -1;
    
    err = ProDtlgroupDelete (&group);
    TEST_CALL_REPORT ("ProDtlgroupDelete()", "ProTestDtlGroupExplode()",
        err, err != PRO_TK_NO_ERROR);

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupEditMenu()
    Purpose:    Menu for edititing
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupEditMenu (void* app_data, int int_dummy)
{
    ProDrawing drawing = (ProDrawing)app_data;
    int            menu_id;   
    int            action;
    ProError    err = PRO_TK_NO_ERROR;

    err = ProMenuFileRegister( (char*)"Edit", (char*)"tkdtlgroupedit.mnu", &menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestDtlEditMenu()", 
            err, err != PRO_TK_NO_ERROR );

    /* Define menu buttons */
    ProMenubuttonActionSet( (char*)"Edit", (char*)"Add", 
        (ProMenubuttonAction)ProTestDtlGroupEdit, drawing, GRP_EDIT_ADD);
    ProMenubuttonActionSet( (char*)"Edit", (char*)"Remove", 
        (ProMenubuttonAction)ProTestDtlGroupEdit, drawing, GRP_EDIT_REMOVE);
    ProMenubuttonActionSet( (char*)"Edit", (char*)"Edit", 
        (ProMenubuttonAction)ProMenuDelete, NULL, 0 );

    /*--------------------------*\
    Run menu Disp List
    \*--------------------------*/
    err = ProMenuCreate( PROMENUTYPE_MAIN, (char*)"Edit", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestDtlEditMenu()", 
        err, err != PRO_TK_NO_ERROR );
    if( err == PRO_TK_NO_ERROR )
    {
        err = ProMenuProcess( (char*)"Edit", &action );
        TEST_CALL_REPORT( "ProMenuProcess()", "ProTestDtlEditMenu()", 
            err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_FOUND);
    }

    return 0;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlitemsCompare()
    Purpose:    Compares two dtlitems
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlitemsCompare (ProDtlitem *item1, ProDtlitem *item2)
{
    if (item1->type != item2->type)
        return -1;
    return (item1->id == item2->id)? 0 : -1;
}

/*---------------------------------------------------------------------*\
    Function:    ProTestDtlGroupEdit()
    Purpose:    Edit
    Returns:    0 - success; -1 - error.
\*---------------------------------------------------------------------*/
int ProTestDtlGroupEdit (void* app_data, int action)
{
    ProDrawing drawing = (ProDrawing)app_data;
    ProDtlgroup group;
    ProDtlgroupdata group_data;
    ProDtlitem *p_group_items, group_item;
    ProError err = PRO_TK_NO_ERROR;
    ProSelection *p_sel = NULL;
    int items_num = 0, i = 0, j = 0, n_sel;

    if (ProTestDtlGroupSelectMenu (drawing, &group) == -1)
        return -1;

    err = ProDtlgroupDataGet (&group, &group_data);
    TEST_CALL_REPORT ("ProDtlgroupDataGet()", "ProTestDtlGroupEdit()",
        err, err != PRO_TK_NO_ERROR);
    err = ProDtlgroupdataItemsCollect (group_data, &p_group_items);
    TEST_CALL_REPORT ("ProDtlgroupdataItemsCollect()", "ProTestDtlGroupEdit()",
        err, err != PRO_TK_NO_ERROR && err != PRO_TK_E_NOT_FOUND);

    err = ProArraySizeGet (p_group_items, &items_num);

    ProUtilMsgPrint ("gen", "TEST %0s", "Select draft items" );
    err = ProSelect ((char*)"any_note,draft_ent,dtl_symbol", -1, NULL, NULL, NULL, 
        NULL, &p_sel, &n_sel);
    TEST_CALL_REPORT ("ProSelect()", "ProTestDtlGroupEdit()",
            err, err != PRO_TK_NO_ERROR);
        
    if (err != PRO_TK_NO_ERROR || n_sel < 1)
        return -1;

    for (i = 0; i < n_sel; i++)
    {
        err = ProSelectionModelitemGet (p_sel[i], &group_item);
        TEST_CALL_REPORT ("ProSelectionModelitemGet()", "ProTestDtlGroupEdit()",
            err, err != PRO_TK_NO_ERROR);
        for (j = 0; j < items_num; j++)
        {
            if (ProTestDtlitemsCompare (&group_item, &p_group_items[j]) == 0)
                break;
        }
        /*item is found*/
        if ((j != items_num) && (action == GRP_EDIT_REMOVE))
        {
            err = ProArrayObjectRemove ((ProArray*)&p_group_items, j, 1);
            TEST_CALL_REPORT ("ProArrayObjectRemove()", "ProTestDtlGroupEdit()",
                err, err != PRO_TK_NO_ERROR);
            ProArraySizeGet (p_group_items, &items_num);
        }
        /*item is not found*/
        else if ((j == items_num) && (action == GRP_EDIT_ADD))
        {
            ProArrayObjectAdd ((ProArray*)&p_group_items, 
                PRO_VALUE_UNUSED, 1, &group_item);
            TEST_CALL_REPORT ("ProArrayObjectAdd()", "ProTestDtlGroupEdit()",
                err, err != PRO_TK_NO_ERROR);
            ProArraySizeGet (p_group_items, &items_num);
        }
    }

    err = ProDtlgroupdataItemsSet (group_data, p_group_items);
    TEST_CALL_REPORT ("ProDtlgroupdataItemsSet()", "ProTestDtlGroupEdit()",
        err, err != PRO_TK_NO_ERROR);
    err = ProDtlgroupModify (&group, group_data);
    TEST_CALL_REPORT ("ProDtlgroupModify()", "ProTestDtlGroupEdit()",
        err, err != PRO_TK_NO_ERROR);

    err = ProDtlgroupdataFree (group_data);
    TEST_CALL_REPORT ("ProDtlgroupdataFree()", "ProTestDtlGroupEdit()",
        err, err != PRO_TK_NO_ERROR);

    return 0;
}