#!/usr/bin/perl

use strict;
use Test;
use Text::Diff;
use Algorithm::Diff qw( traverse_sequences );

## Each test specifies options to pass to "diff" when the --update option
## is present in @ARGV and options to pass to Text::Diff::diff when the
## tests are run.
my @tests= (
    ["-u", 
        ''
    ],
    ["-c",
        'STYLE => "Context"'
    ],
    ["-C0",
        'STYLE => "Context", CONTEXT => 0'
    ],
    ["-U0",
        'STYLE => "Unified", CONTEXT => 0'
    ],
    ["",
        'STYLE => "OldStyle"'     
    ],
);

my @A = map "$_\n", qw( 1 2 3 4 5d 6 7 8 9    10 11 11d 12 13 );
my @B = map "$_\n", qw( 1 2 3 4 5a 6 7 8 9 9a 10 11     12 13 );

my $sep = ( "----8<----" x 7 ) . "\n";

if ( grep "--update", @ARGV ) {
    my $version = `diff -v`;

    die "Could not determine your diff's version"
        unless defined $version && length $version;
    chomp $version;
    die "Requires GNU's diff, not '$version'" 
        unless $version =~ /GNU/;

    ## Here are the two files to feed to diff
    open A, ">A" or die $!; print A @A; close A;
    open B, ">B" or die $!; print B @B; close B;

    my $mtime_A = time;
    my $mtime_B = $mtime_A + 1;

    utime $mtime_A, $mtime_A, "A" or die $!;
    utime $mtime_B, $mtime_B, "B" or die $!;

    my $file_options = <<END_OPTIONS;
FILENAME_A => "A",
MTIME_A => $mtime_A,
FILENAME_B => "B",
MTIME_B => $mtime_B,
END_OPTIONS

    open ME, "<$0" or die $!;
    my $me = join( "", <ME> );
    close ME or die $!;

    open BAK, ">$0.bak" or die $!;
    print BAK $me or die $!;
    close BAK or die $!;

    my @diffs = map scalar `diff $_->[0] A B`, @tests;

    for ( @diffs ) {
        s/(Sun|Mon|Tue|Wed|Thu|Fri|Sat).*/<MTIME_A>/m;
        s/(Sun|Mon|Tue|Wed|Thu|Fri|Sat).*/<MTIME_B>/m;
    }

    $me =~ s/^(__DATA__\n).*//ms;
    open ME, ">$0" or die $!;
    print ME
        $me,
        "__DATA__\n",
        join $sep, "$file_options\n", @diffs
    or die $!;

    close ME or die $!;
#    unlink "A" or warn "$! unlinking A";
#    unlink "B" or warn "$! unlinking B";
    exit 0;
}

## Ok, we're not updating, so run the tests...

my @data = split $sep, join "", <DATA>;
close DATA or die $!;
die "Found " . @data,
    " elements, not ", ( @tests + 1 ),
    ", time to --update?\n"
    unless @data == @tests + 1;

my @file_options = eval "(" . shift( @data ) . ")";
die if $@;

my ( $mtime_A, $mtime_B );

{
    my %o = @file_options;
    $mtime_A = $o{MTIME_A};
    $mtime_B = $o{MTIME_B};
}

plan tests => scalar @tests;
for ( @tests ) {
    my ( $diff_opts, $Diff_opts ) = @$_;
    my $expect = shift @data;

    $expect =~ s/<MTIME_A>/localtime $mtime_A/e;
    $expect =~ s/<MTIME_B>/localtime $mtime_B/e;

    my @Diff_opts = eval "($Diff_opts)";
    die if $@;

    my $output = diff \@A, \@B, { @file_options, @Diff_opts };
    if ( $output eq $expect ) {
        ok( 1 );
    }
    else {
        ok( 0 );
        warn "# diff options: $diff_opts\n";
        warn "# my options: $Diff_opts\n";
        ## Merge the outputs using A::D
        my @E = split /^/, $expect;
        my @G = split /^/, $output;
        my $w = length "Expected";
        for ( @E, @G ) {
            s/\n/\\n/g;
            $w = length if length > $w;
        }
        my $fmt = "# %-${w}s %-2s %-${w}s\n";
        printf STDERR $fmt, "Expected", " ", "Got";
        print STDERR "# ", "-" x ( $w * 2 + 4 ), "\n";

        my ( $E_start, $G_start );
        my $print_diff = sub {
	    my ( $E_end, $G_end ) = @_;
            if ( defined $E_start || defined $G_start ) {
                while ( $E_start < $E_end || $G_start < $G_end ) {
                    printf STDERR (
                        $fmt,
                        $E_start < $E_end ? $E[$E_start] : "",
                        "!=",
                        $G_start < $G_end ? $G[$G_start] : ""
		     );

		     ++$E_start;
		     ++$G_start;
                }
                $E_start = $G_start = undef;
                
            }
        };

	my $dis = sub {
	   $E_start = $_[0] unless defined $E_start;
	   $G_start = $_[1] unless defined $G_start;
	};

        traverse_sequences(
            \@E, \@G,
            {
                MATCH => sub {
                    $print_diff->( @_ );
                    printf STDERR $fmt, $E[$_[0]], "==", $G[$_[1]];
                },
                DISCARD_A => $dis,
                DISCARD_B => $dis,
            }
        );
        $print_diff->( scalar @E, scalar @G );

        print STDERR "# ", "-" x ( $w * 2 + 4 ), "\n";
        print STDERR "#\n";
    }
}


__DATA__
FILENAME_A => "A",
MTIME_A => 1007983243,
FILENAME_B => "B",
MTIME_B => 1007983244,

----8<--------8<--------8<--------8<--------8<--------8<--------8<----
--- A	<MTIME_A>
+++ B	<MTIME_B>
@@ -2,13 +2,13 @@
 2
 3
 4
-5d
+5a
 6
 7
 8
 9
+9a
 10
 11
-11d
 12
 13
----8<--------8<--------8<--------8<--------8<--------8<--------8<----
*** A	<MTIME_A>
--- B	<MTIME_B>
***************
*** 2,14 ****
  2
  3
  4
! 5d
  6
  7
  8
  9
  10
  11
- 11d
  12
  13
--- 2,14 ----
  2
  3
  4
! 5a
  6
  7
  8
  9
+ 9a
  10
  11
  12
  13
----8<--------8<--------8<--------8<--------8<--------8<--------8<----
*** A	<MTIME_A>
--- B	<MTIME_B>
***************
*** 5 ****
! 5d
--- 5 ----
! 5a
***************
*** 9 ****
--- 10 ----
+ 9a
***************
*** 12 ****
- 11d
--- 12 ----
----8<--------8<--------8<--------8<--------8<--------8<--------8<----
--- A	<MTIME_A>
+++ B	<MTIME_B>
@@ -5 +5 @@
-5d
+5a
@@ -9,0 +10 @@
+9a
@@ -12 +12,0 @@
-11d
----8<--------8<--------8<--------8<--------8<--------8<--------8<----
5c5
< 5d
---
> 5a
9a10
> 9a
12d12
< 11d