use strict ;
use Test ;

use Inline(
	Java => 'DATA'
) ;

use Inline::Java qw(cast);

BEGIN {
	plan(tests => 55) ;
}


my $t = new types5() ;

{
	ok(++($t->_byte([12, 34, 56])->[0]) == 124) ;
	ok(eq_array($t->_Byte([12, 34, 56]), [12, 34, 56])) ;
	ok(++($t->_short([12, 34, 56])->[0]) == 124) ;
	ok(eq_array($t->_Short([12, 34, 56]), [12, 34, 56])) ;
	ok(++($t->_int([12, 34, 56])->[0]) == 124) ;
	ok(eq_array($t->_Integer([12, 34, 56]), [12, 34, 56])) ;
	ok(++($t->_long([12, 34, 56])->[0]) == 124) ;
	ok(eq_array($t->_Long([12, 34, 56]), [12, 34, 56])) ;
	ok(++($t->_float([12.34, 5.6, 7])->[0]) == 124.456) ;
	ok(eq_array($t->_Float([12.34, 5.6, 7]), [12.34, 5.6, 7])) ;
	ok(++($t->_double([12.34, 5.6, 7])->[0]) == 124.456) ;
	ok(eq_array($t->_Double([12.34, 5.6, 7]), [12.34, 5.6, 7])) ;
	ok($t->_boolean([1, 0, "tree"])->[0]) ;
	ok($t->_Boolean([1, 0])->[0]) ;
	ok(! $t->_Boolean([1, 0])->[1]) ;
	ok($t->_char(['a', 'b', 'c'])->[0], "A") ;
	ok(eq_array($t->_Character(['a', 'b', 'c']), ['a', 'b', 'c'], 1)) ;
	my $a = $t->_String(["bla", "ble", "bli"]) ;
	ok($a->[0], "STRING") ;
	$a->[1] = "wazoo" ;
	ok($a->[1], "wazoo") ;
	ok($t->_StringBuffer(["bla", "ble", "bli"])->[0], "STRINGBUFFER") ;
	
	ok($t->_Object(undef), undef) ;
	$a = $t->_Object([1, "two", $t]) ;
	ok($a->[0], "1") ;
	ok($a->[1], "two") ;
	my $a2 = cast('types5', $a->[2]);
	ok(UNIVERSAL::isa($a2, "main::types5")) ;
	ok($a2->{data}->[1], "a") ;
	$a2->{data} = ["1", "2"] ;
	ok($a2->{data}->[1], 2) ;

	$a->[0]++ ;
	ok($a->[0], "2") ;

	$a->[1] = "three" ;
	ok($a->[1], "three") ;

	$a->[2] = "string" ;
	ok($a->[2], "string") ;

	$a->[0] = $t ;
	ok(UNIVERSAL::isa(cast('types5', $a->[0]), "main::types5")) ;
	
	# Try some multidimensional arrays.
	$a = $t->_StringString([
		["00", "01"],
		["10", "11"]
	]) ;
	
	# Try some incomplete multidimensional arrays.
	$a = $t->_StringString([
		[undef, "01", "02"],
		[undef, "11"],
		undef,
	]) ;
	ok($a->[1]->[0], undef) ;
	
	
	my $b = $a->[1] ;
	ok($t->_String($b)->[0], "STRING") ;
	
	# Arrays of other arrays
	$a = $t->_StringString([
		$a->[0],
	]) ;
	ok($a->[0]->[2], "02") ;
	
	# This is one of the things that won't work. 
	# Try passing an array as an Object.
	eval {$t->_o(["a", "b", "c"])} ; ok($@, qr/Can't create Java array/) ;
	ok($t->_o(Inline::Java::coerce(
		"java.lang.Object", 
		["a", "b", "c"], 
		"[Ljava.lang.String;"))->[0], "a") ;
	$t->{o} = Inline::Java::coerce(
		"java.lang.Object", 
		["a", "b", "c"], 
		"[Ljava.lang.String;") ;
	ok($t->{o}->[0], "a") ;
	$t->{o} = $t->{i} ;
	ok($t->{o}->[0], "1") ;
	
	# Mixed types
	eval {$t->_int(["3", "3456", "cat"])} ; ok($@, qr/Can't convert/) ;
	ok($t->_Object(["3", "3456", "cat"])->[2], 'cat') ; 
	
	# Badly constructed array
	eval {$t->_int(["3", [], "cat"])} ; ok($@, qr/Java array contains mixed types/) ;
	eval {$t->_StringString([["3"], "string"])} ; ok($@, qr/Java array contains mixed types/) ;
	
	# Invalid operations on arrays.
	eval {@{$b} = ()} ; ok($@, qr/Operation CLEAR/) ;
	eval {pop @{$b}} ; ok($@, qr/Operation POP/) ;
	eval {shift @{$b}} ; ok($@, qr/Operation SHIFT/) ;
	eval {splice(@{$b}, 0, 1)} ; ok($@, qr/Operation SPLICE/) ;
	eval {$b->[10] = 5} ; ok($@, qr/out of bounds/) ;

	# Cool stuff on arrays
	$a = $t->_byte([12, 34, 56]) ;
	ok(scalar(@{$a}), 3) ;
	foreach my $e (@{$a}){
		ok($e =~ /^(123|34|56)$/) ;
	}

	# Zero length arrays
	$a = $t->_Byte([]) ;
	ok(scalar(@$a), 0) ;
	$a = $t->_StringString([[], []]) ;
	ok(scalar(@{$a}), 2) ;
	ok(scalar(@{$a->[0]}), 0) ;
	ok(scalar(@{$a->[1]}), 0) ;
}

ok($t->__get_private()->{proto}->ObjectCount(), 1) ;


sub eq_array {
	my $a1 = shift ;
	my $a2 = shift ;
	my $eq = shift || 0 ;

	if (scalar(@{$a1}) != scalar(@{$a2})){
		return 0 ;
	}

	my $ok = 1 ;
	for (0..$#{$a1}){
		if ($eq){
			$ok = ($a1->[$_] eq $a2->[$_]) ;
		}
		else{
			$ok = ($a1->[$_] == $a2->[$_]) ;
		}
		last unless $ok ;
	}
	
	return $ok ;
}


__END__

__Java__


class types5 {
	public Object o ;
	public int i[] = {1, 2, 3} ;
	public String data[] = {"d", "a", "t", "a"} ;
	public types5(){
	}

	public byte[] _byte(byte b[]){
		b[0] = (byte)123 ;
		return b ;
	}

	public Byte[] _Byte(Byte b[]){
		return b ;
	}

	public short[] _short(short s[]){
		s[0] = (short)123 ;
		return s ;
	}

	public Short[] _Short(Short s[]){
		return s ;
	}

	public int[] _int(int i[]){
		i[0] = 123 ;
		return i ;
	}

	public Integer[] _Integer(Integer i[]){
		return i ;
	}

	public long[] _long(long l[]){
		l[0] = 123 ;
		return l ;
	}

	public Long[] _Long(Long l[]){
		return l ;
	}

	public float[] _float(float f[]){
		f[0] = (float)123.456 ;
		return f ;
	}

	public Float[] _Float(Float f[]){
		return f ;
	}

	public double[] _double(double d[]){
		d[0] = 123.456 ;
		return d ;
	}

	public Double[] _Double(Double d[]){
		return d ;
	}

	public boolean[] _boolean(boolean b[]){
		b[0] = true ;
		return b ;
	}

	public Boolean[] _Boolean(Boolean b[]){
		return b ;
	}

	public char[] _char(char c[]){
		c[0] = 'A' ;
		return c ;
	}

	public Character[] _Character(Character c[]){
		return c ;
	}

	public String[] _String(String s[]){
		s[0] = "STRING" ;
		return s ;
	}

	public String[][] _StringString(String s[][]){
		return s ;
	}

	public StringBuffer[] _StringBuffer(StringBuffer sb[]){
		sb[0] = new StringBuffer("STRINGBUFFER") ;
		return sb ;
	}

	public Object[] _Object(Object o[]){
		return o ;
	}

	public Object _o(Object o){
		return o ;
	}
}