use strict;         # strict naming rules

use Cwd;            # figuring out directories

use Data::Dumper;   # debugging purposes

use XML::Simple;    # for using xml parser

use File::Copy;     # for copying files

use Getopt::Long;   # parameter handling

use File::Temp qw/ tempdir /; # for creating unique temp directories

# uncomment to get temp dir debug traces

$File::Temp::DEBUG = 1;

my( $param_help,          # print help

    $param_server,        # manually select server

    $param_release_path,  # where are the releases located in the server

    $param_debug,         # parameter for controlling extra debug prints

    $param_latest,        # just grab the latest build (requires product name)

    $param_keepgoing,     # continue even if dependency is missing

    $param_print_only,    # do nothing but print system calls

    $param_skipITD,       # do not extract internal, testsources and documentation

    $param_emuenv,        # extract only emulator environment

    $param_start_directly,# starts extracting directly without waiting user acceptance

    $param_product,       # manually insert product name

    $param_skip_deps,     # do not extract dependencies

    $param_grace,         # do not check for grace access

    @param_exclude,       # exclude list

    @param_include,       # include list

    @force_include,       # force include list

    $param_all );         # extract all zips

my $result = GetOptions('help'      => \$param_help,            # print help

                        'h'         => \$param_help,            # print help

                        'latest'    => \$param_latest,          # just grab the latest build (requires product name)

                        'server=s'  => \$param_server,          # manually select server

                        'path=s'    => \$param_release_path,    # extract this release directly

                        'verbose'   => \$param_debug,           # verbose debug print

                        'k'         => \$param_keepgoing,       # continue even if there is any problems

                        'p'         => \$param_print_only,      # do nothing but print system calls

                        'skipitd'   => \$param_skipITD,         # Deprecated: do not extract internal, testsources and documentation

                        'emu'       => \$param_emuenv,          # Deprecated: extract only emulator environment

                        'start'     => \$param_start_directly,  # starts extracting directly without waiting user acceptance

                        'product=s' => \$param_product,         # manually insert product name

                        'x=s'       => \@param_exclude,         # filer list for excluding zips

                        'exclude=s' => \@param_exclude,         # filer list for excluding zips

                        'i=s'       => \@param_include,         # filer list for including zips

                        'include=s' => \@param_include,         # filer list for including zips

                        'f=s'       => \@force_include,         # filer list for including zips if default tag is false

                        'force=s'   => \@force_include,         # filer list for including zips if default tag is false

                        'all'       => \$param_all,             # extract all zip whether default tag is true or false

                        'nodeps'    => \$param_skip_deps,       # do not extract dependencies

                        'grace'     => \$param_grace);          # try to DL from GRACE

my $metaDataXml;            # path to metadata file

my $pathToUnzip;            # path to unzip tool

my $tmpDlDir;               # path to temp dir where we'll DL packages to

my $tmpDir;                 # path to temp dir where we extract packages from

my $returnValue;            # holds the error codes coming from 7-zip

my $graceServer;            # path to local grace server if accessible

my $logFile;                # log file for troubleshooting

my %packageHash;            # hash containing zips to extract

my @finalZipList;           # contains final list of files to unzip

my $getEnvVersion;          # version of this getenv script

my @hydraList = ();

my @hydraNameList = ();

$getEnvVersion = "2.4.9";

  print_help( ) if ( $param_help );

  if( @param_exclude and @param_include ) {

    HandleError( "you cant specify include and exclude lists at the same time!", $cannotContinue );

  }

  # checking wheter we are in root of the substituted drive (if -start param is not specified)

  if( ! $param_start_directly and

      ! getcwd =~ /[a-zA-Z]:\// and

        $param_keepgoing ) {

    HandleError( "You should run getenv only in root of the substituted drive\nYou can use -k as keep going parameter if you think it is ok to proceed", $cannotContinue );

  }

  # ok we are in root. Is the drive empty?

  my $xmlFile = 0;

  my $driveEmpty = 1;

  opendir( ROOT, "/" ) or HandleError( "cant read root dir: $!", $warning );

  my @filesFound = readdir( ROOT );

  closedir( ROOT );

  foreach my $file( @filesFound ) {

      next if $file =~ /^\.[\.]?$/;

      next if $file =~ /getenv/;

      $xmlFile = 1 if $file =~ /.*metadata.*\.xml/;

      $xmlFile = 1 if $file =~ /currentRelease\.xml/;

      $driveEmpty = 0;

  }

  printLog( "xml files: $xmlFile" );

  printLog( "drive empty: $driveEmpty" );

  # if drive is not empty and no xmls found ==> print warning (if -start param not specified)

  if( ! $param_start_directly and ! $xmlFile and ! $driveEmpty ) {

      HandleError( "The drive you are about to extract environment is not empty!\nHit CTRL-C to break now or <enter> to continue", $promptUser );

  }

  # if there is valid metadata.xml in root, params like path or latest doesn't make any sense

  if( $xmlFile ) {

      foreach my $file( @filesFound ) {

          if( $file =~ /.*metadata(_(\d*))?.xml$/i ) {

              print "metadata file found!\n";

              if( ValidateXmlFile( getcwd.$file ) ) {

                  $metaDataXml = getcwd.$file;

                  last;

              }

          }

      }

  }

  if( $metaDataXml ) {

    if( $param_latest or $param_release_path ) {

          print "It doesnt make sense to use 'path' or 'latest' parameter while having metadata.xml in root!\n\n";

          print_help( );

          exit 0;

  # we should ask correct grace share if xmlfile !server !start       

    if( !$param_server and ! $param_start_directly ) {

      print "For your convenience it is recommended to use HYDRA samba share close to you.\n";

      # prompt user wheter he wants to use GRACE

      my $networkAccessVerified = 0;

      while( $networkAccessVerified eq 0 ) {

        my $wantedServer = FixPaths( $hydraList[ ReturnMenuIndex( "Please select share closest to you", @hydraNameList ) ] );

        if( $wantedServer eq FixPaths( $hydraList[0] ) ) {

              HandleError( "Please notice that access to $hydraList[0] will be removed from wk50 onwards. Now would be perfect time to get yourself a GRACE access.", $promptUser );

        printLog( "selected: $wantedServer - accessing.." );

        if( opendir( GRACETEST, $wantedServer ) ) {

          printLog( "connection tested OK" );

          $networkAccessVerified = 1;

          $pathToReleaseFolder = $wantedServer;

              print "Unable to access $wantedServer\nPlease select another network share.\n";

      }

          # in case we have metadata in \ and -start defined, look grace automatically

    elsif( !$param_server and $param_start_directly ) {

              $pathToReleaseFolder = FindGraceServer( );

  }

  # ToDo: if there is not metadata.xml in root check if we have already env. Possibly update?

  # is 'path' parameter is used, find out (wheter there exists) valid metadata.xml

  if( $param_release_path ) {

    if( $param_latest or $param_product ) {

      print "It doesnt make sense to use 'path' or 'latest' parameter while having metadata.xml in root!\n\n";

      print_help( );

      exit 0;

    }

    $metaDataXml = FixPaths( $param_release_path );

    $metaDataXml .= SearchValidXml( $metaDataXml );

    printLog( "setting metadata: $metaDataXml" );

  }

  # handle server parameter

  # simply just verify accessablility and fix path

  if( $param_server ) {

      $pathToReleaseFolder = FixPaths( $param_server );

      opendir( OPENTEST, $pathToReleaseFolder ) or HandleError( "Unable to access given server path: $pathToReleaseFolder\n$!", $cannotContinue );

      closedir( OPENTEST );

  }

  # param_latest is used to just get latest release - requires product

  if( $param_latest ) {

    if( $param_product ) {

      $param_product = FixPaths( $param_product );

      # once the network share is unavailable then tries to find grace share

      $pathToReleaseFolder = FindGraceServer( );

      opendir( RELDIR, $pathToReleaseFolder.$defaultServiceName.$param_product ) or die "unable to open $pathToReleaseFolder$defaultServiceName$param_product\n$!";

      # scan all xml files to @files_found

# salmarko starts

      my @files_found = grep { /^pf_|^S60_|^dfs_/i } readdir RELDIR;

# salmarko ends

      close RELDIR;

      if( @files_found ) {

          foreach( reverse sort ( @files_found ) ) {

              # we only want to get the last dir name..

              s/.*\///i;

              my $productToDl = $pathToReleaseFolder.$defaultServiceName.$param_product;

              $productToDl .= FixPaths( $_ );

              print "Searching metadata.xml files from $productToDl\n" if $param_debug;

              $metaDataXml = SearchValidXml( $productToDl ) ;

              if( $metaDataXml ) {

                  $metaDataXml = $productToDl.$metaDataXml;

                  printLog( "selected xml: $metaDataXml" );

                  last;

              }

          }

      }

      else {

          HandleError( "cannot find releases from $pathToReleaseFolder$defaultServiceName$param_product", $cannotContinue );

      }

    }

    else {

        die "If you specify -latest parameter you have to define -product also!\n";

    }

  }

  # use wizard to find out what to DL

  if( ! $metaDataXml ) {

      printLog( "Not enought valid inputs provided - running wizard..." );

      RunWizard( );

  }

  # check wheter metadata and currentRelease adds up

  if( -e FixPaths( getcwd )."currentRelease.xml") {

      printLog( "CurrenRelease.xml exists. Checking wheter update is possible" );

      # compare service, product and release with xml files

      my $CurrentRelXmlParser = new XML::Simple( );

      my $currentReleaseData = $CurrentRelXmlParser->XMLin( FixPaths( getcwd )."currentRelease.xml" );

      my $xmlParser = new XML::Simple( );

      my $xmlData = $xmlParser->XMLin( $metaDataXml );

      my $currentRelease = '';

      my $newRelease = '';

      if ( !defined $xmlData->{releaseDetails}->{dependsOf}->{service}->{name} ) { # no dependencies, lets compare current to new

          # compare services

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name} ne

                  $xmlData->{releaseDetails}->{releaseID}->{service}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{releaseID}->{service}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name}, $cannotContinue );

          }

          # compare products

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name} ne

                  $xmlData->{releaseDetails}->{releaseID}->{product}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{releaseID}->{product}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name}, $cannotContinue );

          }

          printLog( "service and product matches.. checking release" );

          $currentRelease = $currentReleaseData->{releaseDetails}->{releaseID}->{release}->{name};

          $newRelease = $xmlData->{releaseDetails}->{releaseID}->{release}->{name};

      }

      else{

          # compare services

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name} ne

                  $xmlData->{releaseDetails}->{dependsOf}->{service}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{dependsOf}->{service}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name}, $cannotContinue );

          }

          # compare products

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name} ne

                  $xmlData->{releaseDetails}->{dependsOf}->{product}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{dependsOf}->{product}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name}, $cannotContinue );

          }

          printLog( "service and product matches.. checking release" );

          # compare releases

          $currentRelease = $currentReleaseData->{releaseDetails}->{releaseID}->{release}->{name};

          $newRelease = $xmlData->{releaseDetails}->{dependsOf}->{release}->{name};

          if ( $currentRelease =~ m/^(S60_\d_\d+_\d{6})/i or $currentRelease =~ m/^(pf_\d{4}_\d{6})/ ) {

              $currentRelease = $1;

          }

          else {

              HandleError( "Current release info unknown or missing: $currentRelease", $cannotContinue );

          }

          if ( $newRelease =~ m/^(S60_\d_\d+_\d{6})/i or $newRelease =~ m/^(pf_\d{4}_\d{6})/ ) {

              $newRelease = $1;

          }

          else {

              HandleError( "New release info unknown or missing: $newRelease", $cannotContinue );

          }

      }

      printLog( "current release: $currentRelease" );

      printLog( "release to extract: $newRelease" );

#salmarko ends

      if( $currentRelease ne $newRelease ) {

          HandleError( "Can not extract $newRelease release on top of $currentRelease", $cannotContinue );

      }

      printLog( "release matches - update possible" );

      $currentRelease = FixPaths( getcwd )."currentRelease.xml";

  }

  # check wheter we can use c-disc as temp

  my $df = getFreeDisk(  $ENV{'TEMP'}  );

  if( $df > 2147483648 && $df < 2147483648000 ) {

    printLog( "amount of free space seems sane: $df" );

    $tmpDir = FixPaths( tempdir( CLEANUP => 0 ) );

    printLog( "setting tmpDir: $tmpDir" );

    $tmpDlDir = FixPaths( tempdir( CLEANUP => 0 ) );

    printLog( "setting tmpDlDir: $tmpDlDir" );

  }

  getenv.pl -all        extract all zips

  getenv.pl -Force      forces to extract some filtered packages ( tsrc ) including default zips