use strict;
use Benchmark qw(cmpthese);
use Cache::Memcached;
use Cache::Memcached::Fast;
use Cache::Memcached::libmemcached;
use Getopt::Long;

my $no_block = 0;
my $server   = '';
my %modes = (
    simple_get       => 1,
    simple_get_multi => 0,
    serialize_get    => 0,
    simple_set       => 0,
);

if (! GetOptions(
    "no_block!" => \$no_block,
    "server=s" => \$server,
    "simple-get!"       => \$modes{simple_get},
    "simple-get_multi!" => \$modes{simple_get_multi},
    "serialize-get!"    => \$modes{serialize_get},
    "compress-get!"     => \$modes{compress_get},
    "simple-set!"       => \$modes{simple_set},
    "serialize-set!"    => \$modes{serialize_set},
    "compress-set!"     => \$modes{compress_set},
)) {
    exit 1;
}
$server ||= $ENV{MEMCACHED_SERVER} || 'localhost:11211';

print "Module Information:\n";
foreach my $module qw(Cache::Memcached Cache::Memcached::Fast Cache::Memcached::libmemcached) {
    no strict 'refs';
    print " + $module => " . ${ "${module}::VERSION" }, "\n";
}

print "\n";
print "Options:\n";
print " + Memcached server: $server\n";
print " + Include no block mode (where applicable)? :", $no_block ? "YES" : "NO", "\n";

my %args = (
    servers => [ $server ],
    compress_threshold => 1_000,
);

my $data;

print "\n";
print "Prepping clients...\n";
my %clients = (
    perl_memcached => Cache::Memcached->new(\%args),
    memcached_fast => Cache::Memcached::Fast->new(\%args),
    libmemcached   => Cache::Memcached::libmemcached->new(\%args)
);

# Include non-blocking client modes
if ($no_block) {
    $clients{libmemcached_no_block} = Cache::Memcached::libmemcached->new({
        %args, no_block => 1
    });
}

print "\n";

if ($modes{simple_get}) {
    print qq|==== Benchmark "Simple get() (scalar)" ====\n|;
    $data = '0123456789' x 10;
    $clients{perl_memcached}->set( 'foo', $data );
    cmpthese(50_000, +{
        map {
            my $client = $clients{$_};
            $_ => sub { ($client->get('foo') eq $data) or die "$client did not return proper value" }
        } keys %clients
    });
}

if ($modes{simple_get_multi}) {
    print qq|==== Benchmark "Simple get_multi() (scalar)" ====\n|;

    my @keys = ('a'..'z');
    for (@keys) {
        $clients{perl_memcached}->set($_, $_);
    }
    cmpthese(50_000, +{
        map {
            my $client = $clients{$_};
            $_ => sub { $client->get_multi(@keys) }
        } keys %clients
    });
}

if ($modes{serialize_get}) {
    print qq|==== Benchmark "Serialization with get()" ====\n|;
    $data = { foo => [ qw(1 2 3) ] };
    $clients{perl_memcached}->set( 'foo', $data );
    cmpthese(50_000, {
        map {
            my $client = $clients{$_};
            $_ => sub { 
                my $h = $client->get('foo');
                ref($h) eq 'HASH' or die "$client did not return a hash";
                ref($h->{foo}) eq 'ARRAY' or die "$client did not return an array in hash";
            }
        } keys %clients
    });
}

if ($modes{compress_get}) {
    print qq|==== Benchmark "Simple get() (w/compression)" ====\n|;
    $data = '0123456789' x 500;
    $clients{perl_memcached}->set( 'foo', $data );
    cmpthese(50_000, {
        map {
            my $client = $clients{$_};
            $_ => sub { 
                my $h = $client->get('foo');
                length($h) == 5000 or die "$client did not return 5000 bytes";
            }
        } keys %clients
    });
}

if ($modes{simple_set}) {
    print qq|==== Benchmark "Simple set() (scalar)" ====\n|;
    $data = '0123456789' x 10;
    cmpthese(50_000, {
        map {
            my $client = $clients{$_};
            $_ => sub { 
                $client->set('foo', $data);
            }
        } keys %clients
    });
}

if ($modes{serialize_set}) {
    print qq|==== Benchmark "Simple set() (w/seriale)" ====\n|;
    $data = { foo => [ qw( 1 2 3 ) ] };
    cmpthese(50_000, {
        map {
            my $client = $clients{$_};
            $_ => sub { 
                $client->set('foo', $data);
            }
        } keys %clients
    });
}

if ($modes{compress_set}) {
    print qq|==== Benchmark "Simple set() (w/compress)" ====\n|;
    $data = '0123456789' x 500;
    cmpthese(50_000, {
        map {
            my $client = $clients{$_};
            $_ => sub { 
                $client->set('foo', $data);
            }
        } keys %clients
    });
}

__END__

{
    print qq|==== Benchmark "Simple set() (w/serialize)" ====\n|;
    $data = { foo => [ qw(1 2 3) ] };
    cmpthese(100_000, {
        perl_memcahed => sub {
            $memd->set( 'foo', $data );
        },
        memcached_fast => sub {
            $memd_fast->set( 'foo', $data );
        },
        libmemcached  => sub {
            $libmemd->set( 'foo', $data );
        },
#        libmemcached_no_block  => sub {
#            $libmemd_no_block->set( 'foo', $data );
#        },
    });
}

{
    print qq|==== Benchmark "Simple set() (w/compress)" ====\n|;
    $data = '0123456789' x 500;
    cmpthese(100_000, {
        perl_memcahed => sub {
            $memd->set( 'foo', $data );
        },
        memcached_fast => sub {
            $memd_fast->set( 'foo', $data );
        },
        libmemcached  => sub {
            $libmemd->set( 'foo', $data );
        },
#        libmemcached_no_block  => sub {
#            $libmemd_no_block->set( 'foo', $data );
#        },
    });
}