/************************************************************************/
/*  Build_SEED - Build SEED volumes from user request.			*/
/*	Runs programs:	netdc2meta					*/
/*			meta2seed (which runs read_POD_Request)		*/
/*			pod						*/
/*	Input:		netdc request file and/or POD request file OR	*/
/*			command line channel and time specification.	*/
/************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <math.h>
#include <ctype.h>
#include <assert.h>

#include <qlib2.h>

#define		WORKDIR		"/tmp"

char *syntax[] = {
"%s [-h] [-n netdc_file | [-f date -t date | -s interval] ",
"    [-S station] [-N network] [-C channel] [-L location]",
"    [-p pod_file] [-D datapath] [-o seed_file] [-I] ",
"    [-w workdir] [-b poddir] [-d n]",
"    where:",
"	-h	    Prints out a summary of the available options.",
"	-n filename Specifies the name of the NetDC requests file.",
"	-f date	    From date - ignore data before this date.",
"	-t date	    To date - ignore data from this date on.",
"		    Date can be in formats:",
"			yyyy/mm/dd/hh:mm:ss.ffff",
"			yyyy/mm/dd.hh:mm:ss.ffff",
"			yyyy/mm/dd,hh:mm:ss.ffff",
"			yyyy.ddd,hh:mm:ss.ffff",
"			yyyy,ddd,hh:mm:ss.ffff",
"		    You may leave off any trailing 0 components of the time.",
"	-s interval span interval.  Alternate way of specifying end time.",
"		    Interval can be an integer followed immediately by",
"		    s, m, h, or d for seconds, minutes, hours, or days.",
"	-S station_list",
"		    A comma-delimited list of station names for the specified time.",
"	-N network_list",
"		    A comma-delimited list of network names for the specified time.",
"	-C channel_list",
"		    A comma-delimited list of channel names for the specified time.",
"	-L locationlist",
"		    A list of location names for the specified time.",
"	-p filename Specifies the name of an additional POD requests file.",
"	-D datapath Additional explicit POD DATA_PATH entry.",
"	-o filename Specifies the name of the output SEED volume.",
"	-I	    Generates a Dataless SEED volume.",
"	-w dir	    Specifies the path of the working directory.",
"		    If none specified, a temporary working directory",
"		    will be created in /tmp and deleted when done.",
"	-b dir      Specifies the path and name of the POD request",
"		    directory structure (HAR000).",
"	-d n	    Debug option (may be added)",
"			1-3 POD debug flags",
"			4   Print commands",
"			8   Keep query directory",
"                        16  Keep waveform directory",
NULL };

#define	DEBUG(val)  (debug_flag & val)
#define	DEBUG_POD   3
#define	DEBUG_CMD   4
#define	DEBUG_KEEP  8

#define	METAFILE    "Query.in"
#define	MAXJOINLEN  65536

char *cmdname;

typedef struct _listhead {
    char **name;
    int n;
} LISTHEAD;
LISTHEAD station;
LISTHEAD channel;
LISTHEAD location;
LISTHEAD network;

LISTHEAD add_to_list (LISTHEAD l, char *clist)
{
    char *str = strdup(clist);
    char *p = str;
    char *pc;
    char *e;
    while (p != NULL && *p != 0) {
	e = strchr(p,',');
	if (e != NULL) *e = '\0';
	if (l.name == NULL) l.name = (char **)malloc((l.n+1) * sizeof(char **));
	else l.name = (char **)realloc(l.name, (l.n+1) * sizeof(char **));
	l.name[l.n] = strdup(p);
	for (pc=l.name[l.n]; *pc; pc++) {
	    /* 1.  Replace "-" with blank (for location code). */
	    if (*pc == '-') *pc = ' ';
	    /* 2.  Replace "*" with "%" for unix->sql 0-n char wildcard. */
	    if (*pc == '*') *pc = '%';
	    /* 3.  Replace "?" with "_" for unix->sql 1 char wildcard. */
	    if (*pc == '?') *pc = '_';
	}
	l.n++;
	p = (e!=NULL) ? e+1 : NULL;
    }
    free(str);

    /*:: Debug 
    {int i;for (i=0;i<l.n;i++) printf ("[%s]", l.name[i]);printf ("\n");}
    ::*/

    return(l);
}

char *join (char *delim, LISTHEAD l)
{
    static char str[MAXJOINLEN];
    int i;
    int len = 0;
    str[0] = '\0';
    if (l.n <= 0) return (str);
    assert (len+strlen(l.name[0])<MAXJOINLEN);
    strcpy (str, l.name[0]);
    for (i=1;i<l.n;i++) {
	assert (len+strlen(l.name[0]+1)<MAXJOINLEN);
	strcat (str, delim);
	strcat (str, l.name[i]);
    }
    return (str);
}
	
/************************************************************************/
/*  like_string:							*/
/*	convert a field_val string that is intended as a comparison to 	*/
/*	a database field of field_name from a bar '|' separated set of	*/
/*	SQL-wildcarded phrases to a compound set of 'LIKE' statements 	*/
/*	example:  like_string("myfield","%a%|%b%|%c%") returns		*/
/*	"myfield like '%a%' OR myfield like '%b%' OR myfield like '%c%'"*/
/*	Assumes no leading spaces present in parameters.		*/
/************************************************************************/
char *like_string(char *field_name, char *field_val) 
{
    char like_expr[4096],like_tmp[64],tmp_str[64];
    int i,append,string_len;

    i=0;  /* i is the character index */
    append=0;  /* append indicates that first expression is past */
    like_expr[0] = '\0';
    while (field_val[i] != '\0') {
	string_len = strcspn(field_val+i,"|");  /* token separator */
	strncpy(tmp_str,field_val+i,string_len);
	tmp_str[string_len] = '\0';
	if (append) strcat(like_expr," OR ");
	sprintf(like_tmp,"%s like '%s'",field_name,tmp_str);
	strcat(like_expr,like_tmp);
	append = 1;
	i+=string_len;
	if (field_val[i] == '|') i++;  /* prevents skipping over NULL */
    }
    return (like_expr);
}


/************************************************************************/
/*	Main procedure.							*/
/************************************************************************/
void main (int argc, char *argv[])
{
    FILE	*f_query_in;
    char	query_in[255];
    char	query_line[255];
    char	cmd[2048];
    char	*seed_name = "./volume.seed";
    char	workdir[2048];
    char	netdc_name[255];
    char	har_name[255];
    char	hostname[11];
    char	*Add_podreq;
    char	*Add_Datapath;
    int	Flag_Resp  = 0;
    int	Flag_Start = 0;
    int	Flag_End   = 0;
    int	Flag_Span  = 0;
    int	Flag_Name  = 0;
    int	Flag_Dir   = 0;
    int	Flag_Netdc = 0;
    int	Flag_Net   = 0;
    int	Flag_Sta   = 0;
    int	Flag_Cha   = 0;
    int	Flag_Loc   = 0;
    int	Flag_Pod   = 0;
    int	Flag_Har   = 0;
    int	debug_flag = 0;
    int	i, l;
    int	ret_code;
    char	all_net[1024] = "";
    char	all_sta[1024] = "";
    char	all_cha[1024] = "";
    char	all_loc[1024] = "";
    char	buf[2048];
    char	*span;
    struct stat statbuf;

    INT_TIME start_time;
    INT_TIME end_time;
    INT_TIME duration;
    INT_TIME *pt;
    EXT_TIME stime_et;
    EXT_TIME etime_et;

    /* Variables needed for getopt. */
    extern char	*optarg;
    extern int	optind, opterr;
    int		c;

    cmdname = tail(argv[0]);
    /*	Parse command line options.					*/
    while ( (c = getopt(argc,argv,"hd:f:t:s:p:D:n:R:o:b:w:S:N:C:L:I")) != -1)
	switch (c) {
	case '?':
	case 'h':   print_syntax(cmdname,syntax,stdout); exit(0); break;
	case 'd':   debug_flag = atoi(optarg); break;
	case 'f':
	    if ((pt = parse_date (optarg)) == NULL) {
		fprintf (stderr, "Error: invalid date: %s\n", optarg);
		exit(1);
	    }
	    start_time = *pt;
	    Flag_Start = 1;
	    break;
	case 't':
	    if ((pt = parse_date (optarg)) == NULL) {
		fprintf (stderr, "Error: invalid date: %s\n", optarg);
		exit(1);
	    }
	    end_time = *pt;
	    Flag_End = 1;
	    break;
	case 's':
	    span = optarg; ++Flag_Span; 
	    Flag_Span = 1;
	    break;
	case 'p':   Add_podreq = optarg; break;
	case 'D':   Add_Datapath = optarg; break;
	case 'n':   Flag_Netdc = 1; strcpy(netdc_name, optarg); break;
	case 'o':   seed_name = optarg; break;
	case 'w':   Flag_Dir = 1; strcpy(workdir,optarg); break;
	case 'S':   Flag_Sta = 1; station = add_to_list(station,optarg); break;
	case 'N':   Flag_Net = 1; network = add_to_list(network,optarg); break;
	case 'C':   Flag_Cha = 1; channel = add_to_list(channel,optarg); break;
	case 'L':   Flag_Loc = 1; location = add_to_list(location,optarg); break;
	case 'I':   Flag_Resp = 1; break;
	case 'b':   Flag_Har = 1;
		    strcpy (har_name, optarg);
		    if (stat (har_name, &statbuf) == (-1))
			{
			 printf ("\n Error: Path %s is not valid.\n\n", har_name);
			 exit (-1);
			}
		    break;
	default:
	    fprintf (stderr, "Error: Unknown option: -%c\n", c);
	    exit(1);
	}

    /* Updating Flags */
    if ((Flag_Start == 0) && (Flag_Netdc == 0))
    {
	fprintf (stderr, "Error: No time interval or NetDC request file specified.\n");
	exit (1);
    }

    if (Flag_End && Flag_Span) {
	fprintf (stderr, "Error: span and endtime mutually exclusive\n");
	exit(1);
    }
    if (Flag_Span && ! Flag_Start) {
	fprintf (stderr, "Error: span not valid without start time\n");
	exit(1);
    }
    if (Flag_Span && ! valid_span(span)) {
	fprintf (stderr, "Error: invalid span specification: %s\n", span);
	exit(1);
    }
    if (Flag_Span) {
	end_time = end_of_span (start_time, span);
	++Flag_End;
    }
    if ((Flag_Start || Flag_End) && ! (Flag_Start && Flag_End)) {
	fprintf (stderr, "Error: Must specify both start and end time if either specified\n");
	exit (1);
    }
    if (Flag_Start) {
	stime_et = int_to_ext (start_time);
    }
    if (Flag_End) {
	etime_et = int_to_ext (end_time);
    }

    if (Flag_Net  == 0) strcpy (all_net, "%");
    else strcpy (all_net, join("|",network));

    if (Flag_Sta  == 0) strcpy (all_sta, "%");
    else strcpy (all_sta, join("|",station));

    if (Flag_Cha  == 0) strcpy (all_cha, "%");
    else strcpy (all_cha, join("|",channel));

    if (Flag_Loc  == 0) strcpy (all_loc, "%");
    else strcpy (all_loc, join("|",location));

    if (Flag_Dir == 0)
    {
	/* Creating directory */
	gethostname (hostname, 10);
	sprintf (workdir, "%s/%s.%d", WORKDIR, hostname, getpid ());
	mkdir (workdir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
    }

    /* NetDC requests */
    if (Flag_Netdc == 1)
    {
	FILE *tmp_ptr2, *pipe_ptr;
	char buf[1024];
	int status;

	tmp_ptr2 = fopen (netdc_name, "r");

	sprintf (cmd, "netdc2meta %s %s/%s", 
		 ((Flag_Resp) ? "-I" : ""), workdir, METAFILE);
	if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
	if ((pipe_ptr = popen (cmd,"w")) == NULL)
	{
	    fprintf (stderr, "Error: Unable to open command pipe to netdc2meta\n");

	    exit (-1);
	}

	while (fgets (buf, 1024, tmp_ptr2) != NULL)
	    fputs (buf, pipe_ptr);

	status = pclose (pipe_ptr);
    }
    else
    {
	/* Opening METAFILE file */
	sprintf (query_in, "%s/%s", workdir, METAFILE);
	if ((f_query_in = fopen (query_in, "w+t")) == NULL)
	{
	    fprintf (stderr, "Error: Couldn't open file %s.\n", query_in);
	    exit (129);
	}
   
	/* Building meta query file */
	fprintf (f_query_in, "5\n");

	strcpy(buf,like_string("net",all_net));
	fprintf (f_query_in, "%s\n", buf);

	strcpy(buf,like_string("sta",all_sta));
	fprintf (f_query_in, "%s\n", buf);

	strcpy(buf,like_string("location",all_loc));
	fprintf (f_query_in, "%s\n", buf);

	strcpy(buf,like_string("seedchan",all_cha));
	fprintf (f_query_in, "%s\n", buf);

	if (Flag_Resp == 0)
	{
	    fprintf (f_query_in, "%04d/%02d/%02d %02d:%02d:%02d.%04d\n",
		     stime_et.year, stime_et.month, stime_et.day,
		     stime_et.hour, stime_et.minute, stime_et.second,
		     stime_et.usec/USECS_PER_TICK);
	    fprintf (f_query_in, "%04d/%02d/%02d %02d:%02d:%02d.%04d\n",
		     etime_et.year, etime_et.month, etime_et.day,
		     etime_et.hour, etime_et.minute, etime_et.second,
		     etime_et.usec/USECS_PER_TICK);
	}
	else
	{
	    fprintf (f_query_in, "%04d,%03d,%02d:%02d:%02d.%04d\n",
		     stime_et.year, stime_et.doy,
		     stime_et.hour, stime_et.minute, stime_et.second,
		     stime_et.usec/USECS_PER_TICK);
	    fprintf (f_query_in, "%04d,%03d,%02d:%02d:%02d.%04d\n",
		     etime_et.year, etime_et.doy,
		     etime_et.hour, etime_et.minute, etime_et.second,
		     etime_et.usec/USECS_PER_TICK);
	}

	/* Closing METAFILE file */
	fclose (f_query_in);
    }

    /* Calling meta2seed to process query. */
    sprintf (cmd, "meta2seed -w %s -o %s -d %d %s %s %s %s %s %s %s %s/%s",
	     workdir, seed_name, debug_flag,
	     ((Flag_Resp) ? "-I" : ""), 
	     ((Add_podreq) ? "-p" : ""),
	     ((Add_podreq) ? Add_podreq : ""),
	     ((Flag_Har) ? "-b" : ""),
	     ((Flag_Har) ? har_name : ""),
	     ((Add_Datapath) ? "-D" : ""),
	     ((Add_Datapath) ? Add_Datapath : ""),
	     workdir, METAFILE);
    if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
    ret_code = system (cmd);

    /* Delete files */
    if (DEBUG(DEBUG_KEEP) || DEBUG(DEBUG_POD))
    {
	printf ("Temporary files in %s\n", workdir);
    }
    else if (! Flag_Dir) 
    {
	sprintf (cmd, "rm -rf %s", workdir);
	if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
	system (cmd);
    }
    /* Testing return code */ 
    if (WEXITSTATUS (ret_code) != 0)
	printf ("Error while processing your request [%d].\n", WEXITSTATUS (ret_code));
    exit (WEXITSTATUS (ret_code));
    exit (WEXITSTATUS (ret_code));
}