import rps.Rps;

class TestConversions extends haxe.unit.TestCase {
    public function testLetter() 
    {
	assertEquals( 'r', Rps.letter(ROCK) );
	assertEquals( 'p', Rps.letter(PAPER) );
	assertEquals( 's', Rps.letter(SCISSORS) );
    }
    public function testNumber()
    {
	assertEquals( 0, Rps.number(ROCK) );
	assertEquals( 1, Rps.number(PAPER) );
	assertEquals( 2, Rps.number(SCISSORS) );
    }
    public function testToken()
    {
	assertEquals( ROCK, Rps.token(0) );
	assertEquals( PAPER, Rps.token(1) );
	assertEquals( SCISSORS, Rps.token(2) );

	assertEquals( ROCK, Rps.token(3) );
	assertEquals( PAPER, Rps.token(4) );
	assertEquals( SCISSORS, Rps.token(5) );
    }

    public function testString()
    {
	assertEquals( "rock", Rps.string(ROCK) );
	assertEquals( "paper", Rps.string(PAPER) );
	assertEquals( "scissors", Rps.string(SCISSORS) );
    }
}

class TestGameLogic extends haxe.unit.TestCase {
    public function testBeat() 
    {
	assertEquals( PAPER, Rps.beat(ROCK) );
	assertEquals( SCISSORS, Rps.beat(PAPER) );
	assertEquals( ROCK, Rps.beat(SCISSORS) );
    }
    public function testJudge()
    {
	assertEquals( TIE, GameStats.judge(ROCK, ROCK) );
	assertEquals( TIE, GameStats.judge(PAPER, PAPER) );
	assertEquals( TIE, GameStats.judge(SCISSORS, SCISSORS) );

	assertEquals( I_WON, GameStats.judge(ROCK, SCISSORS) );
	assertEquals( I_WON, GameStats.judge(PAPER, ROCK) );
	assertEquals( I_WON, GameStats.judge(SCISSORS, PAPER) );
	
	assertEquals( HE_WON, GameStats.judge(SCISSORS, ROCK) );
	assertEquals( HE_WON, GameStats.judge(ROCK, PAPER) );
	assertEquals( HE_WON, GameStats.judge(PAPER, SCISSORS) );
    }
    public function testInput()
    {
	var stats = new GameStats();
	var me = this;
	var assertGS = function (i, t, h) {
	    me.assertEquals(i, stats.i_won);
	    me.assertEquals(t, stats.ties);
	    me.assertEquals(h, stats.he_won);
	}

	assertGS(0,0,0);

	stats.input(ROCK, ROCK);
	assertGS(0,1,0);
	stats.input(PAPER, PAPER);
	assertGS(0,2,0);
	stats.input(SCISSORS, SCISSORS);
	assertGS(0,3,0);
	
	stats.input(ROCK, PAPER);
	assertGS(0,3,1);
	stats.input(PAPER, SCISSORS);
	assertGS(0,3,2);
	stats.input(SCISSORS, ROCK);
	assertGS(0,3,3);

	stats.input(PAPER, ROCK);
	assertGS(1,3,3);
	stats.input(ROCK, SCISSORS);
	assertGS(2,3,3);
	stats.input(SCISSORS, PAPER);
	assertGS(3,3,3);
    }
}

class TestPrediction extends haxe.unit.TestCase {
    public function testStat()
    {
	var stat = new Stat();
	assertEquals(0, stat.rock);
	assertEquals(0, stat.paper);
	assertEquals(0, stat.scissors);

	stat.add(ROCK);
	assertEquals(1, stat.rock);
	stat.add(PAPER);
	assertEquals(1, stat.paper);
	stat.add(SCISSORS);
	assertEquals(1, stat.scissors);

	var predict = function (r,p,s) {
	    var stat = new Stat();
	    stat.rock = r;
	    stat.paper = p;
	    stat.scissors = s;
	    return stat.predict();
	}

	assertEquals( ROCK,	predict(1,0,0) );
	assertEquals( PAPER,	predict(0,1,0) );
	assertEquals( SCISSORS, predict(0,0,1) );

	var is_in = function (array : Array<Token>, elem) {
	    for (el in array) 
		if (el == elem)
		    return true;
	    return false;
	}
	assertTrue(is_in([ROCK, PAPER], predict(1, 1, 0) ) );
	assertTrue(is_in([ROCK, SCISSORS], predict(1, 0, 1) ) );
	assertTrue(is_in([PAPER, SCISSORS], predict(0, 1, 1) ) );
	assertEquals( null, predict(1, 1, 1) );
    }
    public function testPrediction()
    {
	var game = new Rps();
	var stat : Stat;

	game.game_round(ROCK);
	game.game_round(PAPER);
	game.game_round(SCISSORS);
	assertEquals( 'rps', game.short );

	game.game_round(ROCK);
	stat = game.long.get('rps');
	assertEquals( 1, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('ps');
	assertEquals( 1, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('s');
	assertEquals( 1, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('');
	assertEquals( 2, stat.rock );
	assertEquals( 1, stat.paper );
	assertEquals( 1, stat.scissors );
	
	assertEquals( 2/4, stat.freq(ROCK) );
	assertEquals( 1/4, stat.freq(PAPER) );
	assertEquals( 1/4, stat.freq(SCISSORS) );

	game.game_round(PAPER);
	stat = game.long.get('psr');
	assertEquals( 0, stat.rock );
	assertEquals( 1, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('sr');
	assertEquals( 0, stat.rock );
	assertEquals( 1, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('r');
	assertEquals( 0, stat.rock );
	assertEquals( 2, stat.paper );
	assertEquals( 0, stat.scissors );
	stat = game.long.get('');
	assertEquals( 2, stat.rock );
	assertEquals( 2, stat.paper );
	assertEquals( 1, stat.scissors );
	
	assertEquals( 2/5, stat.freq(ROCK) );
	assertEquals( 2/5, stat.freq(PAPER) );
	assertEquals( 1/5, stat.freq(SCISSORS) );
	
	game.game_round(SCISSORS);
	stat = game.long.get('srp');
	assertEquals( 0, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 1, stat.scissors );
	stat = game.long.get('rp');
	assertEquals( 0, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 2, stat.scissors );
	stat = game.long.get('p');
	assertEquals( 0, stat.rock );
	assertEquals( 0, stat.paper );
	assertEquals( 2, stat.scissors );
	stat = game.long.get('');
	assertEquals( 2, stat.rock );
	assertEquals( 2, stat.paper );
	assertEquals( 2, stat.scissors );

	assertEquals( 2/6, stat.freq(ROCK) );
	assertEquals( 2/6, stat.freq(PAPER) );
	assertEquals( 2/6, stat.freq(SCISSORS) );

	/* we now have enough knowledge to predict the following sequence */
	var pre_wons = game.stats.i_won;
	for(i in 0...10) {
	    game.game_round(ROCK);
	    game.game_round(PAPER);
	    game.game_round(SCISSORS);
	}
	assertEquals( pre_wons+30, game.stats.i_won );
    }
}

class RpsTest {
    static function main() {
	var r = new haxe.unit.TestRunner();
	r.add(new TestConversions());
	r.add(new TestGameLogic());
	r.add(new TestPrediction());

	r.run();
    }
}