use strict;
use warnings;

use Benchmark  qw{ cmpthese };
use Test::More qw{ no_plan };

my %methods = (
   nSubRegex   => sub
   {
       my @sorted = sort sortRowsRegex @{ $_[ 0 ] };
       return \ @sorted;
   },
   nSubSplit   => sub
   {
       my @sorted = sort sortRowsSplit @{ $_[ 0 ] };
       return \ @sorted;
   },
   nSubSplit3  => sub
   {
       my @sorted = sort sortRowsSplit3 @{ $_[ 0 ] };
       return \ @sorted;
   },
   stRegex   => sub
   {
       my @sorted =
          map  { $_->[ 0 ] }
          sort { $a->[ 2 ] <=> $b->[ 2 ] || $a->[ 1 ] <=> $b->[ 1 ] }
          map  { [ $_ , m{^(\d+),(\d+)} ] }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   stSplit   => sub
   {
       my @sorted =
          map  { $_->[ 0 ] }
          sort { $a->[ 1 ] <=> $b->[ 1 ] || $a->[ 2 ] <=> $b->[ 2 ] }
          map  { [ $_ , ( split m{,} )[ 1, 0 ] ] }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   stSplit3  => sub
   {
       my @sorted =
          map  { $_->[ 0 ] }
          sort { $a->[ 1 ] <=> $b->[ 1 ] || $a->[ 2 ] <=> $b->[ 2 ] }
          map  { [ $_ , ( split m{,}, $_, 3 )[ 1, 0 ] ] }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   grtRegex  => sub
   {
       my @sorted =
          map  { substr $_, 8 }
          sort
          map  { pack q{NNA*}, reverse( m{^(\d+),(\d+)} ),  $_ }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   grtSplit  => sub
   {
       my @sorted =
          map  { substr $_, 8 }
          sort
          map  { pack q{NNA*}, ( split m{,} )[ 1, 0 ], $_ }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   grtSplit3 => sub
   {
       my @sorted =
          map  { substr $_, 8 }
          sort
          map  { pack q{NNA*}, ( split m{,}, $_, 3 )[ 1, 0 ], $_ }
          @{ $_[ 0 ] };
       return \ @sorted;
   },
   );

{
    no warnings q{qw};

    my @test = qw{
       1,64,1.4.0,1.4.6
       1,128,1.4.1,1.4.6
       1,256,1.4.2,1.4.6
       1,512,1.4.3,1.4.6
       1,1024,1.4.4,1.4.6
       2,64,1.4.5,1.4.6
       2,128,1.4.6,1.4.6
       2,256,1.4.7,1.4.6
       2,512,1.4.8,1.4.6
       2,1024,1.4.9,1.4.6
       };
    my $testRes = join q{:}, qw{
       1,64,1.4.0,1.4.6
       2,64,1.4.5,1.4.6
       1,128,1.4.1,1.4.6
       2,128,1.4.6,1.4.6
       1,256,1.4.2,1.4.6
       2,256,1.4.7,1.4.6
       1,512,1.4.3,1.4.6
       2,512,1.4.8,1.4.6
       1,1024,1.4.4,1.4.6
       2,1024,1.4.9,1.4.6
       };

    foreach my $method ( sort keys %methods )
    {
        ok(
           join( q{:}, @{ $methods{ $method }->( \ @test ) } )
           eq
           $testRes,
           qq{$method}
           );
    }
}

my @unsorted;

for my $col1 ( 1 .. 32 )
{
    for my $col2 ( 1 .. 32 )
    {
        push @unsorted,
          join q{,},
             $col1,
             2 ** $col2,
             qw{
                1.4.5
                1.4.6
                44642850
                44642850
                0
                27348
                10028
                59188
                1488095
                761904.64
                };
    }
}

cmpthese(
   -5,
   {
       map
       {
           my $codeStr
              = q|sub { my $ref = $methods{ |
              . $_
              . q| }->( \ @unsorted ); }|;
           $_ => eval $codeStr;
       }
       keys %methods
   }
   );

sub sortRowsRegex
{
    my( $a1, $a2 ) = $a =~ m{^(\d+),(\d+)};
    my( $b1, $b2 ) = $b =~ m{^(\d+),(\d+)};
    return $a2 <=> $b2 || $a1 <=> $b1;
}

sub sortRowsSplit
{
    my( $a1, $a2 ) = ( split m{,}, $a )[ 0, 1 ];
    my( $b1, $b2 ) = ( split m{,}, $b )[ 0, 1 ];
    return $a2 <=> $b2 || $a1 <=> $b1;
}

sub sortRowsSplit3
{
    my( $a1, $a2 ) = ( split m{,}, $a, 3 )[ 0, 1 ];
    my( $b1, $b2 ) = ( split m{,}, $b, 3 )[ 0, 1 ];
    return $a2 <=> $b2 || $a1 <=> $b1;
}