/*
     *   This is an example of using mrd_position_to_element(3mrd)
     *   to perform multiple Position To Element commands.  For
     *   each pair of arguments after the robot and transport
     *   address, it will position the transport to that location.
     *
     *      mrd_position_to_element robot transport type address
     *
     *   Type can be one of:
     *
     *      slot, port, drive or transport
     *
     *   The optional transport argument can be a transport address
     *   number, the word "default" or an empty string.  To keep the
     *   example as simple as possible, it doesn't try to invert the
     *   transport.
     */
    #ifndef   lint
    static char SccsId[] = "@(#)mrd_position_to_element.c 1.2 3/5/97" ;
    #endif

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    #include <mrd_common.h>
    #include <mrd_message.h>

    /*
     *   Given a string, resembling one of the element types,
     *   return the SCSI type code for it.
     */
    struct {
       int   code ;
       char   *string ;
    } etypes[] = {
       TRANSPORT,   "transport",
       SLOT,      "slot",
       DRIVE,      "drive",
       PORT,      "port",
    } ;

    convert_type(char *etype)
    {
       register i ;

       /*
        *   For each entry in the array.
        */
       for(i = 0; i < sizeof(etypes)/sizeof(etypes[0]); i++)
          /*
           *   Do a case insensitive comparison, allowing
           *   abbreviations.  Return as soon as a match is
           *   found.  Return -1 if one isn't found.
           */
    #ifdef   vms
          if( strncmp(etypes[i].string, etype, strlen(etype)) == 0 )
    #else
          if( strncasecmp(etypes[i].string, etype, strlen(etype)) == 0 )
    #endif
             return etypes[i].code ;

       return -1 ;
    }

    main(int argc, char *argv[])
    {
       int      el ;         /* Counter */
       int      status ;      /* Status from MRD calls */
       int      invert = 0 ;      /* Don't invert */
       char      *robot ;      /* Robot name */
       int      type ;         /* Element type */
       int      element ;      /* Relative element addr */
       int      address ;      /* Absolute element addr */
       int      transport ;      /* Transport address */
       char      *transport_name ;   /* Tranport name */
       robot_info_t   robot_info ;
       dev_status_t   dev_status ;
       char      log_info[MRD_MAX_LOG_STRING+1] ;

       if( argc < 5 ) {
          printf("usage: %s robot transport type address ...\n", argv[0]);
          exit(1) ;
       }

       /*
        *   Get the medium changer name.
        */
       robot = argv[1] ;

       /*
        *   Get the transport number.  We'll keep it as a name
        *   so we can detect the default transport.  Once we
        *   know the element addresses, we can add the base
        *   base address if appropriate.
         */
       if( strcmp(argv[2], "default") == 0 )
          transport_name = NULL ;
       else
          transport_name = argv[2] ;

       /*
        *   Make sure there are pairs of arguments left.  There
        *   should be an odd number.
        */
       if((argc % 2) == 0 ) {
          printf("Pairs of arguments are required.\n") ;
          exit(1) ;
       }

       /*
        *   Open the robot.
        */
       robot_info.channel = BAD_CHANNEL ;

       status = mrd_startup(robot, &robot_info, log_info) ;

       if( status != MRD_STATUS_SUCCESS ) {
          fprintf(stderr, "Can't start %s: %s\n", robot,
             mrd_strstatus(status)) ;

          exit(1) ;
       }

       if( transport_name == NULL )
          transport = 0 ;
       else
          transport = atoi(transport_name) + robot_info.transport_start;

       /*
        *   Look at the element addresses in pairs.
        */
       for(el = 3; el < argc; el += 2) {
          type    = convert_type(argv[el]) ;
          element = atoi(argv[el + 1]) ;

          switch( type ) {
          case SLOT:
             address = element + robot_info.slot_start ;
             break ;
          case DRIVE:
             address = element + robot_info.device_start ;
             break ;
          case TRANSPORT:
             address = element + robot_info.transport_start ;
             break ;
          case PORT:
             address = element + robot_info.port_start ;
             break ;
          default:
             printf("Unknown element type: %s %s\n", argv[el],
                argv[el + 1]) ;

             continue ;
          }

          /*
           *   Audit the command.
           */
          printf("Position transport to %s #%d.\n", mrd_strelement(type),
             element) ;

          /*
           *   Do the command.
           */
          status = mrd_position_to_element(&robot_info, transport,
                    address, invert, &dev_status) ;

          if( status != MRD_STATUS_SUCCESS )
             printf("Position to Element failed: %s: %s.\n", robot,
                mrd_strstatus(status)) ;
       }

       (void)mrd_shutdown(&robot_info) ;

       return 0 ;
    }