# -*- mode: python -*-
# Copyright (C) 2004, 2005, 2006 Mekensleep
#
# Mekensleep
# 24 rue vieille du temple
# 75004 Paris
#       licensing@mekensleep.com
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
#
# Authors:
#  Loic Dachary <loic@gnu.org>
#

import sys, os
sys.path.insert(0, "@top_srcdir@")
sys.path.insert(0, "..")

from pprint import pprint
from string import split
import unittest
from pokerengine.pokergame import PokerGameServer
from pokerengine import pokergame

class PokerPredefinedDecks:
    def __init__(self, decks):
        self.decks = decks
        self.index = 0
        
    def shuffle(self, deck):
        deck[:] = self.decks[self.index][:]
        self.index += 1
        if self.index >= len(self.decks):
            self.index = 0

class TestMuck(unittest.TestCase):

    def setUp(self):
        self.game = PokerGameServer("poker.%s.xml", [ "../conf", "@top_srcdir@/conf" ])
        self.game.verbose = int(os.environ.get('VERBOSE_T', 3))
        self.game.setVariant("holdem")
        self.game.setBettingStructure("2-4-limit")
        predefined_decks = [
                    "8d 2h 2c 8c 4c Kc Ad 9d Ts Jd 5h Tc 4d 9h 8h 7h 9c 2s 3c Kd 5s Td 5d Th 3s Kh Js Qh 7d 2d 3d 9s Qd Ac Jh Jc Qc 6c 7s Ks 5c 4h 7c 4s Qs 6s 6d Ah 6d 3h 8s As", # distributed from the end
            ]
        self.game.shuffler = PokerPredefinedDecks(map(lambda deck: self.game.eval.string2card(split(deck)), predefined_decks))

    def tearDown(self):
        del self.game

    def log(self, string):
        print string

    def make_new_bot(self, serial, seat):
        game = self.game
        self.failUnless(game.addPlayer(serial, seat))
        self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
        self.failUnless(game.sit(serial))
        game.botPlayer(serial)
        game.autoMuck(serial, pokergame.AUTO_MUCK_NEVER)

    def make_new_player(self, serial, seat):
        game = self.game
        self.failUnless(game.addPlayer(serial, seat))
        self.failUnless(game.payBuyIn(serial, game.bestBuyIn()))
        self.failUnless(game.sit(serial))
        self.game.autoBlindAnte(serial)

    def check_blinds(self, descriptions):
        players = self.game.playersAll()
        players.sort(lambda a,b: int(a.seat - b.seat))
        fail = False
        for player in players:
            (blind, missed, wait) = descriptions.pop(0)
            if(blind != player.blind or missed != player.missed_blind or wait != player.wait_for):
                print "check_blinds FAILED actual %s != from expected %s" % ( (player.blind, player.missed_blind, player.wait_for), (blind, missed, wait) )
                fail = True
            else:
                print "check_blinds %s == %s" % ( (player.blind, player.missed_blind, player.wait_for), (blind, missed, wait) )
        if fail:
            self.fail()
            
            
    def test1(self):
        """
          won fold, auto_muck always
        """
        for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
            self.make_new_player(serial, seat)
        self.game.beginTurn(1)
        self.game.fold(4)
        self.game.fold(1)
        self.game.fold(2)
        self.assertEqual(len(self.game.winners), 1)
        self.assertEqual(self.game.winners[0], 3)
        self.failUnless(self.game.isWinnerBecauseFold())
        self.failUnless(self.game.getPlayer(3).hand.areHidden())

    def test2(self):
        """
          won fold, auto_muck lose, decided to muck
        """
        for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
            self.make_new_player(serial, seat)
            
        self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
        self.game.beginTurn(1)
        self.game.fold(4)
        self.game.fold(1)
        self.game.fold(2)
        self.assertEqual(len(self.game.winners), 1)
        self.assertEqual(self.game.winners[0], 3)
        self.failUnless(self.game.isWinnerBecauseFold())
        self.assertEqual(self.game.muckable_serials, [3])
        self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
        self.game.muck(serial = 3, want_to_muck = True)
        self.failUnless(self.game.getPlayer(3).hand.areHidden())
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)

    def test3(self):
        """
          won fold, auto_muck lose, decided not to muck (ie show)
        """
        for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
            self.make_new_player(serial, seat)
            
        self.game.autoMuck(3, pokergame.AUTO_MUCK_LOSE)
        self.game.beginTurn(1)
        self.game.fold(4)
        self.game.fold(1)
        self.game.fold(2)
        self.assertEqual(len(self.game.winners), 1)
        self.assertEqual(self.game.winners[0], 3)
        self.failUnless(self.game.isWinnerBecauseFold())
        self.assertEqual(self.game.muckable_serials, [3])
        self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
        self.game.muck(serial = 3, want_to_muck = False)
        self.failUnless(self.game.getPlayer(3).hand.areVisible())
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)

    def test4(self):
        """
          fake deck
          player p2 wins against p1, p1 is muckable, auto_muck_never, p1 mucks
        """
        for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
            self.make_new_bot(serial, seat)
                    
        self.game.beginTurn(1)
        self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
        self.game.muck(serial = 1, want_to_muck = True)
        self.assertEqual(len(self.game.winners), 1)
        self.assertEqual(self.game.winners[0], 2)
        self.failUnless(self.game.getPlayer(1).hand.areHidden())
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)

    def test5(self):
        """
          fake deck
          player p2 wins against p1, p1 is muckable, auto_muck_never, p1 does not muck
        """
        for (serial, seat) in ((1, 0), (2, 1), (3, 2), (4, 3)):
            self.make_new_bot(serial, seat)
                    
        self.game.beginTurn(1)
        self.assertEqual(self.game.state, pokergame.GAME_STATE_MUCK)
        self.game.muck(serial = 1, want_to_muck = False)
        self.assertEqual(len(self.game.winners), 1)
        self.assertEqual(self.game.winners[0], 2)
        self.failUnless(self.game.getPlayer(1).hand.areVisible())
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)

    def test6(self):
        """
          game canceled because blind not payed, player p2 get her/his blind back
        """
        for (serial, seat) in ((1, 0), (2, 1)):
            self.make_new_player(serial, seat)
            self.game.noAutoBlindAnte(serial)
                    
        self.game.beginTurn(1)
        self.game.blind(2)
        self.game.sitOut(1)
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
        self.assertEqual(len(self.game.winners), 0)

    def test0(self):
        """
          game canceled explicitly, player p2 get her/his blind back
        """
        for (serial, seat) in ((1, 0), (2, 1)):
            self.make_new_player(serial, seat)
            self.game.noAutoBlindAnte(serial)
                    
        self.game.beginTurn(1)
        self.game.blind(2)
        self.game.is_directing = False
        self.game.sitOut(1)
        self.game.canceled(2, self.game.smallBlind())
        self.assertEqual(self.game.state, pokergame.GAME_STATE_END)
        self.assertEqual(len(self.game.winners), 0)

def run():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(TestMuck))
    verbosity = int(os.environ.get('VERBOSE_T', 2))
    unittest.TextTestRunner(verbosity=verbosity).run(suite)
    
if __name__ == '__main__':
    run()

# Interpreted by emacs
# Local Variables:
# compile-command: "( cd .. ; ./config.status tests/muck.py ) ; ( cd ../tests ; make TESTS='muck.py' check )"
# End: