#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"
/*
Compumotor_command_tcpip function that passed the command to the compumotor
for intrepretation.  The argruements are

  command = pointer to the string containing the command that will be passed 
            to the compumotor command.  The command should not have the 
	    terminating ":".  This will be appended to the string in the 
	    function automatically.
  responce = array of string pointers that will contain the reply from the
             compumotor.  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 compumotor.  This is to allow for 
                          reading of multiple line replies from the compumotor.
  net_address = currently is the numerical form of the ip address stored as a
                chareacter.  For example "10.212.212.111" would be a correct
		form of the net_address.  It is the address of the compumotor.
  port = integer that holds port number for communication to the compumotor.
			  
Initial version of this software was written by Robert C. Berrington.
Please contact for questions regarding the code at rberring@uwyo.edu.
*/
int compumotor_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 sequence for the compumotor command.  This is the will
     be the string that will actually be sent to the compumotor
  */
  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, ":\0"); /* Append end of command sequence */

#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 claudius.
  */
  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 compumotor_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 information 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 compumotor.
  */
  if (close(outgoing_socket)==-1) {
    fprintf(stderr, "*ERROR* Failed to close the socket!\n");
    return FAILURE;
  }
  free(command_with_terminator);
  return SUCCESS;
}