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

use Test::More 'no_plan';
use strict;

BEGIN { 
    use_ok('CGI');
    use_ok('Data::FormValidator::Constraints::Upload') 
};

my $cgi_simple_test = 0;

eval {
	require CGI::Simple;
};

if ($@) { 
	diag "Skipping CGI::Simple Tests";
} 
else {
	diag "Adding CGI::Simple tests";		
	$cgi_simple_test = 1;
} 

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

%ENV = (
	%ENV,
          'SCRIPT_NAME' => '/test.cgi',
          'SERVER_NAME' => 'perl.org',
          'HTTP_CONNECTION' => 'TE, close',
          'REQUEST_METHOD' => 'POST',
          'SCRIPT_URI' => 'http://www.perl.org/test.cgi',
          'CONTENT_LENGTH' => 3129,
          'SCRIPT_FILENAME' => '/home/usr/test.cgi',
          'SERVER_SOFTWARE' => 'Apache/1.3.27 (Unix) ',
          'HTTP_TE' => 'deflate,gzip;q=0.3',
          'QUERY_STRING' => '',
          'REMOTE_PORT' => '1855',
          'HTTP_USER_AGENT' => 'Mozilla/5.0 (compatible; Konqueror/2.1.1; X11)',
          'SERVER_PORT' => '80',
          'REMOTE_ADDR' => '127.0.0.1',
          'CONTENT_TYPE' => 'multipart/form-data; boundary=xYzZY',
          'SERVER_PROTOCOL' => 'HTTP/1.1',
          'PATH' => '/usr/local/bin:/usr/bin:/bin',
          'REQUEST_URI' => '/test.cgi',
          'GATEWAY_INTERFACE' => 'CGI/1.1',
          'SCRIPT_URL' => '/test.cgi',
          'SERVER_ADDR' => '127.0.0.1',
          'DOCUMENT_ROOT' => '/home/develop',
          'HTTP_HOST' => 'www.perl.org'
);

diag "testing with CGI.pm version: $CGI::VERSION";
diag "testing with CGI::Simple version: $CGI::Simple::VERSION" if $cgi_simple_test;

## testing vars
my $cgi_pm_q;
my $cgi_simple_q;

## setup input (need cleaner way)
open(IN,'<t/upload_post_text.txt') || die 'missing test file';
binmode(IN);

*STDIN = *IN;
$cgi_pm_q = CGI->new;
close(IN);

## setup CGI::Simple testing
if ($cgi_simple_test) {
	open(IN,'<t/upload_post_text.txt') || die 'missing test file';
	binmode(IN);
	*STDIN = *IN;
	## annoying context
	$CGI::Simple::DISABLE_UPLOADS = 0;
    # Repeat to avoid warning..
	$CGI::Simple::DISABLE_UPLOADS = 0;
	$cgi_simple_q = CGI::Simple->new();
	close(IN);
}

use Data::FormValidator;
my $default = {
		required=>[qw/hello_world does_not_exist_gif 100x100_gif 300x300_gif/],
		validator_packages=> 'Data::FormValidator::Constraints::Upload',
		constraints => {
			'hello_world' => {
				constraint_method => 'file_format',
				params=>[],
			},
			'does_not_exist_gif' => {
				constraint_method => 'file_format',
				params=>[],
			},
			'100x100_gif' => [
				{
					constraint_method => 'file_format',
					params=>[],
				},
				{
					constraint_method => 'file_max_bytes',
					params=>[],
				}
			],
			'300x300_gif' => {
				constraint_method => 'file_max_bytes',
				params => [\100],
			},
		},
	};

## same set of tests with each one (does this work?)
for my $q ($cgi_pm_q, $cgi_simple_q) {
    next unless $q;
	diag "Running tests with ", ref $q;

	my $dfv = Data::FormValidator->new({ default => $default });
	my $results;
	eval { $results = $dfv->check($q, 'default'); };
    is($@,'','survived eval');

	my $valid   = $results->valid;
	my $invalid = $results->invalid; # as hash ref
	my @invalids = $results->invalid;
	my $missing = $results->missing;


	# Test to make sure hello world fails because it is the wrong type
	ok((grep {m/hello_world/} @invalids), 'expect format failure');

	# should fail on empty/missing source file data
	ok((grep {m/does_not_exist_gif/} @invalids), 'expect non-existent failure');

	ok(
        (exists $valid->{'100x100_gif'}, "valid")
        , 'Make sure 100x100 passes because it is the right type and size'
    );

	my $meta = $results->meta('100x100_gif');
	is(ref $meta, 'HASH', 'meta() returns hash ref');

	ok($meta->{extension}, 'setting extension meta data');
	ok($meta->{mime_type}, 'setting mime_type meta data');

	ok((grep {m/300x300/} @invalids)
        , '300x300 should fail because it exceeds max_bytes');

	ok(($results->meta('100x100_gif')->{bytes} > 0), (ref $q).': setting bytes meta data') ;


	# Revalidate to usefully re-use the same fields
	my $profile_2  = {
	required=>[qw/hello_world 100x100_gif 300x300_gif/],
	validator_packages=> 'Data::FormValidator::Constraints::Upload',
	constraints => {
		'100x100_gif' => {
			constraint_method => 'image_max_dimensions',
			params => [\200,\200],
		},
		'300x300_gif' => {
			constraint_method => 'image_max_dimensions',
			params => [\200,\200],
		},
	},
	};

	$dfv = Data::FormValidator->new({ profile_2 => $profile_2});
	eval {
	$results = $dfv->check($q, 'profile_2');
	};
	ok(not $@) or diag $@;

	$valid   = $results->valid;
	$invalid = $results->invalid; # as hash ref
	@invalids = $results->invalid;
	$missing = $results->missing;

	ok(exists $valid->{'100x100_gif'}, 'expecting success with max_dimensions');
	ok((grep /300x300/, @invalids), 'expecting failure with max_dimensions');

	ok( $results->meta('100x100_gif')->{width} > 0, 'setting width as meta data');
	ok( $results->meta('100x100_gif')->{width} > 0, 'setting height as meta data');

	# Now test trying constraint_regxep_map
	my $profile_3  = {
	required=>[qw/hello_world 100x100_gif 300x300_gif/],
	validator_packages=> 'Data::FormValidator::Constraints::Upload',
	constraint_regexp_map => {
		'/[13]00x[13]00_gif/'	=> {
			constraint_method => 'image_max_dimensions',
			params => [\200,\200],
		}
	}
	};

	$dfv = Data::FormValidator->new({ profile_3 => $profile_3});
	($valid,$missing,$invalid) = $dfv->validate($q, 'profile_3');
	
	ok(exists $valid->{'100x100_gif'}, 'expecting success with max_dimensions using constraint_regexp_map');
	ok((grep {m/300x300/} @$invalid), 'expecting failure with max_dimensions using constraint_regexp_map');

	## min test
	my $profile_4  = {
		required=>[qw/hello_world 100x100_gif 300x300_gif/],
		validator_packages=> 'Data::FormValidator::Constraints::Upload',
		constraints => {
			'100x100_gif' => {
				constraint_method => 'image_min_dimensions',
				params => [\200,\200],
			},
			'300x300_gif' => {
				constraint_method => 'image_min_dimensions',
				params => [\200,\200],
			},
		},
	};

	$dfv = Data::FormValidator->new({ profile_4 => $profile_4});
	eval {
		$results = $dfv->check($q, 'profile_4');
	};
	ok(not $@) or diag $@;
	
	$valid   = $results->valid;
	$invalid = $results->invalid; # as hash ref
	@invalids = $results->invalid;
	$missing = $results->missing;
	
	ok(exists $valid->{'300x300_gif'}, 'expecting success with min_dimensions');
	ok((grep /100x100/, @invalids), 'expecting failure with min_dimensions');

	## file type tests
	## with new interface
	{
		use Data::FormValidator::Constraints::Upload qw(file_format);
	
		my $profile_5  = {
			required=> [qw/hello_world 100x100_gif 300x300_gif/],
			constraint_methods => {
				'100x100_gif' => [ file_format( mime_types => [ qw(image/gif) ] ) ],
				'300x300_gif' => [ file_format( mime_types => [ qw(image/png) ] ) ] 
			}
		};
	
		$dfv = Data::FormValidator->new({ profile_5 => $profile_5});
		eval {
			$results = $dfv->check($q, 'profile_5');
		};

		ok(not $@) or diag $@;

		$valid   = $results->valid;
		$invalid = $results->invalid; # as hash ref
		@invalids = $results->invalid;
		$missing = $results->missing;

		ok(exists $valid->{'100x100_gif'}, 'expecting success with mime_type');
		ok((grep /300x300/, @invalids), 'expecting failure with mime_type');
	} 

	## range checks with new format
	{
		use Data::FormValidator::Constraints::Upload qw(image_max_dimensions image_min_dimensions);
		my $profile_6 = {
			required => [ qw/hello_world 100x100_gif 300x300_gif/ ],
			constraint_methods => {
				'100x100_gif' => [ 
					image_max_dimensions(200, 200),
					image_min_dimensions(110, 100) 
				],
				'300x300_gif' => [
					image_max_dimensions(400, 400),
					image_min_dimensions(245, 100) 
				]
			}
		};

		$dfv = Data::FormValidator->new({ profile_6 => $profile_6});
		eval {
			$results = $dfv->check($q, 'profile_6');
		};
        is($@,'','survived eval');

		$valid    = $results->valid;
		$invalid  = $results->invalid; # as hash ref
		@invalids = $results->invalid;
		$missing  = $results->missing;
	
		ok((grep /100x100/, @invalids), 'expecting failure with size range');
		ok(exists $valid->{'300x300_gif'}, 'expecting success with size range');

	}

} ## end of for loop

## end of tests