#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "definitions.h"
#include "net.h"
/*
vrsi_command_tcpip function that passed the command to the ACU
for intrepretation.  The argruements are

  command = pointer to the string containing the command that will be passed 
            to the Vertex RSI command.  The command should not have the 
            terminating "CR".  This will be appended to the string in the 
            function automatically.
  responce = array of string pointers that will contain the reply from the
             ACU.  If response==NULL, response_buffer_length==0, or 
	     number_of_terminators==0 then no reply is expected.
  response_buffer_length = length of the reply buffer string.  This is the 
                           maximum size of the reply buffer any string beyond 
			   this will not be read in. 
  number_of_terminators = number of "\n" (carrage returns) expected from the 
                          reply of the ACU.  This is to allow for 
                          reading of multiple line replies from the ACU.
  net_address = currently is the numerical form of the ip address stored as a
                character.  For example "192.168.140.1" would be a correct
		form of the net_address.  It is the address of the ACU.
  port = integer that holds port number for communication to the ACU.  5001
                or 5002.
			  
Initial version of this software was written by Robert C. Berrington.
Please contact for questions regarding the code at rberring@uwyo.edu.
Modified for Vertex RSI ACU. JSW 9 June 08
*/
int vrsi_command_tcpip(char *command,
			     char **response,
			     int response_buffer_length,
			     int number_of_terminators,
			     char *net_address,
			     int port) {
  int j=0;
  int outgoing_socket=0;
  int response_successfully_read=0;
  struct sockaddr_in compumotor_interface;
  char *command_with_terminator=NULL;

  if (command == NULL) {
    fprintf(stderr,
	    "'command' buffer pointer passed was NULL.  No command sent.\n");
    fflush(stderr);
    return NULL_ARGUEMENT;
  }
  if ((response_buffer_length>0) && (response==NULL)) {
    fprintf(stderr,
	    "'response' buffer pointer passed was NULL with positive expected buffer length!\n");
    fflush(stderr);
    return NULL_ARGUEMENT;
  }
  if (number_of_terminators==0) {
    fprintf(stderr,
	    "*WARNING* expected number of terminators was %d! No reply expected\n",
	    number_of_terminators);
    fflush(stderr);
  }
  /*
    First lets clear out the responce buffer for accepting the reply
  */
  if ((response != NULL) && (response_buffer_length > 0)) {
    for (j=0; j<number_of_terminators; j++) {
      memset(response[j], (int) 0, sizeof(response_buffer_length));
    }
  }
  /* 
     Allocate the memory required for the string that will include the
     terminator character for the Vertex RSI command.  This is the will
     be the string that will actually be sent to the Vertex RSI ACU.
  */
  if ((command_with_terminator = calloc(strlen(command)+2, sizeof(char)))==NULL) {
    fprintf(stderr, "*ERROR* failed to allocate command buffer!");
    fflush(stderr);
    return FAILURE;
  }

  strcpy(command_with_terminator, command);
  strcat(command_with_terminator, "\r\0"); /* Append end-of-string character */

#ifdef DEBUG
  /* Just to show that we got this far. */
  printf("The command '%s' was received.\n", command_with_terminator);
#endif

  memset(&(compumotor_interface), (int) 0, sizeof(compumotor_interface));

  compumotor_interface.sin_family=AF_INET;
  /*
    Convert the network address stored in numerical-dot form in the character
    string into network byte order.
  */
  if (inet_aton((char *) net_address, 
		(struct in_addr *) &(compumotor_interface.sin_addr))==0) {
    fprintf(stderr, "*ERROR* Invalid to internet address!\n");
    return FAILURE;
  } else {
    fprintf(stderr, "Setting address %s\n", net_address);
  }
  compumotor_interface.sin_port = htons(port);
  
  /*
    Create the socket for communicating with ACU.
  */
  if ((outgoing_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))==-1) {
    fprintf(stderr, "*ERROR* Failed to open socket!\n");
    return FAILURE;
  } else {
    fprintf(stderr, "Socket created!\n");
  }
  
  if (connect(outgoing_socket,
	      (struct sockaddr *) &(compumotor_interface),
	      sizeof(compumotor_interface))!=0) {
    fprintf(stderr,
	    "*ERROR* Failed to connect to the vrsi_interface!\n");
    return FAILURE;
  } else {
    fprintf(stderr, "connection successful!\n");
  }
    
  if (write(outgoing_socket,
	    command_with_terminator,
	    strlen(command_with_terminator)) < 0) {
    fprintf(stderr, "Sending telescope command failed!\n");
    return FAILURE;
  } else {
    fprintf(stderr, "successfully sent!\n");
  }
  /* 
     Get the response, if one is expected. 
  */
  if (   (response != NULL) 
      || (response_buffer_length != 0) 
      || (number_of_terminators != 0)) {
    for (j=0; j<number_of_terminators; j++) {
      response_successfully_read = read(outgoing_socket,
					response[j],
					response_buffer_length);
      if (response_successfully_read == -1) {
	fprintf(stderr, "*ERROR* Failed to read the reply!\n");
	return FAILURE;
      } else if (response_successfully_read >= response_buffer_length ) {
	fprintf(stderr, "*ERROR* Filled the response buffer!\n");
	return FAILURE;
      }
    }
  }
  /*
    Close the socket established for communication with the ACU.
  */
  if (close(outgoing_socket)==-1) {
    fprintf(stderr, "*ERROR* Failed to close the socket!\n");
    return FAILURE;
  }
  free(command_with_terminator);
  return SUCCESS;
}