#!/bin/sh
# the next line restarts using wish \
exec tclsh $0 $@

# THIS procedure creates or deleted a base directory and its subdirectories

proc DoDir { BASE SUBS { Action CREATE } } {
   global env SySCmDs

   set HOME $BASE
   set sLen [llength $SUBS]

   if [string match CREATE $Action] {
      puts -nonewline stderr "TESTING FOR $HOME ...."
      if [file isdirectory $HOME] {
         puts stderr "EXISTS"

         for { set I 0 } { $I < $sLen } { incr I } {
            set tDir [file join $HOME [lindex $SUBS $I] ]
            puts -nonewline stderr "TESTING FOR SUBDIRECTORY $tDir ...."
            if ![file isdirectory $tDir] {
               puts stderr "CREATING"
               file mkdir $tDir
            } else { puts stderr "EXISTS" }
         }
      } else {
         puts stderr "CREATING"
         file mkdir $HOME
         for { set I 0 } { $I < $sLen } { incr I } {
            set tDir [file join $HOME [lindex $SUBS $I] ]
            puts stderr  "CREATING SUBDIRECTORY $tDir"
            file mkdir $tDir
         }
      }
   } else {
      if [file isdirectory $HOME] {
         for { set I 0 } { $I < $sLen } { incr I } {
            set tDir [file join $HOME [lindex $SUBS $I] ]
            if [file isdirectory $tDir] {
               puts stderr "REMOVING SUBDIRECTORY $tDir"
               file delete -force $tDir
            } 
         }
         if [string match REMOVEALL $Action] {  
            puts stderr "REMOVING DIRECTORY $HOME"
            file delete -force $HOME
         }
      }
   }
}

# THIS procedure gets all of the initial directories setup and the packages
#   in their proper places

proc SetUp { } {
   global env SySCmDs tcl_platform

   set owd [pwd]

   DoDir $env(UDF_HOME)  [list Archives]
   DoDir $env(UDFTOOL_HOME)  [list bin lib INSTALLED PKGHOME ConFigs]
   DoDir $env(TCLTOOLS_HOME) [list INSTALLED PKGHOME]

   puts stderr "MOVING MININSTALL PACKAGES"

   set BasEHome [file join $env(UDFTOOL_HOME) PKGHOME]

   if [file exists MININSTALL.tar] {
      puts stderr "   MOVING MININSTALL.tar To $BasEHome"
      set PkG [file join $BasEHome MININSTALL.tar]
      file rename -force MININSTALL.tar $PkG
      cd $BasEHome
      exec $SySCmDs(tar) xmf MININSTALL.tar
      cd $owd
   } else { 
      puts stderr "MININSTALL.tar Package Missing"
      if [string match window* $tcl_platform(platform)] { after 5000 }
      exit
   }
   
   set MrC [file join $BasEHome MakeRc]
   set GrC [file join $BasEHome GUIrc]
   set UrC [file join $BasEHome UDFrc]
   set CpF [file join $BasEHome ClientPublic]
   if [file exists $MrC] {
      set HoMe [file join $env(UDFTOOL_HOME) ConFigs]
      puts stderr "   MOVING MakeRc To $HoMe"
      set MvTo [file join $HoMe MakeRc]
      file rename -force $MrC $MvTo
   } 
   if [file exists $UrC] {
      set HoMe [file join $env(UDFTOOL_HOME) ConFigs]
      puts stderr "   MOVING UDFrc To $HoMe"
      set MvTo [file join $HoMe UDFrc]
      file rename -force $UrC $MvTo
   } 
   if [file exists $GrC] {
      set HoMe [file join $env(UDFTOOL_HOME) ConFigs]
      puts stderr "   MOVING GUIrc To $HoMe"
      set MvTo [file join $HoMe GUIrc]
      file rename -force $GrC $MvTo
   } 

   if [file exists $CpF] {
      set HoMe [file join $env(UDF_HOME) Archives]
      puts stderr "   MOVING ClientPublic To $HoMe (ClientInfo)"
      set MvTo [file join $HoMe ClientInfo]
      file rename -force $CpF $MvTo
   }
}

# THIS procedure installs a software package.  There are a number of options
#   to give it some generality.  The inputs include
#
#  pBaSe  - The base directory of the package
#  pHoMe  - The directory the package creates
#  pNaMe  - The package name (less the version-revision-.tgz info)
#  ActioN - Array which describes what needs to be done.
#      (0)  1 if a make needs be done; 0 otherwise
#      (1)  name of program to link if an executable is built; "" otherwise
#      (2)  1 if a release is done; 0 otherwise
#      (3)  A list of any files to move to the bin directory under pBaSe 
#      (4)  1 if a pkgIndex needs to be done
#      (5)  1 if purge the home directory; 0 otherwise
#      (6)  1 no overwrite of existing package (also no InstalledPKGS update)
#
#  NOTE that the actual package presented to the routine is a combination
#    of the package database entry and the package itself

proc InstallPackage { dInFo pHoMe pName ActioN } {
   global env SySCmDs 

   upvar $ActioN aC
   
   set owd [pwd]

   if ![info exists aC(0)] { set aC(0) 0  }
   if ![info exists aC(1)] { set aC(1) "" }
   if ![info exists aC(2)] { set aC(2) 0  }
   if ![info exists aC(3)] { set aC(3) "" }
   if ![info exists aC(4)] { set aC(4) 0  }
   if ![info exists aC(5)] { set aC(5) 1  }
   if ![info exists aC(6)] { set aC(6) 0  }

# GET the both the package home and the package base.  The home is 
#    the directory from which the install starts and the base is the
#    home directory of the package (which includes the package base)

   set dLen [llength [split $dInFo "|"]]
   if { $dLen == 1 } {
      set pBaSe $dInFo
      set INSHOME [file join $dInFo INSTALLED]
   } else { 
      set pBaSe [lindex [split $dInFo "|"] 0] 
      set INSHOME [file join $pBaSe INSTALLED]
      for { set I 1 } { $I < $dLen } { incr I } {
         set pBaSe [file join $pBaSe [lindex [split $dInFo "|"] $I]] 
      }
   }

# GET the package name.  This is not fixed since it includes the package
#    version/revision info in it.  It is always found in the directory   
#    UDFTOOL_HOME/PKGHOME.  We need package name sans tar.

   set fList [exec $SySCmDs(ls) [file join $env(UDFTOOL_HOME) PKGHOME]]
   set fLen [llength $fList]
   set PkGName ""
   for { set I 0 } { $I < $fLen } { incr I } {
      if [string match ${pName}* [lindex $fList $I]] {
         set PkGName  [file rootname [lindex $fList $I]]
         set PkGRName [lindex [split $PkGName "."] 0]
         break
      }
   }

   if { [string length $PkGName] == 0 } {
      puts stderr "WARNING .... $PkGName  PACKAGE NOT FOUND!"
      return -1
   }

# IF we shouldn't overwrite a registered installed version of this package
#   see if one exists

   set iName [file join $INSHOME InstalledPKGS]
   puts stderr "INSTALLING THE $pName SOFTWARE PACKAGE"
   
# DELETE the directories the package will create and then recreate it.  
#    This purges the old version if any was present.

   if $aC(5) { DoDir $pBaSe [list $pHoMe] REMOVESUBS }
   DoDir $pBaSe [list $pHoMe] CREATE

#  NOW install the package.  This consists of unzipping it, untarring
#    it and then doing any needed makes or moves.

   set PKGHOME [file join $pBaSe $pHoMe]
   set PkG [file join $env(UDFTOOL_HOME) PKGHOME $PkGName]

   file rename $PkG.tar [file join $PKGHOME $PkGName.tar] 

   cd $PKGHOME
   exec $SySCmDs(tar) xmf $PkGName.tar
   if [file exists $PkGName.dbe] { 
      if !$aC(6) {
         file rename $PkGName.dbe [file join $INSHOME $PkGName.dbe] 
      } else { file delete -force $PkGName.dbe } 
   }
   exec $SySCmDs(gzip) -df $PkGName.tgz
   exec $SySCmDs(tar) xmf $PkGName.tar
   if [file exists $PkGName.tar] { file delete -force $PkGName.tar }
   if [file exists $PkGName.tgz] { file delete -force $PkGName.tgz }

   cd $owd
   set mLen [llength $aC(3)]
   if { $mLen > 0 } {
      puts -nonewline stderr " ... MOVING"
      for { set I 0 } { $I < $mLen } { incr I } {
         set mVF [lindex $aC(3) $I]
         if { [llength [split $mVF ":"]] == 1 } {
             set bHoMe [file join $pBaSe bin]
             set Mv $mVF
         } else {
             set bHoMe [file join $env([lindex [split $mVF ":"] 0]) bin]
             set Mv [lindex [split $mVF ":"] 1]
         }
         if ![file isdirectory $bHoMe] { file mkdir $bHoMe }
         file rename -force [file join $PKGHOME $Mv] [file join $bHoMe $Mv]
      }
   }

   if $aC(4) { pkg_mkIndex $PKGHOME }

   puts stderr " ... DONE"

   UpdatePkgDb $INSHOME $PkGName
   return 1
}

proc UpdatePkgDb { HoMe PkGName  } {
   global SySCmDs

   set iName [file join $HoMe InstalledPKGS]
   if [file exists $iName] { set openAs r } else { set openAs w }
   if [catch {open $iName $openAs } fo]  {
     puts stderr "UNABLE to open or create InstalledPKGS file"
     return 0
   }

# READ in the database entry and then delete the database file

   set dbE [file join $HoMe $PkGName.dbe] 
   if [file exists $dbE] {
      if [catch {open $dbE r } fdbE]  {
         puts stderr "UNABLE to open database entry file $dbE"
         return 0
      }

      set dbN ""
      while { [gets $fdbE LiNe] >= 0 } {
         scan $LiNe "%s %s" fN fD
         set fN [string trim $fN]
         set fD [string trim $fD]
         set dbF($fN) $fD
         lappend dbN $fN
      }
      close $fdbE
      if [file exists $dbE] { file delete -force $dbE }
   } else {
      set fD [split $PkGName "."]
      set dbF(PKG) [lindex $fD 0]
      set dbF(REV) [lindex $fD 1].[lindex $fD 2]
      set dbN [list PKG REV]
   }
                                                                                
   set TiMe [clock format [clock seconds] -format %Y%m%d]

   if [string match r $openAs] {
      set tName [file join $HoMe ._TmP]
      if [catch {open $tName w} fi]  {
         puts stderr "UNABLE to create Temporary file $tName"
         return 0
      }
        
      set Entered 0
      while { [gets $fo LiNe] > 0 } {
         scan $LiNe "%s %s" fN fD
         set fN [string trim $fN]
         set fD [string trim $fD]
         if [string match PKG $fN] {
            set IgN 0
            if { [string compare $fD $dbF(PKG)] == 0 } {
               set IgN 1
               set Entered 1
               set nE [llength $dbN]
               for { set I 0 } { $I < $nE } { incr I } {
                  puts $fi "[lindex $dbN $I]   $dbF([lindex $dbN $I])"
               }
               puts $fi "TIME   $TiMe"
            } else { puts $fi "$fN   $fD" }
         } else { 
            if { !$IgN } { puts $fi "$fN   $fD" }
         }
      }

      if !$Entered { 
         set nE [llength $dbN]
         for { set I 0 } { $I < $nE } { incr I } {
            puts $fi "[lindex $dbN $I]   $dbF([lindex $dbN $I])"
         }
         puts $fi "TIME   $TiMe"
      }
      close $fi
      close $fo
      file rename -force $tName $iName
   } else {
      set nE [llength $dbN]
      for { set I 0 } { $I < $nE } { incr I } {
         puts $fo "[lindex $dbN $I]   $dbF([lindex $dbN $I])"
      }
      puts $fo "TIME   $TiMe"
      close $fo
   }
   return 1
}

proc EnvCheck { } {
   global env SySCmDs
   
   set OK 1
   if ![info exists env(UDF_HOME)] {
      puts stderr "Environment variable UDF_HOME not set!"
      set OK 0
   }
   if ![info exists env(UDFTOOL_HOME)] {
      puts stderr "Environment variable UDFTOOL_HOME not set!"
      set OK 0
   }
   if ![info exists env(TCLTOOLS_HOME)] {
      puts stderr "Environment variable TCLTOOLS_HOME not set!"
      set OK 0
   }
}

# ........................................................................
#       
#                             INSTALL STARTS HERE
#
# ........................................................................


set owd [pwd]

if [info exists env(UNIXCMDS_HOME)] {
   set SySCmDs(ls)   [file join $env(UNIXCMDS_HOME) ls.exe]
   set SySCmDs(gzip) [file join $env(UNIXCMDS_HOME) gzip.exe]
   set SySCmDs(tar)  [file join $env(UNIXCMDS_HOME) tar.exe]
}
if ![info exists SySCmDs(ls)]   { set SySCmDs(ls) ls     }
if ![info exists SySCmDs(gzip)] { set SySCmDs(gzip) gzip }
if ![info exists SySCmDs(tar)]  { set SySCmDs(tar) tar   }

EnvCheck
SetUp

set HOME [file join $env(TCLTOOLS_HOME)]

set AcTioN(5) 0
InstallPackage $HOME "" TCLCNTRL AcTioN
set AcTioN(4) 1
set AcTioN(5) 1
set AcTioN(3) [list SetGUIrc]
InstallPackage $HOME TclGUI TCLGUI AcTioN

set AcTioN(3) [list udfLibrarian]
InstallPackage $env(UDFTOOL_HOME) UDFLibrarian UDFLIBRARIAN AcTioN
set AcTioN(3) [list NoProWin ProWin PromoteUDF]
InstallPackage $env(UDFTOOL_HOME) Client CLIENT AcTioN

cd $owd 
if [file exists MinInstall] { file delete -force MinInstall }