#!/usr/bin/perl

use Getopt::Long;

# 1. Get parameters
versions();
setup();

if ($ownsource) {
    doOwnSource();
    exit(0);
}

# 2. Prepare RPM (special version needed for SL4, ok for SL5 and later)
rpmSetup();
# 4. Install HCAL release
installHCAL();
installSetups();
# 5. Environment script
makeEnvironment();
system("chmod u+x $binloc/*.exe");

sub versions {
    @allpackages=("hcalAux","hcalBase","hcalCalib","hcalClassic","hcalDCC","hcalHW","hcalMonVis",
		  "hcalOnlineDB","hcalRBX","hcalSupervisor","hcalTrig","hcalAlarm","hcalCCM","hcalUpgrade","hcalUHTR","hcalUTCA","hcalngRBX");

    %versions=();
    $versions{"Release"}="13_2_1";
    $versions{"HCALdaq"}=$versions{"Release"};
    $slc_version=`expr \$(uname -r) : '.*el\\\([0-9]\\\)'`;
    $cmsos=`expr \$(grep "PACKAGE_RELEASE=" /opt/xdaq/config/mfRPM.release) | sed 's/PACKAGE_RELEASE=//' | tr -d '\n'`;
    if ($slc_version == 5) {
	$versions{"ROOT"}="hcal-root-5.28.00f-gcc412";
	$versions{"XDAQ"}=$cmsos.".slc5.gcc4_1_2";
    } elsif ($slc_version == 6) {
	$versions{"ROOT"}="hcal-root-5.28.00f-gcc44";
	$versions{"XDAQ"}=$cmsos.".slc6.gcc4_4_7";
    } else {
        print "No SLC Version Detected";
        exit(1);
    }
}

sub setup {
    $prefix="default";
    $xdaqroot="/opt/xdaq";
    $arch=`uname -i`;
    chomp($arch);

    $xdaqarch=$versions{"XDAQ"}.".".$arch;

    $mode="unknown";
    $hcalRepo="http://cmshcalweb01.cern.ch/hcalsw";
    $source="1";
    $clean='';
    $help='';
    $ownsource="default";
    $versionInput="default";
    $packages="default";
    $svnuser="default";
    $commonprefix="default";
    $forceHCAL='';
    $rpmcmd='';
    $prepre="";

    GetOptions("prefix=s" => \$prefix,
	       "common=s" => \$commonprefix,
	       "mode=s" => \$mode,
	       "source" => \$source,
	       "clean" => \$clean,
               "help" => \$help,
	       "forceHCAL" => \$forceHCAL,
	       "offsite" => \$offsite,
	       "svnuser=s" => \$svnuser,
	       "ownsource=s" => \$ownsource,
	       "versionInput=s" => \$versionInput,
	       "hcalrepo=s" => \$hcalRepo,
	       "packages=s" => \$packages,
	       "rpm=s" => \$rpmcmd);

    if ($help || $mode eq "unknown") {
	help();
	exit(0);
    }

    if ($ownsource eq "default") {
	$ownsource="0";
    }

    if ($prefix eq "default") {
	$aaa=$versions{"Release"};
	$aaa=~s/_/./g;
	if ($mode eq "usc") {
	    $prefix="/nfshome0/hcaldev/releases/";
	    $commonprefix="/opt/xdaq";
	    $prefix.="daq.$aaa";
	} else {
	    $prefix="/home/daqowner/daq.$aaa";
	    if ($commonprefix eq "default") {
		$commonprefix="/home/daqowner/common";
	    } 
	}
    } elsif ($commonprefix eq "default") { $commonprefix=$prefix; }
    
    if ($mode eq "usc") {
	$hcalRepo="file:///nfshome0/hcalsw/dist";

	@hcalsites=($hcalRepo."/RPM/");
    } else {
	@hcalsites=($hcalRepo."/RPM/");
    }

    $prepre=$prefix;
    $prepre=~s|/[^/]*$||;


    $binloc="$prefix/bin";
    $libloc="$prefix/lib";
    $etcloc="$prefix/etc";
    $docloc="$prefix/doc";
    $halloc="$prefix/hal";
    $tmploc="$prefix/tmp";
    $srcloc="$prefix/src";
    $logloc="$commonprefix/monlog";
    $cacheloc="$commonprefix/cache";
    $rootloc="/opt/root/".$versions{"ROOT"};

    if ($ownsource) {
	return;
    }

# check for RPM versions
    open(RPMV,"rpm --version|");
    $al=<RPMV>;
    $al=~/version ([0-9]+).([0-9]+).([0-9]+)/;
    if ($1 <= 4 && $2 <= 3) {
	$rpmMode="special";
    } else {
	$rpmMode="builtin";
    }

    $rpmloc="$prefix/local/rpm";
    $rpmdb="$rpmloc/rpmdb";


    if ($rpmcmd) {
	runRPM($rpmcmd);
	exit(0);
    }


	
    print <<EOF;
Installing HCAL DAQ Release $versions{"Release"} (based on XDAQ $versions{"XDAQ"})
  Downloading (HCAL code) from $hcalRepo
  RPM mode is $rpmMode
  Binaries in $binloc
  Libaries in $libloc
  Source files in $srcloc
  ROOT $versions{"ROOT"} in $rootloc
  Cache (for database, etc) in $cacheloc
  Setup files in $etcloc
  HAL files in $halloc
  Working space in $tmploc

EOF

   if ($clean) {
	print "\nWiping old installation (keeping only the etc files)\n";
	system("rm -rf $binloc") if (-e $binloc);
	system("rm -rf $libloc") if (-e $libloc);
	system("rm -rf $cacheloc") if (-e $cacheloc);
	system("rm -rf $halloc") if (-e $halloc);
	system("rm -rf $srcloc") if (-e $srcloc);
	system("rm -rf $tmploc") if (-e $tmploc);
	system("rm -rf $rpmloc") if (-e $rpmloc);
	print " ....  Done with cleanup!\n\n";
    }

    system("mkdir -p $commonprefix");
    system("mkdir -p $binloc");
    system("mkdir -p $libloc");
    system("mkdir -p $etcloc");
    system("mkdir -p $cacheloc");
    system("mkdir -p $halloc");
    system("mkdir -p $srcloc");
    system("mkdir -p $tmploc");
    system("mkdir -p $logloc");
    # allow writing to these locations
    system("chmod og+rwx $cacheloc $tmploc $logloc");
}


sub rpmSetup() {
    if ($rpmMode eq "special") {
	if (! (-e "/tmp/rpmSpecial")) {
	    system("ln -s $rpmloc /tmp/rpmSpecial");
	}

	return if (-e $rpmloc);

	print "  Downloading special RPM version...\n";
    
	# create the directory
	system("mkdir -p $rpmloc");
	# download the special RPM tarball
	$rpmTar="rpm-4.4.2.1-standalone.tgz";
	chdir($rpmloc);
	my $url="$hcalRepo/SL4/$rpmTar";
	runWGET($url,$rpmTar);
	# unpack
	system("tar xfz $rpmTar");
	# delete
	unlink($rpmTar);
    }
    # create rpm db
    if (-e $rpmdb) {
	print  "  Got an RPM database...\n";
    } else {
	print  "  Creating RPM database..,\n";
	system("mkdir -p $rpmdb");
	runRPM("--initdb");
    }
}

sub runRPM {
    my ($arg1, $arg2, $arg3, $arg4) = @_;
    $rpmExe="rpm";
    if ($rpmMode eq "special") {
	$oldld=$ENV{"LD_LIBRARY_PATH"};
	$ENV{"LD_LIBRARY_PATH"}="$rpmloc/lib";
	$rpmExe="$rpmloc/bin/rpm";
    }
    my @rv=();
    if ($arg1=~/-q/) {
	open(RPM,"$rpmExe --dbpath $rpmdb $arg1 $arg2 $arg3 $arg4 2>&1 |");
	my @bits=<RPM>;
	close(RPM);
	foreach (@bits) {
	    chomp();
	    push @rv, $_;
	}
    } else {
	open(RPM,"$rpmExe --dbpath $rpmdb $arg1 $arg2 $arg3 $arg4 2>&1 |");
	while (<RPM>) {
	    next if (/lsetfilecon/);
	    print;
	}
	close(RPM);
    }
#    print "$cmd\n";
    if ($rpmMode eq "special") {
	$ENV{"LD_LIBRARY_PATH"}=$oldld;
    }
    return \@rv;
}

sub runWGET {
    my ($argi,$argo) = @_;

    if ($argi=~/file:\/\//) {
	my $actual=$argi;
	$actual=~s|file://||;
	print " ln -s $actual $argo\n";
	system("ln -s $actual $argo");
	return 0;
    } else {
	open(WG,"wget  --no-check-certificate -nv -O $argo $argi 2>&1 |");
	my @lines=<WG>;
	close(WG);
	
	if ($lines[0]=~/ERROR 404/ || $lines[1]=~/ERROR 404/ || $lines[2]=~/ERROR 404/) {
	    return 404;
	}
	print @lines;
	return 0;
    }
}

sub installHCAL {

    # get the contents file
    my $contents_base="hcal-".$versions{"HCALdaq"}.".txt";
    my $contents_url=$hcalRepo."/release/".$contents_base;

    my @categories=("base",$mode);
    if ($source) {
	push @categories,"devel";
    }
    
    my $loops=4;
    my $opts="";
    if ($forceHCAL) {
	$opts="force";
    }
    for ($i=0; $i<$loops; $i++) {
	my $contentsRef=getNeededContents($contents_url,\@categories,$opts);
	my $packagesList=downloadPackages($contentsRef,\@hcalsites,$opts);
	installPackages($packagesList);
	$opts="nodownload";
    }
}

sub installSetups {
    # get the contents file
    my $contents_base="hcal-".$versions{"HCALdaq"}.".txt";
    my $contents_url=$hcalRepo."/release/".$contents_base;

    my @categories=("setup","setup-".$mode);
    
    my $contentsRef=getNeededContents($contents_url,\@categories,"nodownload");
    my @sites=($hcalRepo."/RPM/");
    my $packagesList=downloadPackages($contentsRef,\@sites);
    installPackages($packagesList,"--nopost --nopre");
}

sub getNeededContents {
    my ($contentsUrl,$categoriesRef,$opts) = @_;
    my @contentsList=();

    if ($opts=~/private/) {
	$contentsTemp="/tmp/contents_".$ENV{"USER"};
	unlink($contentsTemp);
    } else {
	$contentsTemp=$contentsUrl;
	$contentsTemp=~s/.*[\/]//;
	$contentsTemp=$tmploc."/".$contentsTemp;
    }
    if (!($opts=~/nodownload/)) {
	if (runWGET($contentsUrl,$contentsTemp)) {
	    exit(1);
	}
    }

    # get the list of items
    open(CONTENTS,"$contentsTemp");
    $category="";
    $active=0;
    my %possiblePack=();
    my $packlist="";
    while (<CONTENTS>) {
	chomp;
	s/\#.*//;
	if (/\[([a-zA-Z0-9-_]+)\]/) {
	    $category=$1;
	    $active=grep { /$category/ } @{$categoriesRef};
	} elsif (length($_)>4 && $active>0) {
	    my ($pack,$ver)=split;
	    if ($pack=~/devel/ && $ver=~/\((.*)\)/) {
		$possiblePack{$pack}=$possiblePack{$1};
	    } elsif ($ver=~/EXACT/) {
		# remove the .EXACT
		$ver=~s/[.]EXACT//;
		$possiblePack{$pack}=$ver;
	    } else {
		# add the architecture
		$possiblePack{$pack}=$ver.".".$xdaqarch;
	    }
	    $packlist.=" $pack";
	}
    }
    close(CONTENTS);

  

    if ($opts=~/tags/) {
	foreach $pack (keys %possiblePack) {
	    my $ver=$possiblePack{$pack};
	    $expected="$pack $ver";
	    push(@contentsList,$expected);
	}
    } else {
	# check for possibility of already being installed
	$instL=runRPM("-q $packlist");
	foreach $pack (keys %possiblePack) {
	    my $ver=$possiblePack{$pack};
	    $expected="$pack-$ver";
	    $present=grep { /$expected/ } @{$instL};
	    if ($pack=~/hcal-base/ && $ver=~/nosbs/) {
		$actualVer=$ver;
		$actualVer=~s/[.]nosbs//;
		$expected="$pack-$actualVer";
		$present=grep { /$expected/ } @{$instL};
	    }
	    
	    if ($opts=~/force/ || $present<1) {
		my $rpm=sprintf("%s-%s.rpm",$pack,$ver);
		push(@contentsList,$rpm);
	    }
	}
    }

    return \@contentsList;
}

sub downloadPackages {
    my ($contentsL,$sitesL,$opts)=@_;
    my @packages=();
    
    foreach $rpm (@{$contentsL}) {
	my $rpmDest=$tmploc."/".$rpm;
	foreach $site (@{$sitesL}) {
	    my $rpmSrc=$site.$rpm;
	    if ($opts=~/force/) {
		unlink($rpmDest); # if forcing, remove old files!
	    }
	    if (! -e $rpmDest) {
		$rv=runWGET($rpmSrc,$rpmDest);
		if ($rv==404) {
		    unlink($rpmDest); #empty file
		} else {
		    last;
		}
	    }
	}
	if (-e $rpmDest) {
	    push @packages,$rpmDest;
	} else {
	    print " ERROR: Unable to download '$rpm'\n";
	}
    }
    return \@packages;
}

sub installPackages {
    my ($packL,$extraArgs)=@_;

    return if ($#{$packL}<0);
    
    my $packlist="";
    # install packages
    foreach $pack (@{$packL}) {
	$packlist=$packlist." $pack";
    }

    runRPM("--relocate /opt/xdaq=$prefix --excludepath /var/opt/xdaq --excludepath /usr --excludepath /etc --nodeps $extraArgs -UvH $packlist");
}

sub makeEnvironment {
    $javahome="/usr/java/default";
    
    my $toolmode=$mode;
    $toolmode="central" if ($mode=~/usc/);

    my $cfgcvspoint="/home/daqowner/cfg";
    if ($mode=="usc") {
	$cfgcvspoint="/nfshome0/hcalcfg";
    } 
    if ($mode=="teststand" && $ENV{"HOST"}=~/cern.ch/) {
	$cfgcvspoint="/opt/cfgcvs";
    }


    system("wget ${hcalRepo}/hcostag -O ${binloc}/hcostag");
    system("chmod +x ${binloc}/hcostag");

    # create environment files
    open(ENV,">$etcloc/env.sh");
    print ENV <<EOF; 
export ROOTSYS=$rootloc
export JAVA_HOME=$javahome
export HCALTOOLMODE=$toolmode
export HCALDAQ_SW_LOC=$prefix
export XDAQ_ROOT=$xdaqroot
export HCAL_XDAQ_ROOT=$prefix
export XDAQ_SETUP_ROOT=$prefix/share
export ORACLE_HOME=$xdaqroot
export CACTUS_HOME=/opt/cactus
export XDAQ_ZONE=hcalxt
export LD_LIBRARY_PATH=$prefix/lib:$xdaqroot/lib:\${ROOTSYS}/lib:\${CACTUS_HOME}/lib:/usr/local/lib
export HCAL_DAQ_RELEASE=$versions{"Release"}
export PATH=\${ROOTSYS}/bin:\${JAVA_HOME}/bin:$prefix/bin:$commonprefix/bin:$xdaqroot/bin:\${CACTUS_HOME}/bin/amc13:$cfgcvspoint/bin:\${PATH}
EOF
    close(ENV);
    open(ENV,">$etcloc/env.csh");
    print ENV <<EOF; 
setenv ROOTSYS $rootloc
setenv HCALTOOLMODE $toolmode
setenv JAVA_HOME $javahome
setenv HCALDAQ_SW_LOC $prefix
setenv XDAQ_ROOT $xdaqroot
setenv HCAL_XDAQ_ROOT $prefix
setenv XDAQ_SETUP_ROOT $prefix/share
setenv CACTUS_HOME /opt/cactus
setenv LD_LIBRARY_PATH $prefix/lib:$xdaqroot/lib:\${ROOTSYS}/lib:/usr/local/lib:\${CACTUS_HOME}/lib
setenv ORACLE_HOME $xdaqroot
setenv XDAQ_ZONE hcalxt
setenv HCAL_DAQ_RELEASE $versions{"Release"}
set path=(\${ROOTSYS}/bin \${JAVA_HOME}/bin $prefix/bin $xdaqroot/bin \${CACTUS_HOME}/bin/amc13 $commonprefix/bin $cfgcvspoint/bin \$path )
EOF
close(ENV);
open(STARTXD,">$binloc/startxdaq.sh");
    print STARTXD <<EOF;
#!/bin/sh
export ROOTSYS=$rootsys
export XDAQ_ROOT=$xdaqroot
export CACTUS_HOME=/opt/cactus
export LD_LIBRARY_PATH=\${LD_LIBRARY_PATH}:$prefix/lib:$xdaqroot/lib:\${ROOTSYS}/lib:\${CACTUS_HOME}/lib:/usr/local/lib
export ORACLE_HOME=$xdaqroot
export HCAL_DAQ_RELEASE=$versions{"Release"}
export TNS_ADMIN=$prefix/etc
export HCAL_XDAQ_ROOT=$prefix
if [ "\${HOME}" ]
then
echo HOME is set
else
export HOME=/nfshome0/hcalpro
fi

echo LD_LIBRARY_PATH is \$LD_LIBRARY_PATH
exec \${XDAQ_ROOT}/bin/xdaq.exe \$*
EOF
close(STARTXD);
    system("chmod +x $binloc/startxdaq.sh");

    #needed for old database scripts
    if ($mode=~/usc/) {
	open(RC,">$etcloc/HTBDAQ_configdb.rc");
	print RC "export HTBDAQ_CONFIGDB_DEFAULTS=\"--URL=jdbc:mysql://cmssrv0/HcalCfgDb --DBCLASS=hep.cms.hcal.db.config.sql.ConfigDB --USER=hcalwriter --PASSWORD=hadscr1be\"\n";
	close(RC);
    }

    if ($mode=~/teststand/) {
	system("mkdir -p $commonprefix/bin");
	open(PR,">$commonprefix/bin/pickRelease.sh");
	print PR <<EOF;
#!/bin/bash
echo Available installed releases

for rel in $prepre/daq.*
  do
  :  \$(( j = \$j + 1 ))
  relb=\${rel##/*daq.}
  echo "  " \$j ")  " \$relb
  bases[\$j]=\$rel
done

echo -n "Pick release to use:   "
read pick
    
echo

newbase=\${bases[\$pick]}    
rm -f $prepre/dist
ln -s \$newbase $prepre/dist
EOF
    
	system("chmod +x $commonprefix/bin/pickRelease.sh");
    }
}

sub doOwnSource {
    system("mkdir -p $ownsource");
    chdir("$ownsource");

    #ownsource = ${HOME}/src/TEST2
#want this:    
#svn checkout svn+ssh://darcaro@svn.cern.ch/reps/cmshcos/tags/hcal/hcal_13_5_0/
#versionInput = 

    my $SVNLOC="";
    if ($svnuser=~/default/) {
        $SVNLOC="svn+ssh://svn.cern.ch/reps/cmshcos";
    } else {
	$SVNLOC="svn+ssh://${svnuser}\@svn.cern.ch/reps/cmshcos";
    }

    if ($packages=~/all/) {
	#print "${versionInput}";
	#print "svn co ${SVNLOC}/tags/hcal/hcal_${versionInput} ${ownsource}/hcal";
	system("svn co ${SVNLOC}/tags/hcal/hcal_${versionInput} ${ownsource}/hcal");
    } elsif ($packages=~/default/) {
	help();
	print "ERROR: You must provide a list of packages as a comma-separated list!\n";
	return;
    } else {
	$packages=~s/[,:]/ /g;
	print "SVN checkout may take some time! \n";
	system("svn co --depth=files ${SVNLOC}/trunk ${ownsource}/hcal");
	chdir("${ownsource}/hcal");
	system("svn update --set-depth=infinity config $packages");
    }

    open(CFG,">$ownsource/hcal/config.hcal");
    print CFG <<EOF;
XDAQ_ROOT:=$xdaqroot
HCAL_XDAQ_ROOT:=$prefix
BUILD_HOME:=$ownsource
USE_BUSADAPTER := CAEN
EOF
close(CFG);
}

sub help() {

    print <<EOF;

Help for InstallDAQ:
-------------------

InstallDAQ will install the HCAL DAQ Software in a user-specified area
on a computer.  The installation is done relative to a prefix
directory, off of which there will be bin, include, lib, tmp, etc, src,
and hal directories.  The default prefix is "/home/daqowner/daq.(release)"
unless "--mode=usc" is given as a option, in which case the installation 
will be done in "/nfshom0/hcaldev/releases/[version]".

Other options which may be of interest:

  --help   : this help message
  --svnuser=[username] : sets the username for ownsource checkouts (CERN AFS)
  --ownsource=location 
           : creates a working area for development using links to the 
             installed TriDAS source.  This option installs source and makes 
             links, but skips all other installation steps.  It must be done 
             from a node which is able to access the Internet. You should also 
             include the "--packages=" option as well (see below)
  --packages=[comma-separated list]
           : list of hcal subpackages to install (or 'all') for all.  

List of valid subpackages: 
EOF
	foreach $pack (@allpackages) {
	    print " $pack";
	}
	print "hcalDemo \n";
print <<EOF;
------------------

EOF
}