# Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
# 
# Initial Contributors:
# Nokia Corporation - initial contribution.
# 
# Contributors:
# 
# Description:
# 
#
# Description:
# PathData/ProjectBased.pm
#

package PathData::ProjectBased;
use Utils;
use Carp;
use File::Spec;
use strict;

BEGIN {
  @PathData::ProjectBased::ISA=('PathData');
};

#
# Public
#
#

sub ProcessLine {
  my $self = shift;
  my $keywordref = shift;
  my $lineref = shift;

  die "Unknown keyword $$keywordref for project-based path data" unless ($$keywordref =~ m/archive_path/i);
  $$lineref =~ m/(\S+)\s+(\S+)(?:\s+(\S*))?/ or die "Error: Couldn't cope with archive path arguments \"$$lineref\": possibly the wrong number of arguments?\n";
  my $entry = {
    'name' => lc $1,
    'local' => $2,
    'remote' => $3
  };
 

  $self->{project_paths} ||= []; # I know this line is redundant, but I prefer explicitness :-)
  die "You cannot have multiple archive_path lines with the same project name (".$entry->{name}.")" if (grep { $_->{name} eq $entry->{'name'} } @{$self->{project_paths}});
  # You are allowed to have multiple lines with the same local and/or remote path lines,
  # but it ain't necessarily a good plan.
  push @{$self->{project_paths}}, $entry;
}

sub LocalArchivePath {
  my $self = shift;
  my $project = shift;
  my $result;
  $self->BasicChecks();

  if(defined $project){
    $self->CheckProject($project);
    $result = $self->FindEntry("name", $project);
  }
  else{
    $result = $self->FindEntryWithSub(sub { -d ($_->{'local'})});
  }
  
  return undef unless $result;
  print "Existing component stored at $result\n" if ($self->{verbose});
  return $result->{'local'};
}

sub LocalArchivePathForNewComponent {
  my $self = shift;
  my $comp = shift || confess "No component provided";
  my $ver = shift || confess "No version provided";
  my $project = shift;
  $self->BasicChecks();

  my $result;
  if (defined $project) {
    $self->CheckProject($project);
    $result = $self->FindEntry("name", $project);
  } else {
    $result = $self->{project_paths}->[0];
  }
  die "Error: No archive paths found\n" unless $result; # should never happen due to BasicChecks
  $self->CreateLocalDirectory($result);
  $result = $result->{'local'};
  print "New component being stored at $result\n" if ($self->{verbose});
  return $result . "\\$comp\\$ver";
}

sub LocalArchivePathForExistingComponent {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;
  my $project = shift;
  
  my $result;
  
  $self->BasicChecks();
  confess "Component name undefined" unless defined $comp;
  confess "Version number undefined" unless defined $ver;

  if(defined $project){
    $self->CheckProject($project);
    $result = $self->FindEntry("name", $project);
  }
  else{
    $result = $self->FindEntryWithSub(sub { -d ($_->{'local'}.'\\'.$comp.'\\'.$ver)});
  }
  
  return undef unless $result;
  print "Existing component stored at $result\n" if ($self->{verbose});
  return $result->{'local'} . "\\$comp\\$ver";
}

sub LocalArchivePathForImportingComponent {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;
  my $remotepath = shift; 
  $self->BasicChecks();
  confess "Component name undefined" unless defined $comp;
  confess "Version number undefined" unless defined $ver;
  $remotepath =~ s/(.*)\/.*/$1/;
  my $result = $self->FindEntry("remote", $remotepath);
  $self->CreateLocalDirectory($result);
  die "Couldn't find the remote project directory $remotepath where component $comp is being imported from." unless defined $result;
  return $result->{'local'} . "\\$comp\\$ver";
}

sub RemoteArchivePathForExistingComponent {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;
  my $remotesite = shift; # we must get passed a remote site object

  $self->CheckRemoteSites();

  $self->BasicChecks();
  confess "Component name undefined" unless defined $comp;
  confess "Version number undefined" unless defined $ver;
  confess "No remote site object was provided" unless (ref $remotesite);
  die "Component name undefined" unless defined $comp;
  my %checked;
  my $result = $self->FindEntryWithSub(sub {
     return undef unless $_->{'remote'}; # skip those with no remote path
     return undef if $checked{$_->{'remote'}}; # already checked this remote path
     $checked{$_->{'remote'}} = 1;
     $remotesite->FileExists($_->{'remote'}."/$comp/$comp$ver.zip"
   )});
  return undef unless defined $result;
  $result = $result->{remote};
  return $result . "/$comp";
}

sub RemoteArchivePathForExportingComponent {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;
  my $localpath = shift;

  $self->CheckRemoteSites();

  $localpath =~ s/(.*)[\/\\].*?[\/\\].*?$/$1/; # remove last two path segments
  $self->BasicChecks();
  confess "Component name undefined" unless defined $comp;
  my $result = $self->FindEntry("local", $localpath);
  die "Couldn't find the local project directory $localpath where component $comp is being exported from." unless (defined $result);
  die "Error: The archive ".$result->{name}." does not have a remote path listed in reltools.ini" unless (defined $result->{remote});
  return $result->{remote} . "/$comp";
}

sub ListComponents {
  my $self = shift;
  my $remote = shift || 0;
  my $continue = shift || 0;
  # This returns a list of the components we have locally or remotely.
  
  my $archiveExists;
  
  $self->BasicChecks();
  my @list;
  if ($remote) { # list remote archive
    $self->CheckRemoteSites();
    die "Need a remote site object" unless (ref $remote);
    foreach (map { $_->{'remote'} } @{$self->{project_paths}}) {
      next unless $remote->DirExists($_);
      $archiveExists = 1;
      my $rawlist = $remote->DirList($_);
      if ($rawlist) {
        push @list, grep { !m/^\./ } map { s/.*[\\\/]//; $_ } @$rawlist;
      }
    }
  } else { # list local archive
    foreach (map { $_->{'local'} } @{$self->{project_paths}}) {
      if (!-d $_) {
        if ($continue) {
          next;
        }		
        die "Project path $_ does not correspond to a real directory" ;
      }
      
      $archiveExists = 1;
      
      opendir LISTHANDLE, $_;
      push @list, grep { !/^\./ } readdir LISTHANDLE;
      closedir LISTHANDLE;
    }
  }
  
  if (!$archiveExists) {
    warn "Warning: The archive path locations specified in your reltools.ini do not exist\n";
  }
    
  # Now unique-ify list as per Perl Cookbook recipe
  my %seen;
  @list = grep { ! $seen{$_} ++ } @list;

  return @list if wantarray;
  return \@list;
}

sub ListProjects {
  my $self = shift;
  $self->BasicChecks();
  my @results = map { $_->{name} } @{$self->{project_paths}};
  return @results if wantarray;
  return \@results;
}

sub ListVersions {
  my $self = shift;
  my $comp = shift;
  my $remote = shift || 0;
  my $filter = shift;
  my $latestverFilter = shift;
  $self->BasicChecks();

  my $archiveExists;

  confess "Component name undefined" unless defined $comp;
  my @found;
  if ($remote) {
    $self->CheckRemoteSites();
    die "Need a remote site object" unless (ref $remote);
    foreach (map { $_->{'remote'} } @{$self->{project_paths}}) {
      my $dir = "$_/$comp";
      next unless $remote->DirExists($dir);
      $archiveExists = 1;
      my $files = $remote->DirList($dir);
      push @found, grep { $_ } map { m/.*(?:^|\\|\/)\Q$comp\E[\\\/]\Q$comp\E(.*?)\.zip$/i; $1 } @$files;
    }
  } else {
    foreach (map { $_->{'local'} } @{$self->{project_paths}}) {
      if (-e $_) {
        $archiveExists = 1;
      }
      
      my $dir = "$_\\$comp";
      if (-d $dir) {
        foreach my $entry (@{Utils::ReadDir($dir)}) {
          if (-d File::Spec->catdir($dir, $entry)) {
            push @found, $entry;
          }
        }
      }
    }
  }
  
  if (!$archiveExists) {
    warn "Warning: The archive path locations specified in your reltools.ini do not exist\n";
  }
  
  # Now unique-ify list as per Perl Cookbook recipe
  my %seen;
  @found = grep { ! $seen{$_} ++ } @found;

  # The filter regexes may have been compiled, here we uncompile them
  $latestverFilter =~ s/^\(\?[-imsx]*:(.*)\)$/$1/i if ($latestverFilter);
  $filter =~ s/^\(\?[-imsx]*:(.*)\)$/$1/i if ($filter);
           
  # Now apply a filter to the list
  @found = grep { ! m/$latestverFilter/i } @found if ($latestverFilter);
  @found = grep { m/$filter/i } @found if ($filter);
  return @found if wantarray;
  return \@found;
}

sub ComponentProjects {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;

  confess "Component name undefined" unless defined $comp;
  confess "Version number undefined" unless defined $ver;
  $self->BasicChecks();
  my @results = $self->FindEntriesWithSub(sub {
    -d ($_->{local}."\\$comp\\$ver")
  });
  return map {$_->{name}} @results; 
}

sub ComponentProject {
  my $self = shift;
  my $comp = shift;
  my $ver = shift;

  confess "Component name undefined" unless defined $comp;
  confess "Version number undefined" unless defined $ver;
  $self->BasicChecks();
  my $archive = $self->FindEntryWithSub(sub {
    -d ($_->{local}."\\$comp\\$ver")
  });

  if (defined $archive) {
    return $archive->{name};
  } else {
    return "<none>";
  }
}

#
# Private
#

sub BasicChecks {
  my $self = shift;
  die "No project paths are defined" unless ($self->{project_paths});
}

sub CheckProject {
  my $self = shift;
  my $project = shift;

  die "Project \"$project\" unknown" unless $self->FindEntry("name", $project);
}

sub FindEntry {
  my $self = shift;
  my $type = shift;
  my $what = shift;

  return ($self->FindEntries($type, $what))[0];
}

sub FindEntries {
  my $self = shift;
  my $type = shift;
  my $what = shift;

  return $self->FindEntriesWithSub(sub { lc $_->{$type} eq lc $what });
}

sub CreateLocalDirectory {
  my $self = shift;
  my $entry = shift;
  if (-e $entry->{'local'}) {
    die "Error: Local archive path ".$entry->{'local'}." is not a directory\n" unless (-d _);
  } else {
    print "Warning: creating local archive path ".$entry->{local}."\n";
    Utils::MakeDir($entry->{'local'});
  }
}

sub FindEntryWithSub {
  my $self = shift;
  my $checksub = shift;
  my $projectPath;
  
  foreach (@{$self->{project_paths}}) {
    if (&$checksub) {
      $projectPath = $_;
      last;
    }
  }

  return $projectPath;
} 

sub FindEntriesWithSub {
  my $self = shift;
  my $checksub = shift;

  return grep { &$checksub } @{$self->{project_paths}};
}

sub CheckRemoteSites {
  my $self = shift;
  my $hasRemoteSite = 0;
  
  foreach my $project (@{$self->{project_paths}}) {
    $hasRemoteSite = 1 if ($project->{remote}); 
  }
  
  die "Error: No remote sites are defined in your reltools.ini\n" if (!$hasRemoteSite);
}

1;

__END__

=head1 NAME

PathData/ProjectBased.pm - Provides the location of archived releases with a new-style archive structure.

=head1 DESCRIPTION

A subclass of C<PathData>, provides the understanding of the new-style archive path structure and returns information on where to store releases, and where existing releases are stored.

=head1 INTERFACE

The abstract methods of C<PathData> are implemented.

=head2 LocalArchivePathForNewComponent

This takes a component and a version and (optionally) the name of the project to store the component in.

=head2 LocalArchivePathForExistingComponent

This takes a component, version and optionally a project. 

=head2 LocalArchivePathForImportingComponent

This takes a component, a version, and the remote path where the component was found.

=head2 RemoteArchivePathForExistingComponent

This takes a component, a version and a C<RemoteSite> object.

=head2 RemoteArchivePathForExportingComponent

This takes a component, a version, and the local path where the component was found.

=head2 ListComponents

This takes a remote and continue flag. The remote flag when set as "1" is used to indicate that it should list the components stored remotely, not locally. The continue flag when set as "1" is used to indicate that the script should continue regardless of any problems found with regards to the paths set.

=head2 ListVersions

This takes a component. It may optionally take a "1" to indicate that it should list the versions stored remotely, not locally. The third parameter is also optional; it's a Perl-syntax pattern match for the versions.

=head2 ListProjects

=head2 ComponentProjects

This takes a component and a version and returns the project name of all archives where the release is found.

=head2 ComponentProject

This takes a component name and a version and returns the project name of the first archive where the release is found.  It gives the corresponding project name to the path that LocalArchivePathForExistingComponent gives for the same arguments.
=head2 ProcessLine

This processes a line from the F<reltools.ini>.

=head1 IMPLEMENTATION

This object has a data member, C<project_paths>, which is an array of the project descriptions found in the F<reltools.ini>. Each line is stored as a hash struct, with keys "name", "local" and "remote". It's filled in by C<ProcessLine>, and used by all the other methods via a variety of subroutines which check the contents of this array.

=head1 KNOWN BUGS

None.

=head1 COPYRIGHT

 Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
 All rights reserved.
 This component and the accompanying materials are made available
 under the terms of the License "Eclipse Public License v1.0"
 which accompanies this distribution, and is available
 at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
 Initial Contributors:
 Nokia Corporation - initial contribution.
 
 Contributors:
 
 Description:
 

=cut