#!perl
#

package buildSplit;

use strict;

use Exporter ();
use vars qw(@ISA @EXPORT);
BEGIN {
  @ISA = qw(Exporter);
  @EXPORT = qw(&getData &doSQLdatasetOutput &doSQLgetDatasets);
}


1;

#-----------------------------

sub getData {

  use DBI;
  use strict;
    
# Read the database, username and password from a file
# The file must be three lines with database, username and password
# on separate lines.  There must be no blank lines at the
# end of the file.
#  my $dbname;
#  my $temp;
#  my $user;
#  my $password;
#  open (USERNAME,"test.user") || die "can't open file: $!";
#  while (defined ($temp = <USERNAME>)) 
#  {
#      chomp $temp;
#      $dbname = $temp;
#      $user=<USERNAME>;
#      chomp $user;
#      $password=<USERNAME>;
#      chomp $password;
#  };
#  close (USERNAME) || die "couldn't close file: $!";

  open (OUT, ">-") || die "I/O error accessing STDOUT:$!";

# look for functionality arguments in the list of arguments
#   supported functionality arguments are
#      "--resplit=[column_name,streams]" resplit according to column_name, 
#                                        omiting streams specified, e.g. ad
#                                        to omit streams a,d 
#      "--compress=[compressed streams]" provide compressed output for streams 
#                                        e.g., hj to provide compressed for h,j
# first look for "--" arguments
  
#  print STDERR "before filtering options: @_ \n";
  my $argument; 
  my @optionNum; 
  my @optionList;
  my @filteredArgs;
  foreach $argument (@_) {
      if ( $argument =~ /--/ ) {
#	  print STDERR "located an argument $argument \n";
	  push @optionList, $argument;
      }
      else {
	  push @filteredArgs, $argument;
      }
  }
#  print STDERR "after filtering options: @filteredArgs \n";

  $main::resplit_column="NONE";
  $main::compress_streams=" ";
  $main::resplit_omitstreams=" ";
  foreach $argument (@optionList) {
      if ($argument =~ /resplit/ ) {
	  my @specs = split /[=\,]/,$argument,3;
	  $main::resplit_column=$specs[1];
	  $main::resplit_omitstreams=$specs[2];
      }
      if ($argument =~ /compress/ ) {
	  my @specs = split /[=\,]/,$argument,3;
	  $main::compress_streams=lc $specs[1];
      }
  }
	  
# first argument is the stream_name_used flag
  $main::stream_name_used = shift @filteredArgs; 
        
# template file name
  my $template = shift @filteredArgs;

#  name and tag of the physics table and are passed in as arguments
  $main::phys_table = shift @filteredArgs; 
  $main::phys_table_tag = shift @filteredArgs;
  print OUT "#Physics Table name and tag are: $main::phys_table, $main::phys_table_tag\n";
  
# Removed use of test.user for connecting to database, using the 
# cdf_reader login which is READ ONLY.  Which database to connect
# to is now passed in as an argument - KAT 10/17/00
  my $dbname = shift @filteredArgs;
  my $user = "cdf_reader";
  my $password = "reader";
# Hard wiring password and username for development database since
# a cdf_reader which sees the trigger tables doesn't exist on cdfondev
#  $dbname = "cdfondev";
  if ($dbname eq "cdfondev")
  {
      $user = "level3_trig_dev";
      $password = "level3";
  }

#  print STDERR "arguments are now : $dbname, $user, $password \n";

#note how connection specifies Oracle here, msql, mysql or any
#other DBI driver will work exactly the same
#
  $main::dbh = DBI->connect("dbi:Oracle:$dbname",$user,$password) ||
    die "Error connecting $DBI::errstr\n";

#hard coded: connection to cdfofprd because filecatalog queries do not work on
#cdfonprd used for the L3exe build
#
  $main::dbh_ofprd = DBI->connect("dbi:Oracle:cdfofprd","cdf_reader","reader") || die "Error connecting $DBI::errstr\n";

  my $myfile=$template;
  my $line;
  
  open(TEMPLATE, $myfile) or die "unable to open $myfile:$!";
  while( $line = <TEMPLATE> )
  {
      if ( (index $line,'<TT PATHS>') != -1 )
      {
          &buildInput::doSQLprereqclone('SPLITTER');
# build prerequisites from Level1, Level2 and Level3 requirements
#          &buildInput::doSQLpaths(1,2,3);
# Production splitting should only listen to Level-3 trigger path index
# so setting L1Accept and L2Accept true KAT 4/3/01
          &buildInput::doSQLpaths('SPLITTER',3);
      }
      elsif ( (index $line,'<TT OUTPUT>') != -1 )
      {
	  &doSQLdatasetOutput;  
      } 
      else
      {
          print "$line";
      };
  };
  
  
  $main::dbh->rollback;
  $main::dbh->disconnect;
  
#---------------------------------------------------
  sub doSQLdatasetOutput  {

 
# get datasets associated with physics table
    my @dataset_list;
    my $ref_to_list = &doSQLgetDatasets;
    @dataset_list = @$ref_to_list;

    my $dataset;
    my @dataset;

    my @streamList;

    my $part;
    my @row;
    my $pass;
    
# RESPLIT
    my @resplitList;   # array of arrays

# preliminary loop through datasets to get a list of generic names
    my %generic_by_dataset;
    my @generic_list;
    foreach $dataset(@dataset_list)
      {
        @dataset = split /:/, $dataset; 
        my ($handle) = $main::dbh->prepare("select generic_dataset from 
                 datasets where dataset_name='$dataset[0]' and
                 dataset_tag='$dataset[1]'");  
        if($DBI::err)
          {&buildInput::reportDbError("fetching generic dataset:",
                                      $DBI::errstr);}
        $handle->execute();
        if($DBI::err)
          {&buildInput::reportDbError("fetching generic dataset:",
                                      $DBI::errstr);}
        if (my $generic = $handle->fetchrow){
          if($DBI::err)
            {&buildInput::reportDbError("fetching generic dataset:",
                                        $DBI::errstr);}
          $generic_by_dataset{$dataset}=$generic;
          push @generic_list, $generic;
        }
      }



# preliminary loop through datasets to get a list of stream names
    my %stream_by_dataset;
    foreach $dataset(@dataset_list)
      {
        @dataset = split /:/, $dataset; 
        my ($handle) = $main::dbh->prepare("select logger_datastream from 
                 datasets where dataset_name='$dataset[0]' and
                 dataset_tag='$dataset[1]'");  
        if($DBI::err)
          {&buildInput::reportDbError("fetching logger_datastream:",
                                      $DBI::errstr);}
        $handle->execute();
        if($DBI::err)
          {&buildInput::reportDbError("fetching logger_datastream:",
                                      $DBI::errstr);}
        if (my $stream = $handle->fetchrow){
          push @streamList, $stream;
          $stream_by_dataset{$dataset} = $stream;
        }
      }


#
# Remove duplicate stream names.  Either make a hash indexing streams to
#  A, B, C, D... etc. or use the stream name itself
#
    @streamList = sort @streamList;
    my %stream_index = ();
    my $last_stream = '<none>';
    my $new_stream;
    my $next_index = 'a';
    foreach $new_stream (@streamList)
      {
	  my $reduced_name = lc join("",split("STREAM",uc $new_stream)); 
	  $stream_index{$new_stream} = $reduced_name;

	  if ( $reduced_name ne "none")
	  {
	      
	      if ( $main::stream_name_used )
	      {
		  #my $reduced_name = lc join("",split("STREAM",uc $new_stream)); 
#           print STDERR "Stream Reduction: $new_stream to $reduced_name\n";
		  if ( $reduced_name lt "a" || $reduced_name gt "z" 
		       || length($reduced_name) > 1 )
		  {
		      print STDERR "Stream Name $new_stream is illegal\n";
		      print OUT "#Stream Name $new_stream is illegal\n";
		      die;
		  }
	      }
	      else
	      {
		  # only increment stream index if the stream is unique
		  if ($new_stream ne $last_stream 
		      && $last_stream ne '<none>') {$next_index++;} 
		  $last_stream = $new_stream;
	      }
	  }
      }
    


# this is the place where we check that a single
#   generic dataset doesn't populate multiple streams!!!!
#
    my %stream_by_generic;
    foreach $dataset(@dataset_list) 
      {
        if (exists $stream_by_dataset{$dataset} &&
            exists $generic_by_dataset{$dataset}    )
          {
            if (exists $stream_by_generic{$generic_by_dataset{$dataset}})
              {
                if ($stream_by_dataset{$dataset} ne
                    $stream_by_generic{$generic_by_dataset{$dataset}})
                  {
                    &buildInput::reportDbError("FATAL: generic dataset ",
                                       $generic_by_dataset{$dataset},
                                       " is in at least two datastreams: ",
                                       $stream_by_dataset{$dataset},
                     " and ",$stream_by_generic{$generic_by_dataset{$dataset}},
                                               ".\n");
                    die;
                  }
              }
            else
              {
                $stream_by_generic{$generic_by_dataset{$dataset}}=
                  $stream_by_dataset{$dataset};
              }
          }
      }


# main loop through datasets to write tcl

    my %used_generic_dataset;

    foreach $dataset(@dataset_list) {
 
# the list from doSQLgetDatasets returns a joined list of datasets and 
# tags, so you need to split the dataset from the tag...

        @dataset = split /:/, $dataset; 
        
        
        my $path;
        my @path_list;

        my $stream = $stream_by_dataset{$dataset};

	if ($stream_index{$stream} ne "none")
	{

	    print OUT "\n# dataset $dataset[0]_v$dataset[1] is logged to stream $stream (stream index $stream_index{$stream})\n#   and is associated with generic dataset $generic_by_dataset{$dataset}\n";

	    
# RESPLIT
	    my ($handle);
	    if ($main::resplit_column eq "NONE") {
	      ($handle) = $main::dbh->prepare("select path_name,path_tag 
                 from datasets_trigger_paths where dataset_name='$dataset[0]'
                 and dataset_tag='$dataset[1]'");
#                 datasets.logger_datastream='$stream' and
#                 datasets.dataset_name=datasets_trigger_paths.dataset_name");
	    }
	    else {
	      ($handle) = $main::dbh->prepare("select 
                 trigger_paths.path_name,trigger_paths.path_tag,
                            trigger_paths.".$main::resplit_column." from
                 trigger_paths,datasets_trigger_paths
                 where datasets_trigger_paths.dataset_name='$dataset[0]'
                 and datasets_trigger_paths.dataset_tag='$dataset[1]'
                 and datasets_trigger_paths.path_name=trigger_paths.path_name
                 and datasets_trigger_paths.path_tag=trigger_paths.path_tag");	      
	    }
# no longer select on logger datastream
#                 datasets.logger_datastream='$stream' and 
#                 datasets.dataset_name=datasets_trigger_paths.dataset_name"); 
	    if($DBI::err)
	    {&buildInput::reportDbError("fetching path:",
					$DBI::errstr);}
	    $handle->execute();
	    if($DBI::err)
	    {&buildInput::reportDbError("fetching path:",
					$DBI::errstr);}
	    my @pathNtag;
	    while (@pathNtag = $handle->fetchrow)
	    {
		if($DBI::err)
		{
		    &buildInput::reportDbError("fetching path:",
					       $DBI::errstr);
		    return;
		}
# RESPLIT
		my $resplitValue = "DEFAULT";
		if ( $main::resplit_column ne "NONE" ) { 
		    $resplitValue = uc $pathNtag[2];
		}
		if ( $resplitValue ne "DEFAULT" && $resplitValue ne "$generic_by_dataset{$dataset}" && ((index $main::resplit_omitstreams, $stream_index{$stream}) == -1) )
		{
# put onto the resplit list
		    print OUT "#      trigger path $pathNtag[0]_v$pathNtag[1] is being resplit by $main::resplit_column to $resplitValue\n";
		    push @resplitList, [ $resplitValue, $stream_index{$stream},
					 $pathNtag[0].'_v'.$pathNtag[1] ];
		    if ((index $main::compress_streams,$stream_index{$stream}) != -1){
			print OUT "#      trigger path $pathNtag[0]_v$pathNtag[1] is being resplit by compressed streams to ".$resplitValue."_COMPRESSED \n";
			push @resplitList, [ $resplitValue.'_COMPRESSED', 
					     $stream_index{$stream},
					     $pathNtag[0].'_v'.$pathNtag[1] ];
		    }
		}
		else {
# this is the default action...
#		    print OUT "#      trigger path $pathNtag[0]_v$pathNtag[1] is not being resplit\n";
		    push @path_list, $pathNtag[0].'_v'.$pathNtag[1];
		    if ((index $main::compress_streams,$stream_index{$stream}) != -1){
#		         print STDERR "testing trigger path, $main::compress_streams, $stream_index{$stream} \n";
			print OUT "#      trigger path $pathNtag[0]_v$pathNtag[1] is being resplit by compressed streams to ".$generic_by_dataset{$dataset}."_COMPRESSED \n";
			push @resplitList, [ $generic_by_dataset{$dataset}.'_COMPRESSED', 
					     $stream_index{$stream},
					     $pathNtag[0].'_v'.$pathNtag[1] ];
		    }
		}
	    }  
# end of loop over trigger paths returned by dataset query
	
#
#  remove duplicate path names
#
	    @path_list = sort @path_list;
	    my @unique_path;
	    my $last_path = -1;
	    foreach $path (@path_list)
	    {
#            print "$name,$lastname\n";
		if ($path ne $last_path) 
		{
		    push @unique_path, $path;
		}
		$last_path = $path;
	    }
	    
	    if ( $#unique_path >= 0 ) {
		print OUT "if { \$rawDataStream == \"$stream_index{$stream}\" } then {\n"; 	    
		if (!exists $used_generic_dataset{$generic_by_dataset{$dataset}}) {
#  replace $dataset[0]_v$dataset[1] (specific dataset name) 
#     with generic dataset name

# for Production as Liz's spec:
		  my $generic = $generic_by_dataset{$dataset};		  
		  my $sth = $main::dbh_ofprd->prepare("select distinct ds.ds_name_id from filecatalog.cdf2_datasets ds, filecatalog.cdf2_generic_datasets gds where substr(ds.ds_name_id,2,3)=gds.mnemonic and gds.generic_dataset='$generic' and substr(ds.ds_name_id,1,1)=gds.stream");
		  if($DBI::err)
		    {&buildInput::reportDbError("fetching generic dataset:",
						$DBI::errstr);}
		  $sth->execute();
		  if($DBI::err)
		    {&buildInput::reportDbError("fetching generic dataset:",
						$DBI::errstr);}
		  my $subpart;
		  while ( @row  = $sth->fetchrow ) {
		    foreach $part(@row) {
		      $subpart = substr $part, 0, 4;
#		      print OUT "$part";
		    }
		  }
		  print OUT "output create $generic_by_dataset{$dataset} ./ \n";
		  print OUT "stdOutCommands $generic_by_dataset{$dataset} ";
		  print OUT "$subpart\$prodPass \n";
		    $used_generic_dataset{$generic_by_dataset{$dataset}} = 'YES';
		}
	    
		print OUT "output path $generic_by_dataset{$dataset} ";
		foreach $path (@unique_path)
		{
		    print OUT "$path ";
		}
		
		print OUT "\n";
		print OUT "}\n";
	    }
	} 
	else {
	    print OUT "\n# dataset $dataset[0]_v$dataset[1] is logged to stream $stream (stream index $stream_index{$stream})\n#   and is not associated with a generic dataset \n";	    
	}
# end of if "is associated with a generic dataset"
	
    }    
# end of loop over datasets

#RESPLIT
#
# first group resplits by resplit dataset name
#
    my %resplit_by_generic; my %stream_by_resplit_generic;
    my $i=0; my $nResplit = $#resplitList;
    for ($i=0;$i<=$nResplit;$i++) {
	my $stream = $resplitList[$i][1];
	my $Gdataset = $resplitList[$i][0];
	my $path = $resplitList[$i][2];
	if ( ! exists $resplit_by_generic{$Gdataset} ){
	    $resplit_by_generic{$Gdataset} = [ $path ];
	    $stream_by_resplit_generic{$Gdataset} = $stream;
	}
	else {
	    push @{$resplit_by_generic{$Gdataset}},$path;
	    if ($stream_by_resplit_generic{$Gdataset} ne $stream) {
                    &buildInput::reportDbError("FATAL: resplit generic dataset ",
                                       $Gdataset,
                                       " spans at least two datastreams: ",
                                       $stream_by_resplit_generic{$Gdataset},
                                       " and ",$stream,".\n");
                    die;
	    }
	}
    }
#
#  now loop over resplits and produce their output comands
#
    print OUT "#RESPLIT STREAMS\n";
    print OUT "# respliting $nResplit triggers... \n";

    foreach $dataset (keys %resplit_by_generic) {
#      my @generic1 = split /_COMPRESSED/, $dataset;
#      print "generic : $generic1[0]";
      my $generic1 = $dataset;
      my $sth1 = $main::dbh_ofprd->prepare("select distinct ds.ds_name_id from filecatalog.cdf2_datasets ds, filecatalog.cdf2_generic_datasets gds where substr(ds.ds_name_id,2,3)=gds.mnemonic and gds.generic_dataset='$generic1' and substr(ds.ds_name_id,1,1)=gds.stream");
      if($DBI::err)
	{&buildInput::reportDbError("fetching generic dataset:",
				    $DBI::errstr);}
      $sth1->execute();
      if($DBI::err)
	{&buildInput::reportDbError("fetching generic dataset:",
				    $DBI::errstr);}
      my $subpart1 = "";
      while ( @row  = $sth1->fetchrow ) {
	foreach $part(@row) {
	  $subpart1 = substr $part, 0, 4;
#	  		      print OUT "part : $part \n";
	}
      }
      print OUT "if { \$rawDataStream == \"$stream_by_resplit_generic{$dataset}\" } then {\n"; 	    
      print OUT "output create $dataset ./ \n";
      if ( $dataset =~ /COMPRESSED/ ) {
	  print OUT "$stream_by_resplit_generic{$dataset}pad_dropList $dataset \n";
      }      
      print OUT "stdOutCommands $dataset ";
      print OUT "$subpart1\$prodPass \n";
      print OUT "output path $dataset @{$resplit_by_generic{$dataset}} \n";
      print OUT "}\n";
    }
}

#---------------------------

sub doSQLgetDatasets  
 {
     open (OUT, ">-") || die "I/O error accessing STDOUT:$!";
     
     #need the list of datasets used with the physics table
     my @dataset_list;
#
# Getting the names of all associated data sets (used in this
# particular physics table)
#
     my ($handle) = $main::dbh->prepare("select dataset_name, dataset_tag from 
                            datasets_physics_tables where 
                            physics_table_name='$main::phys_table' and
                            physics_table_tag='$main::phys_table_tag'");
     if($DBI::err)
       {&buildInput::reportDbError("fetching dataset:",
                                   $DBI::errstr);}
     $handle->execute();
     if($DBI::err)
       {&buildInput::reportDbError("fetching dataset:",
                                   $DBI::errstr);}
     
     my @dataset;
     while (@dataset = $handle->fetchrow)
     {
	 if($DBI::err)
	 {
       &buildInput::reportDbError("fetching dataset:",
                                  $DBI::errstr);
       return;
	 }
	 @dataset = join ":", @dataset;
	 push @dataset_list, @dataset;
     }
#
#  remove duplicate dataset names (stolen from doSQLoutput)
#
     
     @dataset_list = sort @dataset_list;
     my @unique_dataset;
     my $last_dataset = -1;
     my $dataset;
     foreach $dataset (@dataset_list)
     {
#            print "$name,$lastname\n";
	 if ($dataset ne $last_dataset) 
	 {
	     push @unique_dataset, $dataset;
	 }
	 $last_dataset = $dataset;
     }
     
     return (\@unique_dataset);
     
 }

} # matches getData