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

EXEC SQL INCLUDE sqlca.h;


typedef char asciz[20];
typedef char vc2_arr[11];

EXEC SQL BEGIN DECLARE SECTION;
/* User-defined type for null-terminated strings */
EXEC SQL TYPE asciz  IS STRING(20) REFERENCE;

/* User-defined type for a VARCHAR array element. */
EXEC SQL TYPE vc2_arr IS VARCHAR2(11) REFERENCE;

asciz	username;
asciz	password;
char	user_pwd[80];

int	i;
int	j;
int	k;

short	ind;		/* Indicator */

char	name[33];	/* Sequence name */
char	lddate[32];	/* Load date */

int	seqresp_id;	/* Sequence of responses identifier */

int	resp_nb;	/* Response number */
char	resp_type;	/* Response type */
int	resp_id;	/* Response identifier */
int	unit_in;	/* Input units */
int	unit_out;	/* Output units */
char	unitin[81];	/* Input units */
char	unitout[81];	/* Output units */
char	r_type;		/* Response type */

char	filter_type[3];	/* Filter type */
int	nb_pole;	/* Number of poles */
float	corner_freq;	/* Corner frequency */
float	damping_value;	/* Damping value */

char	type;
float	r_value;	/* Real value */
float	i_value;	/* Imaginary value */

char	poly_type;	/* Type of polynomial approximation */
float	lower_bound;	/* Lower bound */
float	upper_bound;	/* Upper bound */
float	max_error;	/* Maximum error */
int	nb_coeff;	/* Number of coefficients */

int	pn_nb;		/* Coefficient number */
float	pn_value;	/* Coefficient value */

int	seqfil_id;	/* Sequence of filters identifier */
int	nb_filter;	/* Number of filters */
float	gain;		/* Gain */
float	frequency;	/* Frequency */
int	filter_nb;	/* Filter number */
int	filter_id;	/* Filter identifier */
float	in_sp_rate;	/* Input sample rate */
float	out_sp_rate;	/* Output sample rate */
int	offset;		/* Decimation offset */
float	delay;		/* Estimated delay */
float	correction;	/* Correction applied */

char	symmetry;	/* Filter symmery */

EXEC SQL END DECLARE SECTION;


long      SQLCODE;


void	sql_error();	/* Handles unrecoverable errors */


				  /*****************/
				 /* Main function */
				/*****************/

main (argc, argv)
int	argc;
char*	argv[];
{
 /* Test of parameters */
 if (argc != 2)
	{
	 printf ("\n\n filinfo <Filter sequence name>\n\n");

	 exit (0);
	}

 strcpy (name, argv[1]);
 for (i=0;i<strlen (name);i++)
	name[i] = toupper (name[i]);
 
 /* Connect to ORACLE. */
 EXEC SQL WHENEVER SQLERROR DO sql_error();

 strcpy (username, "ncedcdba");
 strcpy (password, "passwd");
 strcpy (user_pwd, "ncedcdba/passwd@ncedc");

 /*EXEC SQL CONNECT :username IDENTIFIED BY :password;*/
 EXEC SQL CONNECT :user_pwd;

 printf ("\n Connected to ORACLE as user: %s\n\n", username);

 /* Retrieving filter information */
 strcpy (lddate, "");

 EXEC SQL SELECT seqfil_id, nb_filter, gain, frequency, lddate
	  INTO	 :seqfil_id, :nb_filter, :gain, :frequency, :lddate
	  FROM   filter_sequence
	  WHERE  name = :name;

 if (strlen (lddate) == 0)
	{
	 printf ("\n Sorry, this filter sequence is not in the database.\n\n");

	 EXEC SQL ROLLBACK WORK RELEASE;

 	 exit(1);
	}

 printf ("\n Nb Filter: %d -- Gain: %11.9f -- Frequency: %5.2f", nb_filter, gain, frequency);

 for (i=1;i<=nb_filter;i++)
	{
	 printf ("\n\n\t Filter %d:", i);
	 printf ("\n\t ---------\n");

	 EXEC SQL SELECT filter_id
		  INTO	 :filter_id
		  FROM	 filter_sequence_data
		  WHERE	 seqfil_id = :seqfil_id AND filter_nb = :i;

	 EXEC SQL SELECT gain, frequency, in_sp_rate, out_sp_rate, offset, delay, correction, seqresp_id
		  INTO	 :gain, :frequency, :in_sp_rate, :out_sp_rate, :offset, :delay, :correction, :seqresp_id
		  FROM	 filter
		  WHERE	 filter_id = :filter_id;

	 printf ("\n\t\t Gain: %11.9f Freq: %5.2f -- In: %5.2f Hz Out: %5.2f Hz\n\t\t Offset: %d Delay: %5.2f Corr: %5.2f", gain, frequency, in_sp_rate, out_sp_rate, offset, delay, correction);

	 EXEC SQL DECLARE resp_cursor CURSOR FOR
	 SELECT resp_nb, resp_type, resp_id, unit_in, unit_out, r_type
	 FROM	response
	 WHERE	seqresp_id = :seqresp_id
	 ORDER BY	resp_nb;

	 EXEC SQL OPEN resp_cursor;

	 EXEC SQL WHENEVER not found DO break;

	 while (1)
		{
		 EXEC SQL FETCH resp_cursor INTO :resp_nb, :resp_type, :resp_id, :unit_in, :unit_out, :r_type;

		 EXEC SQL SELECT name INTO :unitin  FROM D_Unit WHERE id = :unit_in;
		 EXEC SQL SELECT name INTO :unitout FROM D_Unit WHERE id = :unit_out;

		 printf ("\n\t\t\t Type: %c -- In: %.16s Out: %.16s", r_type, unitin, unitout);

		 switch (resp_type)
			{
			 case 'F':
				  EXEC SQL SELECT name, symmetry, gain
					   INTO	  :name, :symmetry, :gain
					   FROM	  filter_fir
					   WHERE  fir_id = :resp_id;

				  printf ("\n\t\t\t FIR Filter: %.12s -- Symmetry: %c -- Gain: %11.9f", name, symmetry, gain);

				  break;

			 case 'H':
				  EXEC SQL SELECT filter_type, nb_pole, corner_freq, damping_value
					   INTO	  :filter_type, :nb_pole, :corner_freq, :damping_value
					   FROM	  response_hp
					   WHERE  hp_id = :resp_id;

				  printf ("\n\t\t\t High-Pass filter: Type: %s -- Nb. Pole: %d -- Corner Freq: %5.2f -- Damping: %5.2f", filter_type, nb_pole, corner_freq, damping_value);
				  break;

			 case 'L':
				  EXEC SQL SELECT filter_type, nb_pole, corner_freq, damping_value
					   INTO	  :filter_type, :nb_pole, :corner_freq, :damping_value
					   FROM	  response_lp
					   WHERE  lp_id = :resp_id;

				  printf ("\n\t\t\t Low-Pass filter: Type: %s -- Nb. Pole: %d -- Corner Freq: %5.2f -- Damping: %5.2f", filter_type, nb_pole, corner_freq, damping_value);
				  break;

			 case 'Z':
				  EXEC SQL DECLARE pz_cursor CURSOR FOR
				  SELECT type, r_value, i_value
				  FROM	response_pz
				  WHERE pz_id = :resp_id
				  ORDER BY	pz_nb;

				  EXEC SQL OPEN pz_cursor;

				  EXEC SQL WHENEVER not found DO break;

				  while (1)
					{
					 EXEC SQL FETCH pz_cursor INTO :type, :r_value, :i_value;

					 printf ("\n\t\t\t Type: %c -- Real: %5.2f -- Imag: %5.2f", type, r_value, i_value);
					}

				  EXEC SQL CLOSE pz_cursor;
				  break;

			 case 'P':
				  EXEC SQL SELECT poly_type, lower_bound, upper_bound, max_error, nb_coeff
				  INTO	:poly_type, :lower_bound, :upper_bound, :max_error, :nb_coeff
				  FROM	response_pn
				  WHERE	pn_id = :resp_id;

				  printf ("\n\t\t\t Polynomial: Type: %c -- Lower: %5.2f -- Upper: %5.2f -- Max. Error: %5.2f -- Nb Coeff: %d", poly_type, lower_bound, upper_bound, max_error, nb_coeff);

				  EXEC SQL DECLARE pn_cursor CURSOR FOR
				  SELECT pn_nb, pn_value
				  FROM 	response_pn_data
				  WHERE	pn_id = :resp_id
				  ORDER BY	pn_nb;

				  EXEC SQL OPEN pn_cursor;

				  EXEC SQL WHENEVER not found DO break;

				  while (1)
					{
					 EXEC SQL FETCH pn_cursor INTO :pn_nb, :pn_value;

					 printf ("\n\t\t\t Coeff: %d -- Value: %5.2f", pn_nb, pn_value);
					}

				  EXEC SQL CLOSE  pn_cursor;
				  break;
			}
		}

	 EXEC SQL CLOSE resp_cursor;
	}

 printf ("\n\n");
  
 /* Disconnect from the database. */
 printf ("\n Disconnecting from ORACLE ...\n\n");
 EXEC SQL COMMIT WORK RELEASE;

 exit(0);
}

/* Handle errors. Exit on any error. */
void	sql_error()
{
 char msg[512];
 size_t buf_len, msg_len;


 EXEC SQL WHENEVER SQLERROR CONTINUE;

 buf_len = sizeof(msg);
 sqlglm (msg, &buf_len, &msg_len);

 printf ("\nORACLE error detected:");
 printf ("\n%.*s \n", msg_len, msg);

 EXEC SQL ROLLBACK WORK RELEASE;

 exit(1);
}