/*====================================================================*\
FILE    : UgMfgWcellCreate.c
PURPOSE : Pro/TOOLKIT User Guide Example

HISTORY..
DATE      BUILD   AUTHOR   MODIFICATIONS
04-dec-97 H-02-02 mgs      $$1  Created
\*====================================================================*/
#include <ProToolkit.h>
#include <ProMfg.h>
#include <ProSolid.h>
#include <ProSelection.h>
#include <ProAsmcomppath.h>
#include <ProElement.h>
#include <ProElemId.h>
#include <ProValue.h>
#include <ProFeature.h>
#include <ProUtil.h>

#include <TestError.h>
#include <TestMfgNew.h>
#include <UtilString.h>
#include <UtilTree.h>
#include <TestConsts.h>

/*====================================================================*\
FUNCTION : UserWorkcellCreate
PURPOSE  : Create a workcell
\*====================================================================*/
int UserWorkcellCreate ()
{
    ProMdl	   p_mfg_model;
    ProElement     wc_elem      = (ProElement)NULL; /* Individual element */
    ProElement     wc_elem_tree = (ProElement)NULL; /* Entire tree        */
    ProValueData   value_data;
    ProValue       value        = (ProValue)NULL;
    ProErrorlist   errors;
    ProSelection   selection;
    ProFeature     wc_feature;
    ProError       err  = PRO_TK_NO_ERROR;
    int            i = 0;

    ProError UserWpieceSelCreate ( ProMfg, int, ProType, ProSelection*);
    ProError UserToolTableSetup ( ProElement*);

    static ElemTable  workcell_elem_table[] =  {
                { PRO_E_FEATURE_TYPE,   PRO_VALUE_TYPE_INT     },
                { PRO_E_WCELL_TYPE,     PRO_VALUE_TYPE_INT     },
                { PRO_E_NUM_AXES,       PRO_VALUE_TYPE_INT     },
		{ PRO_E_LATHE_DIR,      PRO_VALUE_TYPE_INT     },
		{ PRO_E_MACH_NUM_HEADS, PRO_VALUE_TYPE_INT     }, 
                { PRO_E_TOOL_TABLES,    ARRAY                  }, 
                { PRO_E_FEAT_NAME,      PRO_VALUE_TYPE_WSTRING }};
		
    int            wc_elem_type_size = sizeof(workcell_elem_table)/
                                sizeof(ElemTable);
   
    err = ProMdlCurrentGet(&p_mfg_model);
    ERROR_CHECK("UserWorkcellCreate","ProMdlCurrentGet", err);
 
    err = ProElementAlloc(PRO_E_FEATURE_TREE, &wc_elem_tree);
    ERROR_CHECK("UserWorkcellCreate","ProElementAlloc()", err);
    
    for (i=0 ; i < wc_elem_type_size; i++)
    {

	err = ProElementAlloc(workcell_elem_table[i].elem_type, &wc_elem);
	ERROR_CHECK("UserWorkcellCreate","ProElementAlloc()", err);
	 
	switch (workcell_elem_table[i].elem_type)
	{
	    case PRO_E_FEATURE_TYPE:
		value_data.v.i = PRO_FEAT_WORKCELL;
		break;
	    case PRO_E_WCELL_TYPE:
		value_data.v.i = PRO_WCELL_LATHE;
		break;
	    case PRO_E_NUM_AXES:
		value_data.v.i = 2;
		break;
	    case PRO_E_LATHE_DIR:
		value_data.v.i = PRO_WCELL_LATHE_HORIZONTAL;
		break;
	    case PRO_E_MACH_NUM_HEADS:
		value_data.v.i = 1;
		break;
	    case PRO_E_FEAT_NAME:
		value_data.v.w = (wchar_t*) malloc (sizeof(ProName));
		if (value_data.v.w)
		{
		   ProStringToWstring(value_data.v.w, "Lathe_2_Axis");
		   ERROR_CHECK("UserWorkcellCreate","ProStringToWstring()",err);
		}
		break;
	    case PRO_E_TOOL_TABLES:
		err = UserToolTableSetup( &wc_elem );
		break;
	    default:
		fprintf(stderr, "Error setting element type\n");
		return PRO_TK_GENERAL_ERROR;
		break;
	}

    	if ( workcell_elem_table[i].val_type != ARRAY)
	{
	    value_data.type = workcell_elem_table[i].val_type;
	    
	    err = ProValueAlloc ( &value );

	    if (err == PRO_TK_NO_ERROR)
	    {
		err = ProValueDataSet (value, &value_data);
		ERROR_CHECK("UserWorkcellCreate", "ProValueDataSet()", err);
	    }

	    if ( err == PRO_TK_NO_ERROR )
	    {
		err = ProElementValueSet ( wc_elem, value );
		ERROR_CHECK("UserWorkcellCreate", "ProElementValueSet()", err);
	    }
	}

	if ( err == PRO_TK_NO_ERROR )
	{
	    err = ProElemtreeElementAdd (wc_elem_tree, NULL, wc_elem );
	    ERROR_CHECK("UserWorkcellCreate", "ProElemtreeElementAdd()", err);
	}

    }

    ProUtilElementtreePrint(wc_elem_tree, PRO_TEST_INFO_WINDOW, NULL );

    if (err == PRO_TK_NO_ERROR )
	err = UserWpieceSelCreate ((ProMfg)p_mfg_model, PRO_TK_NOT_USED,
						PRO_TK_NOT_USED, &selection);
    
    if (err == PRO_TK_NO_ERROR)
    {
        err = ProFeatureCreate(selection, wc_elem_tree, NULL, 0,
                                                &wc_feature, &errors);
	ERROR_CHECK("UserWorkcellCreate", "ProFeatureCreate()", err);
    }

    err = ProElementFree(&wc_elem_tree);
    ERROR_CHECK("UserWorkcellCreate", "ProElementFree()", err);

    return ((int)err);
}

/*====================================================================*\
Function : UserWpieceSelCreate()
Purpose  : Create a selection handle for the mfg workpiece or items in it
\*====================================================================*/
ProError UserWpieceSelCreate (
    ProMfg mfg_model,
    int item_id,
    ProType item_type,
    ProSelection *selection)
{
    ProSolid      mfg_solid;
    ProAsmcomppath comp_path;
    ProModelitem   wkpiece_item;
    ProError err;

    err = ProMfgSolidGet(mfg_model, &mfg_solid);
    ERROR_CHECK("UserWorkcellCreate", "ProMfgSolidGet()", err);

    if (err == PRO_TK_NO_ERROR)
    {
	err= ProMfgFeatureOwnerGet(mfg_model, &comp_path);
	ERROR_CHECK("UserWorkcellCreate", "ProMfgSolidGet()", err);
    }

    if (err == PRO_TK_NO_ERROR)
    {
	err = ProModelitemInit( mfg_solid, item_id, item_type, &wkpiece_item );
	ERROR_CHECK("UserWorkcellCreate", "ProModelitemInit()", err);
    }

    if (err == PRO_TK_NO_ERROR)
    {
	err = ProSelectionAlloc(&comp_path, &wkpiece_item, selection);
	ERROR_CHECK("UserWorkcellCreate", "ProSelectionAlloc()", err);
    }

    return err;
}

/*====================================================================*\
Function : UserToolTableSetup()
Purpose  : Setup a simple tool table
\*====================================================================*/
ProError UserToolTableSetup(
    ProElement *tool_tables )
{
    ProError   status;
    ProElement tool_table, tool_table_elem;
    ProValue value;
    ProValueData value_data;
    static ElemTable tool_table_elements[] = {
	{ PRO_E_MACH_HEAD, PRO_VALUE_TYPE_INT },
	{ PRO_E_MFG_TABLE, ARRAY }};
    int  i , tool_table_elem_size = sizeof(tool_table_elements)/ 
					sizeof(ElemTable);

    ProError UserMfgCreateTools();

    status = ProElementAlloc( PRO_E_MFG_TOOL_TABLE, &tool_table);

    for (i=0; i < tool_table_elem_size && status==PRO_TK_NO_ERROR; i++)
    {
        if (status == PRO_TK_NO_ERROR)
	{
	    status = ProElementAlloc(tool_table_elements[i].elem_type, 
				    		    &tool_table_elem);
	    ERROR_CHECK("UserToolTableSetup","ProElementAlloc", status);
	}

	switch ( tool_table_elements[i].elem_type)
	{
	    case PRO_E_MACH_HEAD:
                value_data.v.i = PRO_MACH_HEAD1;
		break;
	    case PRO_E_MFG_TABLE:
		status = UserMfgCreateTools(&tool_table_elem);
	        break;
	    default:
	       /* do nothing */
	       break;
	}

        if (status == PRO_TK_NO_ERROR &&
	    	tool_table_elements[i].val_type != ARRAY &&
		 tool_table_elements[i].val_type != COMPOUND)
	{
	    value_data.type = tool_table_elements[i].val_type;

	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueAlloc ( &value );
		ERROR_CHECK("UserToolTableSetup","ProValueAlloc", status);
	    }

	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueDataSet (value, &value_data);
		ERROR_CHECK("UserToolTableSetup","ProValueDataSet", status);
	    }


	    if ( status == PRO_TK_NO_ERROR )
	    {
	       status = ProElementValueSet ( tool_table_elem, value );
	       ERROR_CHECK("UserToolTableSetup","ProElementValueSet",status);
	    }
	}
    	
	if ( status == PRO_TK_NO_ERROR )
    	{
	    status = ProElemtreeElementAdd (tool_table,NULL,tool_table_elem);
	    ERROR_CHECK("UserToolTableSetup","ProElemtreeElementAdd",status);
	}

    }

    status = ProElemtreeElementAdd( *tool_tables, NULL, tool_table);
    ERROR_CHECK("UserToolTableSetup","ProElemtreeElementAdd", status);

    return status;
    
}

/*====================================================================*\
FUNCTION : UserMfgCreateTools
PURPOSE  : Create tools and add to tool table
\*====================================================================*/
ProError UserMfgCreateTools(
    ProElement *mfg_table  )
{
    ProTool tool;
    ProToolinputPtr tool_input;
    ProToolElem tool_elem;
    ProMfg mfg_model;
    int i = 0;
    char tool_name[PRO_LINE_SIZE], *test;
    wchar_t wtool_name[PRO_LINE_SIZE];
    ProError status = PRO_TK_NO_ERROR;
    ProElement mfg_table_row;

    ProError UserMfgTooltableRowCreate();
    ProError UserParamToolCreate();

/*--------------------------------------------------------------------*\
    Get Manufacturing model
\*--------------------------------------------------------------------*/
    status=ProMdlCurrentGet((ProMdl*)&mfg_model);
    ERROR_CHECK("UserMfgCreateTools","ProMdlCurrentGet", status);

    for (i = 0; i < 5; i++)
    {
/*--------------------------------------------------------------------*\
        Create the drilling tool
\*--------------------------------------------------------------------*/
        sprintf(tool_name, "drill_%dmm", 6+i*2);
	ProStringToWstring(wtool_name, tool_name);
	ERROR_CHECK("UserMfgCreateTools","ProStringToWstring", 0);

	status = UserParamToolCreate(mfg_model, PRO_TOOL_DRILL, wtool_name,
				(double)(6.0+i*2.0), 
				(double)(100.0 + 10.0 * i),
				135.0, &tool);
	
/*--------------------------------------------------------------------*\
	Add the created tool to the workcell element
\*--------------------------------------------------------------------*/
	if (mfg_table != NULL && status == PRO_TK_NO_ERROR )
	{
	    status = ProElementAlloc( PRO_E_MFG_TABLE_ROW, &mfg_table_row);
	    ERROR_CHECK("UserMfgCreateTools","ProElementAlloc", status);

	    status = UserMfgTooltableRowCreate(wtool_name,i,&mfg_table_row);

/*
            ProUtilElementtreePrint(mfg_table_row, PRO_TEST_INFO_WINDOW, NULL);
	    test = getch();
*/

	    if (status == PRO_TK_NO_ERROR)
	    {
		status=ProElemtreeElementAdd(*mfg_table,NULL,mfg_table_row);
		ERROR_CHECK("UserMfgCreateTools","ProElemtreeElementAdd", 
								status);
	    }
	}
    }
	
    return (PRO_TK_NO_ERROR);	
}

/*====================================================================*\
FUNCTION : UserMfgTooltableRowCreate
PURPOSE  : Create a row of the tool table
\*====================================================================*/
ProError UserMfgTooltableRowCreate( 
    wchar_t *tool_name,
    int      index,
    ProElement *mfg_table_row)
{
    ProError status = PRO_TK_NO_ERROR;
    ProValue value;
    ProValueData value_data;
    static ElemTable  tool_elem_table[] = {
	{ PRO_E_MFG_TABLE_CELL_TYPE, PRO_VALUE_TYPE_INT },
	{ PRO_E_MFG_TABLE_CELL_VALUE, PRO_VALUE_TYPE_WSTRING}};
    int  tool_elem_size = sizeof(tool_elem_table)/ sizeof(ElemTable), i, j;
    ProElement mfg_table_cell_entry, mfg_table_cell;
    
 
    for ( i =0; i < 2 ; i++)
    {
	status = ProElementAlloc(PRO_E_MFG_TABLE_CELL, &mfg_table_cell);
	ERROR_CHECK("ProTestTooltableRowCreate","ProElementAlloc", status);

	for ( j =0; j < tool_elem_size ; j++)
	{
	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProElementAlloc(tool_elem_table[j].elem_type, 
						    &mfg_table_cell_entry);
		ERROR_CHECK("ProTestTooltableRowCreate",
						"ProElementAlloc", status);
	    }

	    switch ( tool_elem_table[j].elem_type)
	    {
		case PRO_E_MFG_TABLE_CELL_TYPE:
		    value_data.type = PRO_VALUE_TYPE_INT;
		    
		    if ( !i )
			value_data.v.i = PRO_TOOL_TABLE_INDEX ;
		    else
			value_data.v.i = PRO_TOOL_TABLE_TOOL_ID;
		    break;
		case PRO_E_MFG_TABLE_CELL_VALUE:
		    if ( !i )
		    {
			value_data.type = PRO_VALUE_TYPE_INT;
			value_data.v.i = index;
		    }
		    else
		    {
			value_data.type = PRO_VALUE_TYPE_WSTRING;
			value_data.v.w = (wchar_t*) malloc (sizeof(ProLine));
			if (value_data.v.w)
			    ProUtilWstrcpy(value_data.v.w, tool_name);
		    }
		    break;

		default:
		    /* do nothing */
		    break;
	    }


	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueAlloc ( &value );
		ERROR_CHECK("ProTestTooltableRowCreate","ProValueAlloc", 
	    							status);
	    }

	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueDataSet (value, &value_data);
		ERROR_CHECK("ProTestTooltableRowCreate","ProValueDataSet",
								status);
	    }


	    if ( status == PRO_TK_NO_ERROR )
	    {
		status = ProElementValueSet ( mfg_table_cell_entry,value );
		ERROR_CHECK("ProTestTooltableRowCreate",
				 "ProElementValueSet", status);
	    }
	    
	    if ( status == PRO_TK_NO_ERROR )
	    {
		status = ProElemtreeElementAdd (mfg_table_cell,NULL,
						mfg_table_cell_entry);
	    ERROR_CHECK("ProTestTooltableRowCreate","ProElemtreeElementAdd",
	    							 status);
	    }
	}

	if ( status == PRO_TK_NO_ERROR )
	{
	    status = ProElemtreeElementAdd (*mfg_table_row,NULL, 
	    						mfg_table_cell);
	    ERROR_CHECK("ProTestTooltableRowCreate",
	    		"ProElemtreeElementAdd", status);
	}
    }

    return status;	   
}