#!/usr/bin/env perl

# $Id$
# install-tl.pl
#
# Copyright 2007 2008 Reinhard Kotucha, Norbert Preining
# This file is licensed under the GNU General Public License version 2
# or any later version.
#
# TODO: 
#  - support option_fmt (generation of formats)
#    partially done, missing fmtutil-sys for windows
#  - support option_paper (paper instead of A4)
#    missing

my $svnrev = '$Revision$';
$svnrev =~ m/: ([0-9]+) /;
$::installerrevision = $1;

# is now taken from 00texlive.config: release, $tlpdb->config_release;
our $texlive_release;

BEGIN {
  $^W = 1;
  my $me=$0;
  $me=~s!\\!/!g if $^O=~/^MSWin(32|64)$/i;

  if ($me=~m!/!) {
    ($::installerdir=$me)=~s!(.*)/.*$!$1!;
  } else {
    $::installerdir='.';
  }
# The installer uses a minimal subset of Perl for Windows.  In order
# to avoid conflicts with other versions of Perl already installed on
# the system, we simply ignore them.  The installer has to execute
# $::installerdir/tlpkg/bin/perl.exe and should not rely on any other
# Perl executable.

  if ($^O=~/^MSWin(32|64)$/i) {
    #$ENV{'PERL5LIB'}=undef;
    @INC="$::installerdir/tlpkg/installer/perllib";
  }
  unshift (@INC, "$::installerdir/tlpkg");
}

use TeXLive::TLUtils qw(initialize_installer media platform platform_desc
   which getenv win32 unix program_exists architectures_available
   additional_architectures_available_from_net get_system_tmpdir member
   mkdirhier make_var_skeleton make_local_skeleton install_package copy
   install_packages dirname tllog);
use TeXLive::TLPOBJ;
use TeXLive::TLPDB;
use TeXLive::TLConfig qw($DefaultContainerExtension $InfraLocation);
use TeXLive::TLWinGoo;
use Getopt::Long;
use utf8;
no utf8;

# default language
$::lang = "en";
if ($^O =~ /^MSWin(32|64)$/i) {
  # trying to deduce automatically the country code
  my $foo =  TeXLive::TLWinGoo::reg_country();
  if ($foo) {
    $::lang = $foo;
  } else {
    tllog($::LOG_DEBUG, "Didn't get any usuful code from reg_country: $foo...\n");
  }
} else {
  # we load POSIX and locale stuff
  require POSIX;
  import POSIX qw/locale_h/;
  # now we try to deduce $::lang
  my $loc = setlocale(&POSIX::LC_CTYPE);
  my ($lang,$area,$codeset);
  if ($loc =~ m/^([^_.]*)(_([^.]*))?(\.([^@]*))?(@.*)?$/) {
    $lang = defined($1)?$1:"";
  }
  $::lang = $lang if ($lang);
}

use strict;

# debugging/logging cmd lines options:
# -q     shut up terminal output
# -qq    shut up also log file output
# -d     set $::LOGLEVELFILE to $::LOG_DEBUG
# -dd    set $::LOGLEVELFILE to $::LOG_DDEBUG
# -ddd   set $::LOGLEVELFILE to $::LOG_DDDEBUG
#
$::LOGLEVELFILE = $::LOG_NORMAL;
$::LOGLEVELTERMINAL = $::LOG_NORMAL;
@::LOGLINES = ();
#
# $install{$packagename} == 1 if it should be installed
my %install;
# if we should try to get additional binaries from the net
# needs our since for menu ...
our $trynet=0;
# the url of net location, can be changed with -url ....
#
# for now it is my testing archive on tug.org
#$::texlive_url = 'http://tug.org/svn/texlive/trunk/Master';
# for my own testing in the virtual machine
#$::texlive_url = 'http://localhost/norbert/tltesting';
$::texlive_url = 'http://10.0.2.2/norbert/tltesting';
#$::texlive_url = 'http://tug.org/~preining/tltesting';
# the default scheme to be installed
my $default_scheme='scheme-full';
# some arrays where the lists of collections to be installed are saved
# our for menus
our @collections_std;
our @collections_lang;
our @collections_lang_doc;
# The maximum number of binary systems on the CD.  This number must be
# smaller than the number of binaries available from the network.
our $max_bins_on_CD=7;
# for win dealing
#our $Registry;
# The global variable %vars is an associative list which contains all
# variables and their values which can be changed by the user.
# needs to be our since TeXLive::TLUtils uses it
our %vars=( # 'n_' means 'number of'.
        'this_platform' => platform(),
        'n_systems_available' => 0,
        'n_systems_selected' => 0,
        'n_collections_selected' => 0,
        'n_collections_available' => 0,
        'total_size' => 0,
        'option_symlinks' => 0,
        'sys_bin' => '/usr/local/bin',
        'sys_man' => '/usr/local/man',
        'sys_info' => '/usr/local/info',
        'option_doc' => 1,
        'option_src' => 1,
        'option_fmt' => 0,
        'option_letter' => 0,
        'selected_scheme' => $default_scheme,
    );

# option handling
my $opt_media = "";
my $opt_url = "";
my $opt_profile = "";
my $opt_no_cls=0;
my $opt_gui = 0;
my $opt_debug = 0;
my $opt_ddebug = 0;
my $opt_dddebug = 0;
my $opt_quiet = 0;
my $opt_qquiet = 0;
$::netarchive = "archive";
$::diskarchive = "archive";

GetOptions("media=s" => \$opt_media,
           "profile=s"=> \$opt_profile,
           "no-cls",
           "gui", \$opt_gui,
           "netarchive=s" => \$::netarchive,
           "diskarchive=s" => \$::diskarchive,
           "lang=s" => \$::lang,
           "d" => \$opt_debug,
           "dd" => \$opt_ddebug,
           "ddd" => \$opt_dddebug,
           "q" => \$opt_quiet,
           "qq" => \$opt_qquiet,
           "url=s"   => \$opt_url    ) or die("No pod doc till now!");

if ($opt_quiet) {
  $::LOGLEVELTERMINAL = $::LOG_ZERO;
}
if ($opt_qquiet) {
  $::LOGLEVELTERMINAL = $::LOG_ZERO;
  $::LOGLEVELFILE = $::LOG_ZERO;
}
if ($opt_debug) {
  $::LOGLEVELFILE = $::LOG_DEBUG;
}
if ($opt_ddebug) {
  $::LOGLEVELFILE = $::LOG_DDEBUG;
}
if ($opt_dddebug) {
  $::LOGLEVELFILE = $::LOG_DDDEBUG;
}
if ("$opt_media" =~ m/^CD/i) {
  $::_media_ = "CD";
} elsif ("$opt_media" =~ m/^NET/i) {
  $::_media_ = "NET";
} elsif ("$opt_media" =~ m/^DVD/i) {
  $::_media_ = "DVD";
}

if ("$opt_profile" ne "") {
  if (-r "$opt_profile") {
    tllog($::LOG_NORMAL, "Using automated installation using $opt_profile!");
  } else {
    $opt_profile = "";
    tllog($::LOG_NORMAL, "Profile $opt_profile not readable, continuing in interactive mode!");
  }
}

if ("$opt_url" ne "") {
  $::texlive_url = "$opt_url";
}

# the TLPDB instances we will use. $tlpdb is for the one from the installation
# media, while $localtlpdb is for the new installation
# $tlpdb must be our because it is used in install-menu-text.pl
our $tlpdb;
my $localtlpdb;

# $finished == 1 if the menu call already did the installation
my $finished = 0;
@::start_install_hook = ();
@::end_install_hook = ();
@::start_postinst_hook = ();
@::start_install_hook = ();

my $system_tmpdir=get_system_tmpdir();

tllog($::LOG_NORMAL, "Platform: ", platform, " => \'", platform_desc(platform), "\'\n");
if (media() eq "DVD") {
  tllog($::LOG_NORMAL, "Distribution: live (uncompressed)\n");
} elsif (media() eq "CD") {
  tllog($::LOG_NORMAL, "Distribution: inst (compressed)\n");
} elsif (media() eq "NET") {
  tllog($::LOG_NORMAL, "Distribution: net  (downloading)\n");
} else {
  tllog($::LOG_NORMAL, "Distribution: ", media(), "\n");
}
tllog($::LOG_NORMAL, "Directory for Temporary Files: '", $system_tmpdir, "\'\n");
tllog($::LOG_NORMAL, "Installer Directory: '$::installerdir'\n");

initialize_installer();
load_tlpdb();
$texlive_release = $tlpdb->config_release;
set_platforms_supported();
set_texlive_default_dirs();
initialize_collections();
set_install_platform();
if ($opt_profile eq "") {
  # do the normal interactive installation!
  #
  # here we could load different menu systems. Currently several things
  # are "our" so that the menu implementation can use it. The $tlpdb, the
  # %var, and all the @collection*
  # install-menu-*.pl should implement a function run_menu() and should
  # change ONLY stuff in %vars
  # The allowed keys in %vars should be specified somewhere ...
  # the menu implementation should return
  #    MENU_INSTALL  do the installation
  #    MENU_ABORT    abort every action immediately, no cleanup
  #    MENU_QUIT     try to quit and clean up mess
  our $MENU_INSTALL = 0;
  our $MENU_ABORT   = 1;
  our $MENU_QUIT    = 2;
  our $MENU_ALREADYDONE = 3;
  if ($opt_gui) {
    # try to load Tk.pm, but don't die if it doesn't work
    eval { require Tk; };
    if ($@) {
      # that didn't work out, so warn the user and continue with text mode
      tllog($::LOG_NORMAL, "Cannot load Tk, maybe something is missing!\n");
      tllog($::LOG_NORMAL, "Error message from loading Tk:\n");
      tllog($::LOG_NORMAL, "$@\n");
      tllog($::LOG_NORMAL, "Continuing in Text Mode...\n");
      $opt_gui = 0;
    }
  }
  if ($opt_gui) {
    require("installer/install-menu-perltk.pl");
  } else {
    require("installer/install-menu-text.pl");
  }
  my $ret = run_menu();
  if ($ret == $MENU_QUIT) {
    # do_cleanup();  MISSING
    flushlog();
    exit(1);
  }
  if ($ret == $MENU_ABORT) {
    # NO do_cleanup()!
    flushlog();
    exit(2);
  }
  if ($ret == $MENU_ALREADYDONE) {
    tllog($::LOG_DEBUG, "run_menu has already done the work ... cleaning up!\n");
    $finished = 1;
  }
  if (!$finished && ($ret != $MENU_INSTALL)) {
    tllog($::LOG_NORMAL, "Unknown return value of run_menu: $ret\n");
    exit(3);
  }
} else {
  read_profile("$opt_profile");
}

if (!$finished) {
  # do the actual installation
  do_installation();
}

# now open the log file and write out the log lines
# try to open a log file
if ($::LOGLEVELFILE > $::LOG_ZERO) {
  if (open(LOGF,">$vars{'TEXDIR'}/install-tl.log")) {
    $::LOGFILE = \*LOGF;
    foreach my $line(@::LOGLINES) {
      print $::LOGFILE "$line";
    }
  } else {
    warn("Cannot create log file $vars{'TEXDIR'}/install-tl.log: $!\nNot writing out log lines!\n");
    $::LOGLEVELFILE = $::LOG_ZERO;
  }
}

# dump various things to the log file
if (defined($::LOGFILE)) {
  print $::LOGFILE "\nDump of vars:\n";
  foreach my $key (keys %vars) {
    print $::LOGFILE "$key $vars{$key}\n";
  }
  create_profile($::LOGFILE);
}

dump_vars("$system_tmpdir/texlive.vars");

# write the profile out
create_profile("$vars{'TEXDIR'}/$InfraLocation/texlive.profile");
tllog($::LOG_DEBUG, "Profile written to $vars{'TEXDIR'}/$InfraLocation/texlive.profile\n");

# Close log file if present
close($::LOGFILE) if defined($::LOGFILE);


exit(0);

###################################################################
#
# FROM HERE ON ONLY SUBROUTINES
# NO VARIABLE DECLARATIONS
#
###################################################################

sub do_installation {
  # do the actual installation
  foreach my $h (@::start_install_hook) {
    &$h();
  }
  calc_depends();
  prepare_installation();
  do_install_packages();
  if (win32()) {
    do_win_registry_magic();
  }
  foreach my $h (@::start_postinst_hook) {
    &$h();
  }
  do_postinst_stuff();
  foreach my $h (@::end_install_hook) {
    &$h();
  }
}

sub dump_vars {
  my $filename=shift;
  my $fh;
  if (ref($filename)) {
    $fh = $filename;
  } else {
    open VARS, ">$filename";
    $fh = \*VARS;
  }
  foreach my $key (keys %vars) {
    print $fh "$key $vars{$key}\n";
  }
  close VARS if (!ref($filename));
  tllog($::LOG_DEBUG, "\n%vars dumped to '$filename'.\n");
}


# Determine which platforms are supported.
sub set_platforms_supported {
  my @binaries=architectures_available;
  for my $binary (@binaries) {
    unless (defined $vars{"diskbin_$binary"}) {
      $vars{"diskbin_$binary"}=0;
    }
  }
  if ($trynet==1) {
    my @binaries=additional_architectures_available_from_net \%vars;
    for my $binary (@binaries) {
      $vars{"netbin_$binary"}=0;
    }
  }
  for my $key (keys %vars) {
    ++$vars{'n_systems_available'} if ($key=~/^(disk|net)bin/);
  }
}

# Environment variables and default values on UNIX:
#   TEXLIVE_INSTALL_PREFIX         /usr/local/texlive   => $tex_prefix
#   TEXLIVE_INSTALL_TEXDIR         $tex_prefix/2007     => $TEXDIR
#   TEXLIVE_INSTALL_TEXMFSYSVAR    $TEXDIR/texmf-var
#   TEXLIVE_INSTALL_TEXMFLOCAL     $tex_prefix/texmf-local
#   TEXLIVE_INSTALL_TEXMFHOME      '$HOME/texmf'

sub set_texlive_default_dirs {
  my $tex_prefix;
  my $texmfsysvar;
  my $texmflocal;
  my $texmfhome;

  $tex_prefix=getenv('TEXLIVE_INSTALL_PREFIX');
  if (win32) {
    #require("TeXLive/win-admin.pl");
    $vars{'win-admin'} = admin();
    my $prog = getenv('ProgramFiles');
    $tex_prefix ||= $prog . '/texlive' if TeXLive::TLWinGoo::dir_writable($prog);
    $tex_prefix||=getenv('USERPROFILE') . '/texlive';
  } else {
    $tex_prefix||='/usr/local/texlive';
  }
  $vars{'TEXDIR'}="$tex_prefix/$texlive_release";

  $texmfsysvar=getenv('TEXLIVE_INSTALL_TEXMFSYSVAR');
  $texmfsysvar||=$vars{'TEXDIR'} . '/texmf-var';
  $vars{'TEXMFSYSVAR'}="$texmfsysvar";

  $texmflocal=getenv('TEXLIVE_INSTALL_TEXMFLOCAL');
  $texmflocal||="$tex_prefix/texmf-local";
  $vars{'TEXMFLOCAL'}="$texmflocal";

  $texmfhome=getenv('TEXLIVE_INSTALL_TEXMFHOME');
  $texmfhome ||= "~";
  $vars{'TEXMFHOME'}="$texmfhome/texmf";
}

sub calc_depends {
  # we have to reset the install hash EVERY TIME otherwise everything will
  # always be installed since the default is scheme-full which selects
  # all packages and never deselects it
  %install=();

  # initialize the %install hash with what should be installed

  # First look for packages in the selected scheme.
  my $scheme=$tlpdb->get_package($vars{'selected_scheme'});
  if (!defined($scheme)) {
    dump_vars(\*STDOUT);
    die ("Scheme $vars{'selected_scheme'} not defined!\n");
  }

  for my $scheme_content ($scheme->depends) {
    $install{"$scheme_content"}=1 unless ($scheme_content=~/^collection-/);
  }

  # Now look for collections in the %vars hash.  These are not
  # necessarily the collections required by a scheme.  The final
  # decision is made in the collections/languages menu.
  foreach my $key (keys %vars) {
    if ($key=~/^collection-/) {
      $install{$key} = 1 if $vars{$key};
    }
  }

  # compute the list of archs to be installed
  my @archs;
  foreach (keys %vars) {
    if (m/^diskbin_(.*)$/ ) {
      if ($vars{$_}) { push @archs, $1; }
    }
    if (m/^netbin_(.*)$/ ) {
      if ($vars{$_}) { push @archs, $1; }
    }
  }

  # if programs for arch=win32 are installed we also have to install
  # bin-tlperl.win32 which provides the "hidden" perl that will be used
  # to run all the perl scripts.
  if (grep(/^win32$/,@archs)) {
    $install{"bin-tlperl.win32"} = 1;
  }

  # loop over all the packages until it is getting stable
  my $changed = 1;
  while ($changed) {
    # set $changed to 0
    $changed = 0;

    # collect the already selected packages
    my @pre_selected = keys %install;
    tllog($::LOG_DDEBUG, "initial number of installations: $#pre_selected\n");

    # loop over all the pre_selected and add them
    foreach my $p (@pre_selected) {
      tllog($::LOG_DDEBUG, "pre_selected $p\n");
      foreach my $p_dep ($tlpdb->get_package($p)->depends) {
        if ($p_dep =~ m/^(.*)\.ARCH$/) {
          my $foo = "$1";
          foreach my $a (@archs) {
            $install{"$foo.$a"} = 1;
          }
        } elsif ($p_dep =~ m/^(.*)\.win32$/) {
          # a win32 package should *only* be installed if we are installing
          # the win32 arch
          if (grep(/^win32$/,@archs)) {
            $install{$p_dep} = 1;
          }
        } else {
          $install{$p_dep} = 1;
        }
      }
    }

    # check for newly selected packages
    my @post_selected = keys %install;
    tllog($::LOG_DDEBUG, "number of post installations: $#post_selected\n");

    # set repeat condition
    if ($#pre_selected != $#post_selected) {
      $changed = 1;
    }
  }

  # now do the size computation
  my $size = 0;
  foreach my $p (keys %install) {
    my $tlpobj = $tlpdb->get_package($p);
    if (not(defined($tlpobj))) {
      die "Cannot find $p in texlive.tlpdb, strange!\n";
    }
    $size+=$tlpobj->docsize if $vars{'option_doc'};
    $size+=$tlpobj->srcsize if $vars{'option_src'};
    $size+=$tlpobj->runsize;
    foreach my $a (@archs) {
      $size += $tlpobj->binsize->{$a} if defined($tlpobj->binsize->{$a});
    }
  }
  $vars{'total_size'} =
    sprintf "%d", ($size * $TeXLive::TLConfig::BlockSize)/1024**2;
}

sub load_tlpdb {
  my $master;
  if (media eq 'NET') {
    $master="$::texlive_url";
  } else {
    $master="$::installerdir";
  }
  tllog($::LOG_NORMAL, "Loading $master/$TeXLive::TLConfig::InfraLocation/$TeXLive::TLConfig::DatabaseName ...\n");
  $tlpdb=TeXLive::TLPDB->new(root => "$master");
}

sub initialize_collections {
  foreach my $pkg ($tlpdb->list_packages) {
    my $tlpobj = $tlpdb->{'tlps'}{$pkg};
    if ($tlpobj->category eq "Collection") {
      $vars{"$pkg"}=0;
      ++$vars{'n_collections_available'};
      if ($pkg=~/collection-lang/) {
        push @collections_lang, $pkg;
      } elsif ($pkg=~/documentation/) {
        if ($pkg=~/documentation-base/) {
          push @collections_std, $pkg;
        } else {
          push @collections_lang_doc, $pkg;
        }
      } else {
        push @collections_std, $pkg;
      }
    }
  }
  my $scheme_tlpobj = $tlpdb->get_package($default_scheme);
  if (defined ($scheme_tlpobj)) {
    $vars{'n_collections_selected'}=0;
    foreach my $dependent ($scheme_tlpobj->depends) {
      if ($dependent=~/^(collection-.*)/) {
        $vars{"$1"}=1;
        ++$vars{'n_collections_selected'};
      }
    }
  }
}

sub set_install_platform {
  my @available_platforms;
  my $detected_platform=platform;
  my $warn_nobin;
  my $warn_nobin_x86_64_linux;
  my $nowarn="";
  my $wp='##'; # warning prefix

  $warn_nobin="\n$wp WARNING!  No binaries for your platform found!  ";
  if (media eq 'CD') {
    $warn_nobin.="More binaries are available\n$wp on the DVD.  The binary "
        . "systems menu allows you to download extra binaries\n"
        . "$wp from the network.\n";
  }
  $warn_nobin_x86_64_linux="$warn_nobin" .
      "$wp No binaries for x86_64-linux found, using i386-linux instead.\n";

  my $ret = $warn_nobin;
  if (defined $vars{"diskbin_$detected_platform"}) {
    $vars{"diskbin_$detected_platform"}=1;
    $vars{'inst_platform'}=$detected_platform;
    $ret = $nowarn;
  } elsif (defined $vars{"netbin_$detected_platform"}) {
    $vars{"netbin_$detected_platform"}=1;
    $vars{'inst_platform'}=$detected_platform;
    $ret = $nowarn;
  } elsif ($detected_platform eq 'x86_64-linux') {
    $vars{'diskbin_i386-linux'}=1;
    $vars{'inst_platform'}='i386-linux';
    $ret = $warn_nobin_x86_64_linux;
  } else {
    $ret = $warn_nobin;
  }
  foreach my $key (keys %vars) {
    if ($key=~/^diskbin.*/ or $key=~/^netbin.*/) {
       ++$vars{'n_systems_selected'} if $vars{$key}==1;
    }
  }
  return($ret);
}

sub create_profile {
  my $profilepath = shift;
  # The file "TLprofile" is created at the beginning of the
  # installation process and contains information about the current
  # setup.  The purpose is to allow non-interactive installations.
  my $fh;
  if (ref($profilepath)) {
    $fh = $profilepath;
  } else {
    open PROFILE, ">$profilepath";
    $fh = \*PROFILE;
  }
  my $tim = gmtime(time);
  print $fh "# texlive.profile written on $tim UTC\n";
  print $fh "# it will NOT be overwritten and reflects only the\n";
  print $fh "# installation profile at installation time\n";
  print $fh "selected_scheme $vars{selected_scheme}\n";
  foreach my $key (keys %vars) {
    print $fh "$key $vars{$key}\n"
        if $key=~/^collection/ and $vars{$key}==1;
    print $fh "$key $vars{$key}\n" if $key=~/^option_letter/;
    print $fh "$key $vars{$key}\n" if $key=~/^option_doc/;
    print $fh "$key $vars{$key}\n" if $key=~/^option_fmt/;
    print $fh "$key $vars{$key}\n" if $key=~/^option_src/;
    print $fh "$key $vars{$key}\n" if $key=~/^option_symlinks/;
    print $fh "$key $vars{$key}\n" if $key=~/^TEXDIR/;
    print $fh "$key $vars{$key}\n" if $key=~/^TEXMFSYSVAR/;
    print $fh "$key $vars{$key}\n" if $key=~/^TEXMFLOCAL/;
    print $fh "$key $vars{$key}\n" if $key=~/^TEXMFHOME/;
  }
  if (!ref($profilepath)) {
    close PROFILE;
  }
}

sub read_profile {
  my $profilepath = shift;
  open PROFILE, "<$profilepath"
    or die "Cannot open profile $profilepath for reading!\n";
  my %pro;
  while (<PROFILE>) {
    next if m/^[[:space:]]*$/; # skip empty lines
    next if m/^[[:space:]]*#/; # skip comment lines
    my ($k,$v) = split;
    $pro{$k} = $v;
  }
  foreach (keys %vars) {
    # clear out collections from var
    if (m/^collection-/) { $vars{$_} = 0; }
    if (defined($pro{$_})) { $vars{$_} = $pro{$_}; }
  }
}

sub prepare_installation {
  make_var_skeleton "$vars{'TEXMFSYSVAR'}";
  make_local_skeleton "$vars{'TEXMFLOCAL'}";
  mkdirhier "$vars{'TEXDIR'}/texmf-config";

  $localtlpdb=new TeXLive::TLPDB;
  $localtlpdb->root("$vars{'TEXDIR'}");
}


sub do_install_packages {
  my @what;
  foreach my $package (sort keys %install) {
    push @what, $package if ($install{$package} == 1);
  }
  my @netarchs;
  foreach my $k (keys %vars) {
    if ($k =~ m/^netbin_(.*)$/) {
      my $a = $1;
      if ($vars{$k}) { push @netarchs, $a; }
    }
  }
  install_packages($tlpdb,$localtlpdb,\@what,\@netarchs,$vars{'option_src'},$vars{'option_doc'});
}


# do_postinst_stuff has to fix up the texmf tree and install some missing
# files. The things to do are taken from the install-live.sh installer
# of former times, and should be critically checked.
sub do_postinst_stuff {
  my $TEXDIR="$vars{'TEXDIR'}";
  my $TEXMFSYSVAR="$vars{'TEXMFSYSVAR'}";
  my $TEXMFLOCAL="$vars{'TEXMFLOCAL'}";

  # install some copies from texmf(-dist) into texmf-var
  copy ("$TEXDIR/texmf-dist/tex/plain/config/language.def",
        "$TEXMFSYSVAR/tex/plain/config")
       if (-f "$TEXDIR/texmf-dist/tex/plain/config/language.def");
  copy ("$TEXDIR/texmf/xdvi/XDvi",
        "$TEXMFSYSVAR/xdvi")
       if (-f "$TEXDIR/texmf/xdvi/XDvi");

  # those files must exist
  copy ("$TEXDIR/texmf/dvips/config/config.ps",
        "$TEXMFSYSVAR/dvips/config");
  copy ("$TEXDIR/texmf/dvipdfm/config/config",
        "$TEXMFSYSVAR/dvipdfm/config");
  copy ("$TEXDIR/texmf/web2c/mktex.cnf",
        "$TEXMFSYSVAR/web2c");

  # the old installer copied from CDDIR, but shouldn't this be installed
  # in ANY case since it is in bin-pdftex???
  copy ("$TEXDIR/texmf/tex/generic/config/pdftexconfig.tex",
        "$TEXMFSYSVAR/tex/generic/config");

  # old installer did this, should we do this, TOO????
  #cp $CDDIR/texmf-dist/tex/context/config/cont-usr.tex $TEXMFSYSVAR/tex/context/config/cont-usr.tex

  do_texmf_cnf();


  # final program execution
  # we have to do several things:
  # - clean the environment from spurious TEXMF related variables
  # - add the bin dir to the PATH
  # - select perl interpreter and set the correct perllib
  # - run the programs

  # Step 1: Clean the environment
  my @TMFVARS=qw(VARTEXFONTS TEXMFMAIN TEXMFDIST TEXMFLOCAL TEXMFSYSVAR
    TEXMFSYSCONFIG TEXMFHOME TEXMFVAR TEXMFCONFIG TEXMF SYSTEXMF VARTEXFONTS
    TEXMFDBS WEB2C TEXINPUTS TEXFORMATS MFBASES MPMEMS TEXPOOL MFPOOL MPPOOL
    PSHEADERS TEXFONTMAPS TEXPSHEADERS TEXCONFIG TEXMFCNF);

  foreach my $tmv (@TMFVARS) {
    $ENV{$tmv}=undef if (defined($ENV{$tmv}));
  }

  # Step 2: Setup the PATH, PATHEXT, switch to the new Perl

  my $pathsep=(win32)? ';' : ':';
  my $plat_bindir="$TEXDIR/bin/$vars{'this_platform'}";
  my $perl_bindir="$TEXDIR/tlpkg/tlperl/bin";
  my $perl_libdir="$TEXDIR/tlpkg/tlperl/lib";

  tllog($::LOG_NORMAL, "Prepending $plat_bindir to PATH\n");
  
  $ENV{'PATH'}="$plat_bindir" . "$pathsep" . "$ENV{'PATH'}";

  if (win32) {
    tllog($::LOG_NORMAL, "Prepending $perl_bindir to PATH\n");
    $ENV{'PATH'}="$perl_bindir" . "$pathsep" . "$ENV{'PATH'}";
  }

  tllog($::LOG_NORMAL, "\nNew PATH is now:\n");
  foreach my $dir (split $pathsep, $ENV{'PATH'}) {
    tllog($::LOG_NORMAL, "  $dir\n");
  }
  tllog($::LOG_NORMAL, "\n");

  if (win32) {
    $ENV{'PATHEXT'}=".texlua;" . "$ENV{'PATHEXT'}";
    $ENV{'PERL5LIB'}="$perl_libdir";
  }


  # Step 4: run the programs

  tllog($::LOG_NORMAL, "running mktexlsr $TEXDIR/texmf-dist $TEXDIR/texmf\n");
  system('mktexlsr', "$TEXDIR/texmf-dist", "$TEXDIR/texmf");

  # we have to generate the various config file. That could be done with
  # texconfig generate * but Win32 does not have texconfig. But we have 
  # $localtlpdb and this is simple code, so do it directly, i.e., duplicate
  # the code from the various generate-*.pl scripts
  tllog($::LOG_NORMAL, "writing fmtutil.cnf data to $TEXMFSYSVAR/web2c/fmtutil.cnf\n");
  TeXLive::TLUtils::create_fmtutil($localtlpdb, 
    "$TEXMFSYSVAR/web2c/fmtutil.cnf",
    "$TEXMFLOCAL/web2c/fmtutil-local.cnf");

  tllog($::LOG_NORMAL, "writing updmap.cfg to $TEXMFSYSVAR/web2c/updmap.cfg\n");
  TeXLive::TLUtils::create_updmap ($localtlpdb, 
    "$TEXMFSYSVAR/web2c/updmap.cfg",
    "$TEXMFLOCAL/web2c/updmap-local.cfg");

  tllog($::LOG_NORMAL, "writing language.dat data to $TEXMFSYSVAR/tex/generic/config/language.dat\n");
  TeXLive::TLUtils::create_language($localtlpdb,
    "$TEXMFSYSVAR/tex/generic/config/language.dat",
    "$TEXMFLOCAL/tex/generic/config/language-local.dat");

  tllog($::LOG_NORMAL, "running updmap-sys\n");
  system('updmap-sys', '--nohash');
  
  tllog($::LOG_NORMAL, "re-running mktexlsr $TEXMFSYSVAR\n");
  system('mktexlsr', "$TEXMFSYSVAR");

  # now work through the options if specified at all

  # letter instead of a4
  if ($vars{'option_letter'}) {
    tllog($::LOG_NORMAL, "letter option not implemented yet, please wait\n");
  }

  # all formats option
  if ($vars{'option_fmt'}) {
    tllog($::LOG_NORMAL, "pre-generation all format file (fmtutil-sys --all)\n");
    if (win32()) {
      tllog($::LOG_NORMAL, "missing fmtutil-sys, sorry, please wait!\n");
    } else {
      system('fmtutil-sys','--all');
    }
  }

  # option_links
  if ($vars{'option_symlinks'}) {
    # bin files
    my @files;
    mkdirhier $vars{'sys_bin'};
    if (-w $vars{'sys_bin'}) {
      tllog($::LOG_NORMAL, "linking binaries to $vars{'sys_bin'}\n");
      @files = `ls $plat_bindir`;
      chomp(@files);
      `cd "$vars{'sys_bin'}" && rm -f @files`;
      `ln -s "$plat_bindir/"* "$vars{'sys_bin'}"`;
    } else {
      tllog($::LOG_NORMAL, "destination of bin symlink $vars{'sys_bin'} not writable, no linking of bin files done!\n");
    }
    # info files
    mkdirhier $vars{'sys_info'};
    if (-w  $vars{'sys_info'}) {
      tllog($::LOG_NORMAL, "linking info pages to $vars{'sys_info'}\n");
      @files = `ls "$TEXDIR/texmf/doc/info"`;
      chomp(@files);
      `cd "$vars{'sys_info'}" && rm -f @files`;
      `ln -s "$TEXDIR/texmf/doc/info/"*info* "$vars{'sys_info'}"`;
    } else {
      tllog($::LOG_NORMAL, "destination of info symlink $vars{'sys_info'} not writable, no linking of info files done!\n");
    }
    # man files
    mkdirhier $vars{'sys_man'};
    if (-w  $vars{'sys_man'}) {
      tllog($::LOG_NORMAL, "linking man pages to $vars{'sys_man'}\n");
      my $foo = `(cd "$TEXDIR/texmf/doc/man" && echo *)`;
      my @mans = split ' ', $foo;
      chomp(@mans);
      foreach my $m (@mans) {
        my $mandir = "$TEXDIR/texmf/doc/man/$m";
        next unless -d $mandir;
        mkdirhier "$vars{'sys_man'}/$m";
        next unless -w "$vars{'sys_man'}/$m";
        @files = `ls "$mandir"`;
        chomp(@files);
        `cd "$vars{'sys_man'}/$m" && rm -f @files`;
        `ln -s "$mandir/"* "$vars{'sys_man'}/$m"`;
      }
    } else {
      tllog($::LOG_NORMAL, "destination of man symlink $vars{'sys_man'} not writable, no linking of man files done!\n");
    }
  }

  # old installer:
  #$config && texconfig-sys init
  #$config || echo "PLEASE RUN texconfig or texconfig-sys to make new formats."
}


# we have to adjust the texmf.cnf file to the paths set in the configuration!
sub do_texmf_cnf {
  open(TMF,"<$vars{'TEXDIR'}/texmf/web2c/texmf.cnf")
      or die("$vars{'TEXDIR'}/texmf/web2c/texmf.cnf not found: $!\n");
  my @texmfcnflines = <TMF>;
  close(TMF);
  my @newtmf;
  # we have to find TEXMFLOCAL TEXMFSYSVAR and TEXMFHOME
  foreach my $line (@texmfcnflines) {
    if ($line =~ m/^TEXMFLOCAL/) {
      # by default TEXMFLOCAL = TEXDIR/../texmf-local, if this is the case
      # we don't have to change anything from the default
      my $deftmlocal = dirname($vars{'TEXDIR'});
      $deftmlocal .= "/texmf-local";
      if ("$vars{'TEXMFLOCAL'}" eq "$deftmlocal") {
        push @newtmf, $line;
      } else {
        push @newtmf, "TEXMFLOCAL = $vars{'TEXMFLOCAL'}\n";
      }
    } elsif ($line =~ m/^TEXMFSYSVAR/) {
      # by default TEXMFSYSVAR = TEXDIR/texmf-var, if this is the case
      # we don't have to change anything from the default
      if ("$vars{'TEXMFSYSVAR'}" eq "$vars{'TEXDIR'}/texmf-var") {
        push @newtmf, $line;
      } else {
        push @newtmf, "TEXMFSYSVAR = $vars{'TEXMFSYSVAR'}\n";
      }
    } elsif ($line =~ m/^TEXMFHOME/) {
      # kpse now expands ~ to USERPROFILE, so we don't treat win32 and
      # unix differently
      push @newtmf, "TEXMFHOME = $vars{'TEXMFHOME'}\n";
    } elsif ($line =~ m/^OSFONTDIR/) {
      if (win32()) {
        push @newtmf, "OSFONTDIR = \$SystemRoot/fonts//\n";
      } else {
        push @newtmf, $line;
      }
    } else {
      push @newtmf, $line;
    }
  }
  open(TMF,">$vars{'TEXDIR'}/texmf/web2c/texmf.cnf") 
      or die("Can't open $vars{'TEXDIR'}/texmf/web2c/texmf.cnf for writing: $!\n");
  foreach (@newtmf) { print TMF; }
  close(TMF);
}

# register texlua handlers etc etc
sub do_win_registry_magic {
  # we are called under if (win32()) !!
  my $winpath = "$vars{'TEXDIR'}/bin/win32";
  #$winpath =~ s!/!\\!g;
  add_texbindir_to_path($winpath);
  register_script_type(".texlua", $winpath."/texlua.exe");
  broadcast_env;
}

#
# do everything to select a scheme
#
sub select_scheme {
  my $s = shift;
  # set the selected scheme to $s
  $vars{'selected_scheme'} = $s;
  # remove the selection of all collections
  foreach my $entry (keys %vars) {
    if ($entry=~/^(collection-.*)/) {
      $vars{"$1"}=0;
    }
  }
  # select the collections belonging to the scheme
  my $scheme_tlpobj = $tlpdb->get_package($s);
  if (defined ($scheme_tlpobj)) {
    $vars{'n_collections_selected'}=0;
    foreach my $dependent ($scheme_tlpobj->depends) {
      if ($dependent=~/^(collection-.*)/) {
        $vars{"$1"}=1;
        ++$vars{'n_collections_selected'};
      }
    }
  }
  # for good measure, update the deps
  calc_depends();
}

sub update_numbers {
  $vars{'n_collections_selected'}=0;
  $vars{'n_systems_available'} = 0;
  $vars{'n_collections_selected'} = 0;
  $vars{'n_systems_selected'} = 0;
  foreach my $key (keys %vars) {
    if ($key =~ /^(disk|net)bin/) {
      ++$vars{'n_systems_available'};
      ++$vars{'n_systems_selected'} if $vars{$key} == 1;
    }
    if ($key =~ /^collection-/) {
      ++$vars{'n_collections_available'};
      ++$vars{'n_collections_selected'} if $vars{$key} == 1;
    }
  }
}

sub flushlog {
  my $fh;
  if (open(LOG,">install-tl.log")) {
    warn "Writing log file to current working directory!\n";
    $fh = \*LOG;
  } else {
    $fh = \*STDERR;
    warn "Not creating a log file but flushing messages to stderr:\n";
  }

  foreach my $l (@::LOGLINES) {
    print $fh $l;
  }
}

__END__

### Local Variables:
### perl-indent-level: 2
### tab-width: 2
### indent-tabs-mode: nil
### End:
# vim:set tabstop=2 expandtab: #