package Utils;

use strict;
use warnings;
use vars qw( $VERSION @ISA @EXPORT );
require Exporter;
use Module::ScanDeps qw(path_to_inc_name);

use Test::More;

@ISA=qw(Exporter);
$VERSION   = '0.1';
@EXPORT = qw( generic_scandeps_rv_test compare_scandeps_rvs generic_abs_path );

my $test = Test::More->builder;

sub import {
    my($self) = shift;
    my $pack = caller;

    $test->exported_to($pack);
    $self->export_to_level(1, $self, @EXPORT);
}

sub generic_scandeps_rv_test {
    my $rv = shift;
    my $array_ref = shift;
    my @input_keys = sort @$array_ref;
       $array_ref = shift;
    my @known_deps = sort @$array_ref;
    my @used_by;
    my ($used_by_ok, $i);

    # sanity check input
    foreach my $input (@input_keys) {
      !(grep {$_ eq $input} @known_deps) or die "\@input_keys overlaps with \@known_deps\n";
    }

    $test->ok(ref($rv) eq "HASH", "\$rv is a ref") or return;

    # check all input files and known deps correspond to an entry in rv
    map {$_ = path_to_inc_name($_, 1)} @input_keys;
    map {$_ =~ s|\\|\/|go} (@input_keys, @known_deps);
    $test->ok(exists $rv->{$_}, "$_ is in rv") foreach (@input_keys, @known_deps);

    # Check general properties of the keys
    foreach my $key (keys %$rv) {
        $test->ok(exists($rv->{$key}{key})  && $key eq $rv->{$key}{key}, "For $key: the sub-key matches");
        $test->ok(exists($rv->{$key}{file}) && $rv->{$key}{file} =~ /(?:^|[\/\\])$key$/
                                            && File::Spec->file_name_is_absolute($rv->{$key}{file}), "For $key: the file has been verified");
        $test->ok(exists($rv->{$key}{type}) && $rv->{$key}{type} =~ /^(?:module|autoload|data|shared)$/, "For $key: the type matches module|autoload|data|shared");

        if (exists($rv->{$key}{used_by})) {
            @used_by = sort @{$rv->{$key}{used_by}};
            if (scalar @used_by > 0) {
                $used_by_ok = 1;
                if (scalar @used_by > 1) {
                    for ($i=0; $i<$#used_by; $i++) {
                        if ($used_by[$i] eq $used_by[$i+1]) { # relies on @used_by being sorted earlier
                             $used_by_ok = 0;
                             last;
                        }
                    }
                }
                $test->ok($used_by_ok, "$key\'s used_by has no duplicates");

                $used_by_ok = 1;
                foreach my $used_by (@used_by) {
                    $used_by_ok &= exists($rv->{$used_by});
                }
                $test->ok($used_by_ok, "All entries in $key\'s used_by are themselves described in \$rv");

                # check corresponding uses field
                foreach my $used_by (@used_by) {
                    if (exists($rv->{$used_by}{uses})) {
                        $test->ok(scalar(grep { $_ eq $key } @{$rv->{$used_by}{uses}}), "\$rv contains a matching uses field for the used_by entry $used_by for key $key");
                    } else {
                        $test->ok(0, "\$rv contains a matching uses field for the used_by entry $used_by for key $key");
                    }
                }
            } else {
                $test->ok(0, "$key\'s used_by exists and isn't empty");
            }
        } else {
            $test->ok((grep {$_ eq $key} @input_keys) | ($key =~ m/Plugin/o), "used-by not defined so $key must be one of the input files or is a plugin");
        }

        if (exists($rv->{$key}{uses})) {
            # check corresponding used_by field
            foreach my $uses (@{$rv->{$key}{uses}}) {
                if (exists($rv->{$uses}{used_by})) {
                    $test->ok(scalar(grep { $_ eq $key } @{$rv->{$uses}{used_by}}), "\$rv contains a matching used_by field for the uses entry $uses for key $key");
                } else {
                    $test->ok(0, "\$rv contains a matching used_by field for the uses entry $uses for key $key");
                }
            }
         }
    }
}

sub compare_scandeps_rvs {
    my $rv_to_test = shift;
    my $rv_to_match = shift;
    my $array_ref = shift;
    my @input_keys = @$array_ref;

    my (@used_by_test, @used_by_match);
    my (@uses_test, @uses_match);
    my ($used_by_ok, $uses_ok);
    my ($compare_ok, $i);

    generic_scandeps_rv_test($rv_to_match, \@input_keys, []); # validate test data

    $test->ok(ref($rv_to_test) eq "HASH", "\$rv_to_test is a ref") or return;

    my @rv_to_match_keys = sort keys %{$rv_to_match};
    my @rv_to_test_keys  = sort keys %{$rv_to_test};
    $test->cmp_ok(scalar @rv_to_test_keys, '==', scalar @rv_to_match_keys, "Number of keys in \$rv_to_test == Number of keys in \$rv_to_match") or return;
    $compare_ok = 1;
    for ($i=0; $i<=$#rv_to_match_keys; $i++) {
        $compare_ok &= ($rv_to_match_keys[$i] eq $rv_to_test_keys[$i]);
    }
    $test->ok($compare_ok, "Keys in \$rv_to_test all eq keys in \$rv_to_match");

    foreach my $key (@rv_to_match_keys) {
        $test->ok(exists($rv_to_test->{$key}{key})  && $rv_to_test->{$key}{key}  eq $rv_to_match->{$key}{key}, "For $key: sub-key matches the expected");
        $test->ok(exists($rv_to_test->{$key}{file}) && $rv_to_test->{$key}{file} eq $rv_to_match->{$key}{file}, "For $key: file matches the expected");
        $test->ok(exists($rv_to_test->{$key}{type}) && $rv_to_test->{$key}{type} eq $rv_to_match->{$key}{type}, "For $key: type matches the expected");

        if (exists($rv_to_match->{$key}{used_by})) {
            $test->ok(exists($rv_to_test->{$key}{used_by}), "For $key: used_by exists as expected") or next;

            @used_by_test  = sort @{$rv_to_test->{$key}{used_by}}; # order isn't important
            @used_by_match = sort @{$rv_to_match->{$key}{used_by}}; # order isn't important   
            $test->cmp_ok(scalar @used_by_test, '==', scalar @used_by_match, "For $key: number of used_by in \$rv_to_test == Number of used_by in \$rv_to_match") or next;

            $used_by_ok = 1;
            for ($i=0; $i < scalar @used_by_match; $i++) {
                $used_by_ok &= ($used_by_match[$i] eq $used_by_test[$i]);
            }
            $test->ok($used_by_ok, "For $key: used_by in \$rv_to_test all eq used_by in \$rv_to_match");
        }

        if (exists($rv_to_match->{$key}{uses})) {
            $test->ok(exists($rv_to_test->{$key}{uses}), "For $key: uses exists as expected") or next;

            @uses_test  = sort @{$rv_to_test->{$key}{uses}}; # order isn't important
            @uses_match = sort @{$rv_to_match->{$key}{uses}}; # order isn't important
            $test->cmp_ok(scalar @uses_test, '==', scalar @uses_match, "For $key: number of uses in \$rv_to_test == Number of uses in \$rv_to_match") or next;

            $uses_ok = 1;
            for ($i=0; $i < scalar @uses_match; $i++) {
                $uses_ok &= ($uses_match[$i] eq $uses_test[$i]);
            }
            $test->ok($uses_ok, "For $key: uses in \$rv_to_test all eq uses in \$rv_to_match");
        }
    }
}

1;

sub generic_abs_path {
  my $file = shift @_;
  $file = File::Spec->rel2abs($file);
  $file =~ s|\\|\/|go;
  return $file;
}

# Marks the end of any code. Any symbols after this are ignored. Use for documentation
__END__
