/*====================================================================*\
FILE    : TestMfgOper.c
PURPOSE : Manufacturing Operation functions.

HISTORY..
DATE       BUILD    AUTHOR   MODIFICATIONS		
11-Nov-96  H-01-16  Bojan    $$1  Created.
13-Nov-96  H-01-16  mgs      $$2  Fixed compile errors on sgi
19-Nov-96  H-01-17  Bojan    $$3  Fixed operation.
23-Nov-96  H-01-18  mgs      $$4  Added argument to ProElementtreePrint()
20-Jan-97  H-01-24  Igor     $$5  Removed TestMfg.h from includes
26-Jan-97  H-01-25  Igor     $$6  Added operation tool path display 
06-Oct-97  H-03-25  Pavel    $$7  More includes
02-Nov-98  I-01-25  Alexey   $$8  Added ProMfgoperActiveGet()
08-Dec-98  I-01-28  mka      $$9  Correct TEST_CALL_REPORT
31-May-99  I-03-12  mka      $$10 Delete unused variables.
11-Aug-99  I-03-12  Alexey   $$11 Call ProModelitemNameGet for operation
				  only if ProMfgoperActiveGet returns NO_ERROR
\*====================================================================*/
#ifndef lint
static char TestMfgOper_h [] = "@(#)TestMfgOper.c	1.4 11/26/96";
#endif

/*--------------------------------------------------------------------*\
System includes
\*--------------------------------------------------------------------*/
#include <math.h>

/*--------------------------------------------------------------------*\
Pro/Toolkit  includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProModelitem.h>
#include <ProSelection.h>
#include <ProMdl.h>
#include <ProElement.h>
#include <ProElemId.h>
#include <ProElempath.h>
#include <ProFeature.h>
#include <ProFeatType.h>
#include <ProSolid.h>
#include <ProCsys.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestConsts.h"
#include "TestError.h"
#include "MfgMenu.h"
#include "TestMfgNew.h"
#include "UtilTree.h"
#include "UtilMessage.h"
#include "UtilString.h"
#include "UtilGeom.h"

/*--------------------------------------------------------------------*\
Local functions
\*--------------------------------------------------------------------*/

ProError ProTestOperationCreate(MfgMenuChoice*);

/*====================================================================*\
FUNCTION : ProTestOperationCreate
PURPOSE  : ProTestOperationCreate
\*====================================================================*/
ProError ProTestOperationCreate(MfgMenuChoice *obj_action)
{
    ProMfg       mfg_model = NULL;
    ProSolid     mfg_solid = NULL;
    ProFeature   op_feature;
    ProAsmcomppath  comp_path;
    ProError     status = PRO_TK_NO_ERROR;
    ProSelection *sel;
    int sel_num, wcell_id = -1;
    ProModelitem sel_obj;
    wchar_t      wname[PRO_LINE_SIZE];
    Operation    oper;
    ProError ProTestWkcellId(ProAppData p_wcell,
                                     ProAppData app_data, int ts);

        /* Choose Wcell name. */
    ProUtilMsgPrint("gen", "TEST %0s", "Enter MFG Operation name: ");
    if(!ProUtilStringGet(wname, NULL, PRO_LINE_SIZE))
        return(PRO_TK_BAD_INPUTS);
    oper.wname = wname;

       /* Select Operation CSYS */
    ProUtilMsgPrint("gen", "TEST %0s", "Select Operation CSYS.");

    status = ProSelect("csys", -1, NULL, NULL, NULL, NULL, &sel, &sel_num);
    TEST_CALL_REPORT("ProSelect()", "ProTestOperationCreate()",
                      status, status == PRO_TK_COMM_ERROR);

    if( status != PRO_TK_NO_ERROR || sel_num <= 0 )
        return(-1);

    ProSelectionHighlight(sel[0], PRO_COLOR_ERROR);
    status = ProSelectionModelitemGet(sel[0], &sel_obj);
    TEST_CALL_REPORT("ProSelectionModelitemGet()", "ProTestOperationCreate()",
                      status, status != PRO_TK_NO_ERROR);
    oper.csys_id = sel_obj.id;


       /* Get Operation Workcell */
    ProUtilMsgPrint("gen", "TEST %0s", "Enter Workcell name that Operation belongs to: ");
    if(!ProUtilStringGet(wname, NULL, PRO_LINE_SIZE))
        return(PRO_TK_BAD_INPUTS);

    status = ProTestGetModels(&mfg_model, &mfg_solid, &comp_path);

    status = ProUtilMfgobjAction(obj_action, MFGOBJ_WKCELL, 1,
                                             ProTestWkcellId, &wcell_id, 0 );
    oper.wcell_id = wcell_id;

    fprintf(stderr, "In ProTestOperationCreate()\n");
    fprintf(stderr, "Workcell id  = %d\n", wcell_id);
    
    if(wcell_id == -1)
        return(-1);

    status = ProTempOperationCreate(oper, &op_feature);

    return (1);
}

/*====================================================================*\
FUNCTION : ProTestCreateOper
PURPOSE  : Create an operation op_name using specified wcell
\*====================================================================*/
ProError ProTempOperationCreate(
    Operation oper, 
    ProFeature *p_op_feature)
{
    ProElement     oper_elem_tree = (ProElement)NULL; /* Entire tree        */
    ProElement     oper_elem      = (ProElement)NULL; /* Individual element */
    ProSelection   selection;
    ProValueData   value_data;
    ProValue       value = (ProValue)NULL;
    ProErrorlist   errors;
    ProError       status = PRO_TK_NO_ERROR;
    int            i = 0;

/*--------------------------------------------------------------------*\
    Set up the top level element values and sizes
\*--------------------------------------------------------------------*/
    static ElemTable  oper_elem_table[] =  {
		{ PRO_E_FEATURE_TYPE,  PRO_VALUE_TYPE_INT },
		{ PRO_E_WCELL,         PRO_VALUE_TYPE_INT },
		{ PRO_E_MACH_CSYS,     PRO_VALUE_TYPE_SELECTION },
                { PRO_E_FEAT_NAME,     PRO_VALUE_TYPE_WSTRING}
		};
    int            wc_elem_type_size = sizeof(oper_elem_table)/
                                sizeof(ElemTable);

/*--------------------------------------------------------------------*\
    Allocate space for operation element tree
\*--------------------------------------------------------------------*/
    if (status == PRO_TK_NO_ERROR)
    {
	status = ProElementAlloc ( PRO_E_FEATURE_TREE, &oper_elem_tree );
	TEST_CALL_REPORT("ProElementAlloc()", "ProTestCreateOper()",
					status, (status != PRO_TK_NO_ERROR));
    }

/*--------------------------------------------------------------------*\
    Set all of the top level elements
\*--------------------------------------------------------------------*/
    for (i =0; i < wc_elem_type_size; i++)
    {
	if (status == PRO_TK_NO_ERROR)
	{
	    status = ProElementAlloc(oper_elem_table[i].elem_type,
	    							&oper_elem);
	    TEST_CALL_REPORT("ProElementAlloc()", "ProTestCreateOper()",
				    status, (status != PRO_TK_NO_ERROR));
	}

        switch (oper_elem_table[i].elem_type)
	{
	    case PRO_E_FEATURE_TYPE:
		value_data.v.i = PRO_FEAT_OPERATION;
		break;
	    case PRO_E_WCELL:
		value_data.v.i = oper.wcell_id;
		break;
	    case PRO_E_MACH_CSYS:
		ProTestCreateSelection(oper.csys_id, PRO_CSYS, &value_data.v.r);
		break;
	    case PRO_E_FEAT_NAME:
	        value_data.v.w = (wchar_t*) malloc (sizeof(ProName)); 
		if (value_data.v.w)
		    ProUtilWstrcpy(value_data.v.w, oper.wname);
		break;
            case PRO_E_FROM_POINTS:
	    case PRO_E_HOME_POINTS:
/*
	        ProUtilSetHomeFromPnt(oper_elem_table[i].elem_type,
							&oper_elem);
*/
                break;
	    default:
	        fprintf(stderr, "Error finding element type\n");
		return PRO_TK_GENERAL_ERROR;
		break;
	}
         
	if ( ( oper_elem_table[i].val_type != ARRAY   )  &&
	     ( oper_elem_table[i].val_type != COMPOUND)    )
	{
	    value_data.type = oper_elem_table[i].val_type;

	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueAlloc ( &value );
		TEST_CALL_REPORT("ProValueAlloc()", "ProTestCreateOper()",
				    status, (status != PRO_TK_NO_ERROR));
	    }

	    if (status == PRO_TK_NO_ERROR)
	    {
		status = ProValueDataSet (value, &value_data);
		TEST_CALL_REPORT("ProValueDataSet()", "ProTestCreateOper()",
					status, (status != PRO_TK_NO_ERROR));
	    }

	    if ( status == PRO_TK_NO_ERROR )
	    {
		status = ProElementValueSet ( oper_elem, value );
		TEST_CALL_REPORT("ProElementValueSet()","ProTestCreateOper()",
				    status, (status != PRO_TK_NO_ERROR));
	    }
	}

	if ( status == PRO_TK_NO_ERROR )
	{
	    status = ProElemtreeElementAdd (oper_elem_tree, NULL, oper_elem );
	    TEST_CALL_REPORT("ProElemtreeElementAdd()","ProTestCreateOper()",
				status, (status != PRO_TK_NO_ERROR));
	}
    
    }

    status = ProUtilElementtreePrint(oper_elem_tree, PRO_TEST_INFO_WINDOW,NULL);

    status = ProTestCreateSelection(PRO_TK_NOT_USED,
					PRO_TYPE_UNUSED, &selection);
    if (status == PRO_TK_NO_ERROR)
    {
	status = ProFeatureCreate( selection, oper_elem_tree, NULL, 0, 
						p_op_feature, &errors);
	TEST_CALL_REPORT("ProFeatureCreate()", "ProTestCreateOper()",
				    status, (status != PRO_TK_NO_ERROR));
    }
    
    status = ProElementFree(&oper_elem_tree);
    TEST_CALL_REPORT("ProElementFree()", "ProTestCreateOper()",
			    status, (status != PRO_TK_NO_ERROR));

    return(status);   
}


/*====================================================================*\
FUNCTION : ProTestOperationDisplay
PURPOSE  : Top level function to display a tool path of an operation
\*====================================================================*/
ProError ProTestOperationDisplay(
    MfgMenuChoice *obj_action)
{
    ProError status;
    double   dval = 0;
    int      ival = 0;
    ProMfg mfg_model;
    ProSolid mfg_solid;
    ProAsmcomppath comp_path;
    ProMfgoper oper;
    char oper_name[PRO_NAME_SIZE] = "";
    ProName name;
    
    status = ProTestGetModels (&mfg_model, &mfg_solid, &comp_path);
             
    status = ProMfgoperActiveGet (mfg_solid, &oper);
    TEST_CALL_REPORT("ProMfgoperActiveGet()", 
        "ProTestOperationDisplay", status, (status != PRO_TK_NO_ERROR)&&
        (status != PRO_TK_E_NOT_FOUND));             

    if( status == PRO_TK_NO_ERROR )
    {
	status = ProModelitemNameGet (&oper, name);
	TEST_CALL_REPORT("ProModelitemNameGet()", "ProTestOperationDisplay()",
	    status, (status != PRO_TK_NO_ERROR));
    
	ProWstringToString(oper_name, (wchar_t*)&name);       
    }

    printf("\n Current operation : %s \n", oper_name);

    status = ProUtilMfgobjAction (obj_action, MFGOBJ_OPER, 1,
            ProTestOperToolPathDisp, &dval, ival);

    return status;
}


/*====================================================================*\
FUNCTION : ProTestOperToolPathDisp
PURPOSE  : Display a tool path of a given operation
\*====================================================================*/
ProError ProTestOperToolPathDisp(
    ProAppData p_oper,
    ProAppData app_data,
    int dummy)
{
    ProError status;
    
    status = ProMfgoperToolpathDisplay((ProMfgoper *) p_oper);
    TEST_CALL_REPORT("ProMfgoperToolpathDisplay()", 
             "ProTestOperToolPathDisp", status, status != PRO_TK_NO_ERROR);
  
    return status;
}