#!/usr/bin/perl

#For option processing
use Getopt::Std;


#Options
getopts("shcdrb:") || help();
my $base = undef;
if ( defined($main::opt_b) ) {
    $base = $main::opt_b;
}
else {
    help();
    exit 1;
}

#handle options - we could give more specific help ...
#Configuration

#set up position

if (! defined ($ENV{'ARCH'})) {
	$ENV{'ARCH'} = 'x86-deb31-gcc';
}

my $testbase = "$base/tests";
my $ap4      = "$base/_$ENV{'ARCH'}/ap4";
#my $ap4      = "$base/ap4";

#my $ap4				= "/usr/bin/ap4";
my $p4d_root       = "$testbase/p4d";
my $p4_root        = "$testbase/p4root";
my $p4_client      = "$testbase/p4client";
my $test_files     = "$testbase/etc.tgz";
my $test_templates = "$testbase/etc";
my $logFile        = "$testbase/ap4.log";
my $integ_src_dir  = "X11";
my $integ_dst_dir  = "integrated";

my @sys_users  = ( 0, 2, 3, 4, 5 );
my @sys_groups = ( 0, 2, 3, 4, 5 );
my @sys_perms  = ( 0755,  0777,  0700,  0500, 0444, 0505 );

my $p4d_port = 45454;

#set up environment
$ENV{'P4USER'}   = $ENV{'USER'};
$ENV{'P4PASSWD'} = 'hallo';
$ENV{'P4DPORT'}  = "$p4d_port";
$ENV{'P4PORT'}   = "localhost:$p4d_port";
$ENV{'P4ROOT'}   = "$p4_root";
$ENV{'P4DROOT'}  = "$p4d_root";

#end configuration

#Determines permission check
my $full_perms = 0;

#Counts errors
my $all_errors = 0;

#Determines directory name
my $testcount = 0;

#The working dir
my $testdata = "$p4_client/$testcount";

sub help {
    print <<EOF;
        Usage:
        
        ap4-test.pl -b dir [-scdr] [-h]
		
		-b	Determine base directory, where the ap4 project from
			resides.

        Optional options:
	        -s	Startup p4d at port 45454 before beginning with tests.
	        	NOTE: If you're running another local p4d
	        		  this is not recommened!
	        
	        -c	Create a p4 client. For batchmode, together with -s.
	        
	        -d 	Remove and stop server and client after the tests. For batchmode.
	        
	        -r  	Set random permissions and ownership for the testfiles (root only!)
	        
	        -h	Show this message.
EOF
    exit 1;
}

#call shell functions :)
sub call_shell {
    my $command = shift;
    my $command = "/bin/bash -c \"" . "$command >> $logFile 2>&1" . '"';

    #print "II \n$command\n";
    my $retVal = system($command);
    $retVal = $retVal >> 8;
    return $retVal;
}

#Locking function. Signal safe.
sub doLock ($) {
    my $lockFile = shift;
    my $pid      = $$;
    if ( -f $lockFile ) {
        my $otherPid = `cat $lockFile`;
        chomp $otherPid;
        my $running = `ps -e | egrep -c "^ *$otherPid "`;
        if ( $running == 1 ) {
            print STDERR
"Warning: there is another instance of this script running (PID=$otherPid)\n";
            print STDERR "Abort.\n";
            return $otherPid;
        }
    }
    open( LF, ">$lockFile" );
    print LF $pid;
    close LF;
    return 0;
}


sub set_random_perms {
    my $file_names = shift;
    my $bbase       = shift;
    foreach my $entry (@$file_names) {
        chomp $entry;
        my $group = $sys_groups[ int( rand($#sys_groups) ) ];
        my $user  = $sys_users[ int( rand($#sys_users) ) ];
        my $perms = ( $sys_perms[ int( rand($#sys_perms) ) ] );
		#$perms = sprintf ("0%o",$perms);
        #print "$entry - $group - $user - $perms\n";

        #print oct($perms);
	 if ( -d "$base/$entry") {
        	$perms |= 0300;
        }
        chmod $perms, "$bbase/$entry";
        chown $user, $group, "$bbase/$entry";
    }
}

sub fuck_up_files {
    my $file_names = shift;
    my $bbase       = shift;
    my $last_entry = "$bbase/group";
    foreach my $entry (@$file_names) {
        chomp $entry;
	#FIXME: What is when a directory becomes a file??
	my $rnd = int( rand(10) ) ;
        if ( -d "$bbase/$entry" ) {#chmod directories
        	chmod 0111, "$bbase/$entry";
	} elsif ($rnd < 2) {#files
		call_shell ("cp $last_entry $bbase/$entry");
	} elsif ($rnd < 6) {#delete
		unlink ("$bbase/$entry");
	} elsif ($rnd < 9) {#make link
		#P4 BUG: deadlinks will not get replaced correctly!
		#unlink ("$bbase/$entry");
		#print ("making link of $entry\n");
		#call_shell ("ln -s $last_entry $bbase/$entry");
	}

        chown $user, $group, "$bbase/$entry";
	#takes also directories: increases the f-u-factor!
	$last_entry = "$bbase/$entry";
    }
}

sub dir_diff {
    my $src_ar   = shift;
    my $dst_ar   = shift;
    my $src_base = shift;
    my $dst_base = shift;
    print "II Doing dir_diff...\n";
    my $errors = 0;

    foreach my $entry (@$src_ar) {
        chomp $entry;
        my (
            $devS,   $inoS,     $modeS, $nlinkS, $uidS,
            $gidS,   $rdevS,    $sizeS, $atimeS, $mtimeS,
            $ctimeS, $blksizeS, $blocksS
          )
          = lstat "$src_base/$entry";
        my (
            $devT,   $inoT,     $modeT, $nlinkT, $uidT,
            $gidT,   $rdevT,    $sizeT, $atimeT, $mtimeT,
            $ctimeT, $blksizeT, $blocksT
          )
          = lstat "$dst_base/$entry";

        #print "$entry: $sizeT -> $sizeS\n";
        if ( -e "$src_base/$entry" && !-e "$dst_base/$entry" ) {
            print "EE Missing: File $entry.\n";
            $errors++;
        }
        if ( $devS != $devT ) {
            print "EE Type: File $entry was $devS, is $devT.\n";
            $errors++;
        }
        if ( $uidS != $uidT ) {
            print "EE uid: File $entry was $uidS, is $uidT.\n";
            $errors++;
        }
        if ( $gidS != $gidT ) {
            print "EE gid: File $entry was $gidS, is $gidT.\n";
            $errors++;
        }
        if ( $sizeS != $sizeT ) {
            print "EE size: File $entry was $sizeS, is $sizeT.\n";
            $errors++;
        }
        if ( $full_perms gt 0 && !-l "$src_base/$entry" ) {
            $modeS &= 0177555;
        }
        if ( $modeS != $modeT ) {
            my $o_modeS = sprintf( "%o", $modeS );
            my $o_modeT = sprintf( "%o", $modeT );
            print "EE mode: File $entry was $o_modeS, is $o_modeT.\n";
            $errors++;
        }
    }
    if ( $errors gt 0 ) {
        print "EE $errors errors occured. BUG!\n";
        $all_errors += $errors;
    }
}

#Main

my $lockfile = "/tmp/ap4-test.pl-lock";

if ( doLock($lockfile) ) {
    exit 1;
}

my $retVal;

sub cleanup {
    my $message = shift;
    my $exit_code = shift;
    print $message;
    print "Cleaning up...\n";
    if ( defined($main::opt_d) ) {
        print "II Stopping Server...\n";

        $retVal = call_shell("$p4d_root/p4d-init stop");
        if ( $retVal ne 0 ) {
            print "WW No p4d running..\n";
        }

        print "II Cleaning p4d server...\n";
        $retVal = call_shell("rm -rf $p4_root");
        if ( $retVal ne 0 ) {
            print "WW Error cleaning up server.\n";
        }

        print "II Cleaning p4 client...\n";

        $retVal = call_shell("rm -rf $p4_client");
        if ( $retVal ne 0 ) {
            print "WW Error cleaning up client.\n";
        }
    }
    if ( $all_errors gt 0 ) {
    	print "EE $all_errors errors occured.\n";
		print "You may have a look at the tail of $logFile\n";
	}
	if (!defined ($exit_code)) {
		$exit_code = 1;
	} 
	exit $exit_code;
}

sub submit {
    print "II Submitting files to p4...\n";
    $retVal =
      call_shell(
"cd $testdata && $ap4 change -o | sed 's/<enter description here>/test/' | $ap4 submit -i "
      );
    if ( $retVal ne 0 ) {
        cleanup "EE Error submitting tree to p4.\n";
    }
}

if ( defined($main::opt_h) ) {
    help();
    exit 1;
}

if ( -e $logFile ) {
	unlink ($logFile);
}

if ( defined($main::opt_s) ) {

    #Server init
    print "II Stopping Server...\n";

    $retVal = call_shell("$p4d_root/p4d-init stop && sleep 5");
    if ( $retVal ne 0 ) {
        print "II No p4d running..\n";
    }

    print "II Starting p4d server...\n";
    $retVal =
      call_shell(
        "rm -rf $p4_root && mkdir $p4_root && $p4d_root/p4d-init start");
    if ( $retVal ne 0 ) {
        cleanup "EE Error starting up server.\n";
    }
}

#Client init

if ( defined($main::opt_c) ) {

    print "II Creating p4 client...\n";

    $retVal =
      call_shell(
"rm -rf $p4_client && mkdir $p4_client && cd $p4_client && $ap4 client -o | $ap4 client -i"
      );
    if ( $retVal ne 0 ) {
        print "II No p4d running..\n";
    }

}

print "II Searching testcount...\n";

while ( -d $testdata ) {
    $testcount++;
    $testdata = "$p4_client/$testcount";
}

print "II Testcount: $testcount\n";

print "II Workdir: $testdata\n";

print "II Copying files from $test_files...\n";


$retVal =
  call_shell(
    "cd $testbase && tar xvfz $test_files"
  );
if ( $retVal ne 0 ) {
    cleanup "EE Error getting files from $test_files.\n";
}

my @src_file_names = `cd $test_templates && find .`;
shift(@src_file_names);

if ( defined($main::opt_r) ) {
    print "II Templatedir: $test_templates, setting random perms...\n";
    set_random_perms( \@src_file_names, $test_templates );
}



print "II Creating test tree...\n";

$retVal =
  call_shell(
    "mkdir -p $testdata && cd $test_templates && find . | cpio -pvda $testdata"
  );
if ( $retVal ne 0 ) {
    cleanup "EE Error creating test tree.\n";
}

my @dst_file_names = `cd $testdata && find .`;

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );

$full_perms = 1;

print "II Using $ap4...\n";

print "II Version: \n";
$retVal = system("$ap4 -V");

print "II Adding files to p4...\n";
$retVal = call_shell("cd $testdata && find . | $ap4 -x - add -f");
if ( $retVal ne 0 ) {
    cleanup "EE Error adding tree to p4.\n";
}

submit();

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );

print "II Deleting files from filesystem...\n";
$retVal = call_shell("cd $testdata && rm -rf *");
if ( $retVal ne 0 ) {
    cleanup "EE Error deleting tree.\n";
}

print "II Syncing deleted files...\n";
$retVal = call_shell("cd $testdata && $ap4 sync -f ...");
if ( $retVal ne 0 ) {
    cleanup "EE Error syncing tree.\n";
}

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );

print "II Syncing over existing files...\n";
$retVal = call_shell("cd $testdata && $ap4 sync -f ...");
if ( $retVal ne 0 ) {
    cleanup "EE Error syncing tree.\n";
}

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );

print "II Createing File scum...\n";
fuck_up_files ( \@src_file_names, $testdata );

print "II Syncing over existing modified files...\n";
$retVal = call_shell("cd $testdata && $ap4 sync -f ...");
if ( $retVal ne 0 ) {
    cleanup "EE Error syncing tree.\n";
}

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );


print "II Integrating $integ_src_dir to $integ_dst_dir\n";
$retVal =
  call_shell("cd $testdata && $ap4 integrate $integ_src_dir $integ_dst_dir");
if ( $retVal ne 0 ) {
    cleanup "EE Error integrating tree.\n";
}

print "II Integrating $integ_src_dir/... to $integ_dst_dir/...\n";
$retVal =
  call_shell(
    "cd $testdata && $ap4 integrate $integ_src_dir/... $integ_dst_dir/...");
if ( $retVal ne 0 ) {
    cleanup "EE Error integrating tree.\n";
}

my @integ_src_file_names = `cd $test_templates/$integ_src_dir && find .`;
my @integ_dst_file_names = `cd $testdata/$integ_dst_dir && find .`;

dir_diff(
    \@integ_src_file_names,           \@integ_dst_file_names,
    "$test_templates/$integ_src_dir", "$testdata/$integ_dst_dir"
);

submit();

dir_diff(
    \@integ_src_file_names,           \@integ_dst_file_names,
    "$test_templates/$integ_src_dir", "$testdata/$integ_dst_dir"
);

print "II Deleting $integ_dst_dir/...\n";
$retVal = call_shell("cd $testdata && $ap4 delete $integ_dst_dir/...");
if ( $retVal ne 0 ) {
    cleanup "EE Error delete tree.\n";
}

print "II Deleting $integ_dst_dir\n";
$retVal = call_shell("cd $testdata && $ap4 delete $integ_dst_dir");
if ( $retVal ne 0 ) {
    cleanup "EE Error delete tree.\n";
}

submit();

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );

print "II Editing files $testdata/*\n";
$retVal = call_shell("cd $testdata && $ap4 edit $testdata/*");
if ( $retVal ne 0 ) {
    cleanup "EE Error editing files.\n";
}

print "II Creating files in ${integ_src_dir}-add/...\n";
$retVal =
  call_shell("cd $testdata && cp -Ra ${integ_src_dir} ${integ_src_dir}-add");
if ( $retVal ne 0 ) {
    cleanup "EE Error creating files.\n";
}

print "II Adding files ${integ_src_dir}-add/...\n";
$retVal = call_shell("cd $testdata/${integ_src_dir}-add && $ap4 add -f ...");
if ( $retVal ne 0 ) {
    cleanup "EE Error adding files.\n";
}

print "II Deleting files ${integ_dst_dir}/*\n";
$retVal = call_shell("cd $testdata/${integ_dst_dir} && $ap4 delete ...");
if ( $retVal ne 0 ) {
    cleanup "EE Error editing files.\n";
}

submit();

dir_diff( \@src_file_names, \@dst_file_names, $test_templates, $testdata );
shift(@integ_src_file_names);
dir_diff(
    \@integ_src_file_names,           \@integ_dst_file_names,
    "$test_templates/$integ_src_dir", "$testdata/${integ_src_dir}-add"
);



cleanup("II Success!\n",0);