#!/usr/bin/perl

BEGIN {
   die "The PERCONA_TOOLKIT_BRANCH environment variable is not set.\n"
      unless $ENV{PERCONA_TOOLKIT_BRANCH} && -d $ENV{PERCONA_TOOLKIT_BRANCH};
   unshift @INC, "$ENV{PERCONA_TOOLKIT_BRANCH}/lib";
};

use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
use Test::More;

use VersionParser;
use Quoter;
use TableParser;
use DSNParser;
use QueryParser;
use TableSyncer;
use TableChecksum;
use TableSyncGroupBy;
use MockSyncStream;
use MockSth;
use Outfile;
use RowDiff;
use ChangeHandler;
use ReportFormatter;
use Transformers;
use Retry;
use Sandbox;
use CompareResults;
use PerconaTest;

my $dp  = new DSNParser(opts=>$dsn_opts);
my $sb  = new Sandbox(basedir => '/tmp', DSNParser => $dp);
my $dbh1 = $sb->get_dbh_for('master');
my $dbh2 = $sb->get_dbh_for('slave1');

if ( !$dbh1 ) {
   plan skip_all => "Cannot connect to sandbox master";
}
elsif ( !$dbh2 ) {
   plan skip_all => "Cannot connect to sandbox slave";
}

Transformers->import(qw(make_checksum));

my $q  = new Quoter();
my $qp = new QueryParser();
my $tp = new TableParser(Quoter => $q);
my $tc = new TableChecksum(Quoter => $q);
my $of = new Outfile();
my $rr = new Retry();
my $ts = new TableSyncer(
   Quoter        => $q,
   TableChecksum => $tc,
   Retry         => $rr,
   MasterSlave   => 1,
);
my %modules = (
   Quoter        => $q,
   TableParser   => $tp,
   TableSyncer   => $ts,
   QueryParser   => $qp,
   Outfile       => $of,
);

my $plugin = new TableSyncGroupBy(Quoter => $q);

my $cr;
my $i;
my $report;
my @events;
my $hosts = [
   { dbh => $dbh1, name => 'master' },
   { dbh => $dbh2, name => 'slave'  },
];

sub proc {
   my ( $when, %args ) = @_;
   die "I don't know when $when is"
      unless $when eq 'before_execute'
          || $when eq 'execute'
          || $when eq 'after_execute';
   for my $i ( 0..$#events ) {
      $events[$i] = $cr->$when(
         event    => $events[$i],
         dbh      => $hosts->[$i]->{dbh},
         %args,
      );
   }
};

sub get_id {
   return make_checksum(@_);
}

# #############################################################################
# Test the checksum method.
# #############################################################################

$sb->load_file('master', "t/lib/samples/compare-results.sql");

$cr = new CompareResults(
   method     => 'checksum',
   'base-dir' => '/dev/null',  # not used with checksum method
   plugins    => [$plugin],
   get_id     => \&get_id,
   %modules,
);

isa_ok($cr, 'CompareResults');

@events = (
   {
      arg         => 'select * from test.t where i>0',
      fingerprint => 'select * from test.t where i>?',
      sampleno    => 1,
   },
   {
      arg         => 'select * from test.t where i>0',
      fingerprint => 'select * from test.t where i>?',
      sampleno    => 1,
   },
);

is_deeply(
   $dbh1->selectrow_arrayref("SHOW TABLES FROM test LIKE 'dropme'"),
   ['dropme'],
   'checksum: temp table exists'
);

proc('before_execute', db=>'test', 'temp-table'=>'dropme');

is(
   $events[0]->{wrapped_query},
   'CREATE TEMPORARY TABLE `test`.`dropme` AS select * from test.t where i>0',
   'checksum: before_execute() wraps query in CREATE TEMPORARY TABLE'
);

is_deeply(
   $dbh1->selectall_arrayref("SHOW TABLES FROM test LIKE 'dropme'"),
   [],
   'checksum: before_execute() drops temp table'
);

ok(
   !exists $events[0]->{Query_time},
   "checksum: Query_time doesn't exist before execute()"
);

proc('execute');

ok(
   exists $events[0]->{Query_time},
   "checksum: Query_time exists after exectue()"
);

like(
   $events[0]->{Query_time},
   qr/^[\d.]+$/,
   "checksum: Query_time is a number ($events[0]->{Query_time})"
);

is(
   $events[0]->{wrapped_query},
   'CREATE TEMPORARY TABLE `test`.`dropme` AS select * from test.t where i>0',
   "checksum: execute() doesn't unwrap query"
);

is_deeply(
   $dbh1->selectall_arrayref('select * from test.dropme'),
   [[1],[2],[3]],
   'checksum: Result set selected into the temp table'
);

ok(
   !exists $events[0]->{row_count},
   "checksum: row_count doesn't exist before after_execute()"
);

ok(
   !exists $events[0]->{checksum},
   "checksum: checksum doesn't exist before after_execute()"
);

proc('after_execute');

is(
   $events[0]->{wrapped_query},
   'CREATE TEMPORARY TABLE `test`.`dropme` AS select * from test.t where i>0',
   'checksum: after_execute() left wrapped query'
);

is_deeply(
   $dbh1->selectall_arrayref("SHOW TABLES FROM test LIKE 'dropme'"),
   [],
   'checksum: after_execute() drops temp table'
);

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 0,
      different_checksums     => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'checksum: compare, no differences'
);

is(
   $events[0]->{row_count},
   3,
   "checksum: correct row_count after after_execute()"
);

is(
   $events[0]->{checksum},
   '251493421',
   "checksum: correct checksum after after_execute()"
);

ok(
   !exists $events[0]->{wrapped_query},
   'checksum: wrapped query removed after compare'
);

# Make checksums differ.
$dbh2->do('update test.t set i = 99 where i=1');

proc('before_execute', db=>'test', 'temp-table'=>'dropme');
proc('execute');
proc('after_execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 0,
      different_checksums     => 1,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'checksum: compare, different checksums' 
);

# Make row counts differ, too.
$dbh2->do('insert into test.t values (4)');

proc('before_execute', db=>'test', 'temp-table'=>'dropme');
proc('execute');
proc('after_execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 1,
      different_checksums     => 1,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'checksum: compare, different checksums and row counts'
);

$report = <<EOF;
# Checksum differences
# Query ID           host1     host2
# ================== ========= ==========
# D2D386B840D3BEEA-1 $events[0]->{checksum} $events[1]->{checksum}

# Row count differences
# Query ID           host1 host2
# ================== ===== =====
# D2D386B840D3BEEA-1     3     4
EOF

is(
   $cr->report(hosts => $hosts),
   $report,
   'checksum: report'
);

my %samples = $cr->samples($events[0]->{fingerprint});
is_deeply(
   \%samples,
   {
      1 => 'select * from test.t where i>0',
   },
   'checksum: samples'
);

# #############################################################################
# Test the rows method.
# #############################################################################
my $tmpdir = '/tmp/mk-upgrade-res';
SKIP: {

diag(`rm -rf $tmpdir 2>/dev/null; mkdir $tmpdir`);

$sb->load_file('master', "t/lib/samples/compare-results.sql");

$cr = new CompareResults(
   method     => 'rows',
   'base-dir' => $tmpdir,
   plugins    => [$plugin],
   get_id     => \&get_id,
   %modules,
);

isa_ok($cr, 'CompareResults');

@events = (
   {
      arg => 'select * from test.t',
      db  => 'test',
   },
   {
      arg => 'select * from test.t',
      db  => 'test',
   },
);

is_deeply(
   $dbh1->selectrow_arrayref("SHOW TABLES FROM test LIKE 'dropme'"),
   ['dropme'],
   'rows: temp table exists'
);

proc('before_execute');

is(
   $events[0]->{arg},
   'select * from test.t',
   "rows: before_execute() doesn't wrap query and doesn't require tmp table"
);

is_deeply(
   $dbh1->selectrow_arrayref("SHOW TABLES FROM test LIKE 'dropme'"),
   ['dropme'],
   "rows: before_execute() doesn't drop temp table"
);

ok(
   !exists $events[0]->{Query_time},
   "rows: Query_time doesn't exist before execute()"
);

ok(
   !exists $events[0]->{results_sth},
   "rows: results_sth doesn't exist before execute()"
);

proc('execute');

ok(
   exists $events[0]->{Query_time},
   "rows: query_time exists after exectue()"
);

ok(
   exists $events[0]->{results_sth},
   "rows: results_sth exists after exectue()"
);

like(
   $events[0]->{Query_time},
   qr/^[\d.]+$/,
   "rows: Query_time is a number ($events[0]->{Query_time})"
);

ok(
   !exists $events[0]->{row_count},
   "rows: row_count doesn't exist before after_execute()"
);

is_deeply(
   $cr->after_execute(event=>$events[0]),
   $events[0],
   "rows: after_execute() doesn't modify the event"
);

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 0,
      different_column_values => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, no differences'
);

is(
   $events[0]->{row_count},
   3,
   "rows: compare() sets row_count"
);

is(
   $events[1]->{row_count},
   3,
   "rows: compare() sets row_count"
);

# Make the result set differ.
$dbh2->do('insert into test.t values (5)');

proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 1,
      different_column_values => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, different row counts'
);

# Use test.t2 and make a column value differ.
@events = (
   {
      arg         => 'select * from test.t2',
      db          => 'test',
      fingerprint => 'select * from test.t2',
      sampleno    => 3,
   },
   {
      arg         => 'select * from test.t2',
      db          => 'test',
      fingerprint => 'select * from test.t2',
      sampleno    => 3,
   },
);

$dbh2->do("update test.t2 set c='should be c' where i=3");

is_deeply(
   $dbh2->selectrow_arrayref('select c from test.t2 where i=3'),
   ['should be c'],
   'rows: column value is different'
);

proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 0,
      different_column_values => 1,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, different column values'
);

is_deeply(
   $dbh1->selectall_arrayref('show indexes from test.mk_upgrade_left'),
   [],
   'Did not add indexes'
);

$report = <<EOF;
# Column value differences
# Query ID           Column host1 host2
# ================== ====== ===== ===========
# CFC309761E9131C5-3 c      c     should be c

# Row count differences
# Query ID           host1 host2
# ================== ===== =====
# B8B721D77EA1FD78-0     3     4
EOF

is(
   $cr->report(hosts => $hosts),
   $report,
   'rows: report'
);

%samples = $cr->samples($events[0]->{fingerprint});
is_deeply(
   \%samples,
   {
      3 => 'select * from test.t2'
   },
   'rows: samples'
);

# #############################################################################
# Test max-different-rows.
# #############################################################################
$cr->reset();
$dbh2->do("update test.t2 set c='should be a' where i=1");
$dbh2->do("update test.t2 set c='should be b' where i=2");
proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
      'max-different-rows' => 1,
      'add-indexes'        => 1,
   ) ],
   [
      different_row_counts    => 0,
      different_column_values => 1,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, stop at max-different-rows'
);

# I don't know why but several months ago this test started
# failing although nothing afaik was changed.  This module
# is only used in pt-upgrade and that tool passes its tests.
SKIP: {
   skip "Fix this test", 1;
is_deeply(
   $dbh1->selectall_arrayref('show indexes from test.mk_upgrade_left'),
   [['mk_upgrade_left','0','i','1','i','A',undef,undef, undef,'YES','BTREE','']],
   'Added indexes'
);
}

$report = <<EOF;
# Column value differences
# Query ID           Column host1 host2
# ================== ====== ===== ===========
# CFC309761E9131C5-3 c      a     should be a
EOF

is(
   $cr->report(hosts => $hosts),
   $report,
   'rows: report max-different-rows'
);

# #############################################################################
# Double check that outfiles have correct contents.
# #############################################################################

# This test uses the results from the max-different-rows test above.

my @outfile = split(/[\t\n]+/, `cat /tmp/mk-upgrade-res/left-outfile.txt`);
is_deeply(
	\@outfile,
	[qw(1 a 2 b 3 c)],
   'Left outfile'
);

@outfile = split(/[\t\n]+/, `cat /tmp/mk-upgrade-res/right-outfile.txt`);
is_deeply(
	\@outfile,
	['1', 'should be a', '2', 'should be b', '3', 'should be c'],
   'Right outfile'
);

# #############################################################################
# Test float-precision.
# #############################################################################
@events = (
   {
      arg         => 'select * from test.t3',
      db          => 'test',
      fingerprint => 'select * from test.t3',
      sampleno    => 3,
   },
   {
      arg         => 'select * from test.t3',
      db          => 'test',
      fingerprint => 'select * from test.t3',
      sampleno    => 3,
   },
);

$cr->reset();
$dbh2->do('update test.t3 set f=1.12346 where 1');
proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
   ) ],
   [
      different_row_counts    => 0,
      different_column_values => 1,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, different without float-precision'
);

proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
      'float-precision' => 3
   ) ],
   [
      different_row_counts    => 0,
      different_column_values => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, not different with float-precision'
);

# #############################################################################
# Test when left has more rows than right.
# #############################################################################
$cr->reset();
$dbh1->do('update test.t3 set f=0 where 1');
$dbh1->do('SET SQL_LOG_BIN=0');
$dbh1->do('insert into test.t3 values (2.0),(3.0)');
$dbh1->do('SET SQL_LOG_BIN=1');
$sb->wait_for_slaves();

my $left_n_rows = $dbh1->selectcol_arrayref('select count(*) from test.t3')->[0];
my $right_n_rows = $dbh2->selectcol_arrayref('select count(*) from test.t3')->[0];
ok(
   $left_n_rows == 3 && $right_n_rows == 1,
   'Left has extra rows'
);

proc('before_execute');
proc('execute');

is_deeply(
   [ $cr->compare(
      events => \@events,
      hosts  => $hosts,
      'float-precision' => 3
   ) ],
   [
      different_row_counts    => 1,
      different_column_values => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'rows: compare, left with more rows'
);

$report = <<EOF;
# Row count differences
# Query ID           host1 host2
# ================== ===== =====
# D56E6FABA26D1F1C-3     3     1
EOF

is(
   $cr->report(hosts => $hosts),
   $report,
   'rows: report, left with more rows'
);
}

# #############################################################################
# Try to compare without having done the actions.
# #############################################################################
@events = (
   {
      arg => 'select * from test.t',
      db  => 'test',
   },
   {
      arg => 'select * from test.t',
      db  => 'test',
   },
);

$cr = new CompareResults(
   method     => 'checksum',
   'base-dir' => '/dev/null',  # not used with checksum method
   plugins    => [$plugin],
   get_id     => \&get_id,
   %modules,
);

my @diffs;
eval {
   @diffs = $cr->compare(events => \@events, hosts => $hosts);
};

is(
   $EVAL_ERROR,
   '',
   "compare() checksums without actions doesn't die"
);

is_deeply(
   \@diffs,
   [
      different_row_counts    => 0,
      different_checksums     => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'No differences after bad compare()'
);

SKIP: {

$cr = new CompareResults(
   method     => 'rows',
   'base-dir' => $tmpdir,
   plugins    => [$plugin],
   get_id     => \&get_id,
   %modules,
);

eval {
   @diffs = $cr->compare(events => \@events, hosts => $hosts);
};

is(
   $EVAL_ERROR,
   '',
   "compare() rows without actions doesn't die"
);

is_deeply(
   \@diffs,
   [
      different_row_counts    => 0,
      different_column_values => 0,
      different_column_counts => 0,
      different_column_types  => 0,
   ],
   'No differences after bad compare()'
);

}

# #############################################################################
# Done.
# #############################################################################
my $output = '';
{
   local *STDERR;
   open STDERR, '>', \$output;
   $cr->_d('Complete test coverage');
}
like(
   $output,
   qr/Complete test coverage/,
   '_d() works'
);
diag(`rm -rf $tmpdir`);
diag(`rm -rf /tmp/*outfile.txt`);
$sb->wipe_clean($dbh1);
$sb->wipe_clean($dbh2);
ok($sb->ok(), "Sandbox servers") or BAIL_OUT(__FILE__ . " broke the sandbox");
done_testing;
exit;