#!/usr/bin/perl -w
use strict;
use Test;

BEGIN { plan tests => 49; }

# Collapses sequences of Re: together into one Re(\d):
sub re_collapse_parenthesis
{
	return &re_collapse($_[0], "Re(", "): "); 
}

# Collapses sequences of Re: together into one Re^\d:
sub re_collapse_caret
{
	return &re_collapse($_[0], "Re^", ": "); 
}
 
# Collapses sequences together base on $pre and $post:
sub re_collapse
{
	my $title = shift;
	my ($pre, $post) = @_;
	
	# Normal 'Re: Re: ' sequences
	$title =~ s{(Re: ){2,}}{$pre . ($+[0]-$-[0])/4 . $post}ge;
	
	# 'Re(\d):' => 'Re^\d:' and vice versa
	$title =~ s{Re(?:\((\d+)\)|\^(\d+)): }{$pre . ($1||$2) . $post}ge;
	
	# Already renumbered:
	
	# 'Re: Re(\d+): ' or the Re^\d counterpart
	while($title =~ 
		s{Re: Re(?:\((\d+)\)|\^(\d+)): }
		 {$pre . (($1||$2) + 1) . $post }ge){};
		 
	# 'Re(\d+): Re: ' or the Re^\d counterpart
	while($title =~ 
		s{Re(?:\((\d+)\)|\^(\d+)): Re: }
		 {$pre . (($1||$2) + 1) . $post }ge){};
		 
	# 'Re(\d+): Re(\d+): ' or the Re^\d counterpart
	while($title =~ 
		s{Re(?:\((\d+)\)|\^(\d+)): Re(?:\((\d+)\)|\^(\d+)): }
		 {$pre . (($1||$2) + ($3||$4)) . $post}ge){}; 

	return $title;
}

# Adds a new Re: or Re(\d): at the start of a string:
sub re_add_parenthesis
{
	return &re_add($_[0], "Re(", "): "); 
}

# Adds a new Re: or Re^\d: at the start of a string:
sub re_add_caret
{
	return &re_add($_[0], "Re^", ": "); 
}

# Adds a new Re: etc. based on $pre and $post:
sub re_add
{
	my $title = shift;
	my ($pre, $post) = @_;
	
	$title =~ 
		s{^(Re(\((\d+)\)|\^(\d+))?: )?}
		 {($1) ? ($pre . (($3||$4||1) + 1) . $post) : "Re: "}e;
	
	return $title;
}

###########################
# 
# Tests:
#

# Testing re_collapse_parenthesis:

# Should not change:

ok(&re_collapse_parenthesis("(DaP) Re: Foo is not Bar") eq "(DaP) Re: Foo is not Bar");
ok(&re_collapse_parenthesis("(DaP) Foo is not Bar") eq "(DaP) Foo is not Bar");
ok(&re_collapse_parenthesis("Re(3): (DaP) Re: Foo is not Bar") eq "Re(3): (DaP) Re: Foo is not Bar");

# Normal Re: sequences:

ok(&re_collapse_parenthesis("Re: Re: Foo is not Bar") eq "Re(2): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re: Re: Foo is not Bar") eq "Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re: (DaP) Re: Foo is not Bar") eq "Re(2): (DaP) Re: Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re: (DaP) Re: Re: Foo is not Bar") eq "Re(2): (DaP) Re(2): Foo is not Bar");

# Already renumbered:

ok(&re_collapse_parenthesis("Re: Re(2): Foo is not Bar") eq "Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re(2): Re: Foo is not Bar") eq "Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re(2): (DaP) Re: Re(2): Foo is not Bar") eq "Re(3): (DaP) Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re(2): Re: Re: Re(2): Foo is not Bar") eq "Re(6): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re(2): (DaP) Re(2): Re: Foo is not Bar") eq "Re(3): (DaP) Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re: Re(2): (DaP) Re(2): Re: Re(4): Re: Foo is not Bar") eq "Re(4): (DaP) Re(8): Foo is not Bar");

# Example from node id 168373:
# (Nothing much to do about such).
ok(&re_collapse_parenthesis("Re: Re: (Someone) Re: (Someoneelse) Re: (Someotherelse) Re: Re: Something") eq "Re(2): (Someone) Re: (Someoneelse) Re: (Someotherelse) Re(2): Something");

# Testing Re^2 style:

ok(&re_collapse_parenthesis("Re: Re^2: Foo is not Bar") eq "Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re^2: Re: Foo is not Bar") eq "Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re^2: (DaP) Re: Re^2: Foo is not Bar") eq "Re(3): (DaP) Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re^2: Re: Re: Re^2: Foo is not Bar") eq "Re(6): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re^2: (DaP) Re^2: Re: Foo is not Bar") eq "Re(3): (DaP) Re(3): Foo is not Bar");
ok(&re_collapse_parenthesis("Re: Re: Re^2: (DaP) Re^2: Re: Re^4: Re: Foo is not Bar") eq "Re(4): (DaP) Re(8): Foo is not Bar");


#######################
# Testing re_collapse_caret:

# Should not change:

ok(&re_collapse_caret("(DaP) Re: Foo is not Bar") eq "(DaP) Re: Foo is not Bar");
ok(&re_collapse_caret("(DaP) Foo is not Bar") eq "(DaP) Foo is not Bar");

# Normal Re: sequences:

ok(&re_collapse_caret("Re(3): (DaP) Re: Foo is not Bar") eq "Re^3: (DaP) Re: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: Foo is not Bar") eq "Re^2: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: Re: Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: (DaP) Re: Foo is not Bar") eq "Re^2: (DaP) Re: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: (DaP) Re: Re: Foo is not Bar") eq "Re^2: (DaP) Re^2: Foo is not Bar");

# Already renumbered:

ok(&re_collapse_caret("Re: Re(2): Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re(2): Re: Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re: Re(2): (DaP) Re: Re(2): Foo is not Bar") eq "Re^3: (DaP) Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re(2): Re: Re: Re(2): Foo is not Bar") eq "Re^6: Foo is not Bar");
ok(&re_collapse_caret("Re: Re(2): (DaP) Re(2): Re: Foo is not Bar") eq "Re^3: (DaP) Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: Re(2): (DaP) Re(2): Re: Re(4): Re: Foo is not Bar") eq "Re^4: (DaP) Re^8: Foo is not Bar");

# Example from node id 168373:
# (Nothing much to do about such).
ok(&re_collapse_caret("Re: Re: (Someone) Re: (Someoneelse) Re: (Someotherelse) Re: Re: Something") eq "Re^2: (Someone) Re: (Someoneelse) Re: (Someotherelse) Re^2: Something");

# Testing Re^2 style:

ok(&re_collapse_caret("Re: Re^2: Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re^2: Re: Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re: Re^2: (DaP) Re: Re^2: Foo is not Bar") eq "Re^3: (DaP) Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re^2: Re: Re: Re^2: Foo is not Bar") eq "Re^6: Foo is not Bar");
ok(&re_collapse_caret("Re: Re^2: (DaP) Re^2: Re: Foo is not Bar") eq "Re^3: (DaP) Re^3: Foo is not Bar");
ok(&re_collapse_caret("Re: Re: Re^2: (DaP) Re^2: Re: Re^4: Re: Foo is not Bar") eq "Re^4: (DaP) Re^8: Foo is not Bar");


#######################

# Testing re_add_parenthesis:

ok(&re_add_parenthesis("Foo is not Bar") eq "Re: Foo is not Bar");
ok(&re_add_parenthesis("Re: Foo is not Bar") eq "Re(2): Foo is not Bar");
ok(&re_add_parenthesis("Re(2): Foo is not Bar") eq "Re(3): Foo is not Bar");

# This one has to be collapsed later, so this is ok:
ok(&re_add_parenthesis("Re: Re: Foo is not Bar") eq "Re(2): Re: Foo is not Bar");

#######################

# Testing re_add_caret:

ok(&re_add_caret("Foo is not Bar") eq "Re: Foo is not Bar");
ok(&re_add_caret("Re: Foo is not Bar") eq "Re^2: Foo is not Bar");
ok(&re_add_caret("Re(2): Foo is not Bar") eq "Re^3: Foo is not Bar");
ok(&re_add_caret("Re^2: Foo is not Bar") eq "Re^3: Foo is not Bar");

# This one has to be collapsed later, so this is ok:
ok(&re_add_caret("Re: Re: Foo is not Bar") eq "Re^2: Re: Foo is not Bar");

#######################