tits

import unittest
import random
import itertools

class Deck:

    def __init__(self):
        self.deck = self.build()

    def build(self):
        deck = []
        for x in range(2,15):
            for y in ('c', 'd', 'h', 's'):
                if x == 10:
                    z = 'T'
                elif x == 11:
                    z = 'J'
                elif x == 12:
                    z = 'Q'
                elif x == 13:
                    z = 'K'
                elif x == 14:
                    z = 'A'
                else: z = str(x)
                deck.append([z+y,x,y])
        return deck

class Dealer:
    deck = Deck().deck
 #   def __init__(self):
#        self.deck = Deck()
    def shuffle(self):
       random.shuffle(self.deck)

    def dealflop(self):
        for x in range(3):
            self.board.append(self.deck.pop())

    def dealin(self, player):
        self.players.append(player)

    def deal(self):
        for player in self.players:
            player.hand.append(self.deck.pop())
            player.hand.append(self.deck.pop())

    def who(self):
        for player in self.players:
            print player.name
            print player
            player.hand.append(self.deck.pop())
            print player.hand
         #   player.hand.append(random.randint(2,200)
            #print player.hand

#cards is an a list of 2 cards
    def evalpair(self, cards, board):
        sevencards = [x[1] for x in board]
        for card in cards:
            sevencards.append(card[1])
#        print 'sevencards:'
#        print sevencards
        uniques = set(sevencards)
        paircount = {}
        for x in list(uniques):
            paircount[x] = sevencards.count(x)
#        print uniques
#        print paircount
        high = [k for k, v in paircount.iteritems() if v == 1]
        pair = [k for k, v in paircount.iteritems() if v == 2]
        trips = [k for k, v in paircount.iteritems() if v == 3]
        quads = [k for k, v in paircount.iteritems() if v == 4]
        if len(pair) == 3:
            pair.sort(reverse=True)
            high.append(pair[2])
            pair = pair[:2]
        print 'pair array'
        print pair
        return [high, pair, trips, quads]

#range takes list of tags and returns list of hands of full cards
    def range(self, cards):
        rangedeck = [x for x in self.deck if x[0] in cards]
        return rangedeck

#takes list of list of tags and returns list of list of full cards
    def rangehands(self, handlist):
        hands = []
        for hand in handlist:
            hands.append(self.range(hand))
        return hands

#cardremoval builds deck without certain cards, cards can be array or array of arrays
    def cardremoval(self, cards):
        if type(cards[0]) == list:
            cards = itertools.chain(*cards)
            cards = list(cards)
        print 'im a flatcard list'
        print cards
        newdeck = [x for x in self.deck if x[0] not in cards]
        return newdeck

#hands is an array of two card tags, first convert to array of full card lists then eval
#board is a list of tags
    def flopzilla(self, hands, board):
        results = []
        hands = self.rangehands(hands)
        print "fullhands"
        print hands
        board = self.range(board)
        print board
        print 'board'
        for hand in hands:
            x = self.evalpair(hand, board)
            results.append(x[1])
#        dead = [x[0] for x in board]
#        for card in cards:
#            dead.append(card[0])
#            dead.append(card[1])
#        newdeck = self.cardremoval(dead)
        return results

    def allcards(self):
        for x in self.deck:
            print x

class Player:
    def __init__(self, name="dud"):
        self.name = name
        self.hand = []


class TestPoker(unittest.TestCase):

    def setUp(self):
        self.dealer = Dealer()
        self.jake = Player()
        self.joe = Player()

    def test_count(self):
        self.assertEqual(len(self.dealer.deck), 52)

    def test_shuffle(self):
        self.deck = self.dealer.deck
        self.val = [self.deck[0], self.deck[1]]
        self.dealer.shuffle()
        self.assertNotEqual(self.val, [self.deck[0], self.deck[1]])

    def test_dealflop(self):
        self.dealer.dealflop()
        self.assertEqual(len(self.dealer.board), 3)

    def test_deal(self):
        self.dealer.dealin(self.jake)
        self.dealer.dealin(self.joe)
        self.dealer.deal()
        self.assertEqual(len(self.dealer.deck), 48)
        self.assertEqual(len(self.jake.hand), 2)
        self.assertEqual(len(self.joe.hand), 2)

    def test_dealin(self):
#greg- teardown isnt run betweeen test_methods, its before whole class i think
      #  self.dealer.dealin(self.jake)
      #  self.dealer.dealin(self.joe)
        self.assertEqual(len(self.dealer.players), 2)

    def test_range(self):
        cards = ['As', '6d', '7c', '9h']
        full = [['As', 14, 's'], ['6d', 6, 'd']]
        newrange = self.dealer.range(cards)
#        self.assertEqual(len(newrange), 2)
 #       self.assertIn(full[0], newrange)
  #      self.assertIn(full[1], newrange)
        print newrange
#
    def test_CardRemoval(self):
        remove = ['As', '6d']
        x = self.dealer.cardremoval(remove)
        self.assertNotIn(remove[0], x)
        self.assertNotIn(remove[1], x)

    def tearDown(self):
        self.dealer.players = []
        self.dealer = None
        self.jake = None
        self.joe = None


def db():
    guy = Dealer()
    guy.shuffle()
#    joe = Player('joe')
#    jake = Player('jake')
#    guy.dealin(joe)
#    guy.dealin(jake)
#    guy.who()
#    guy.deal()
#    guy.dealflop()
#    print 'player 1 ' , guy.players[0].hand
#    print 'player 2 ' , guy.players[1].hand
#    print ''
#    print len(guy.players)
#    print guy.board
##    guy.evalpair(guy.players[0].hand)
#    print guy.cardremoval(['As', '5c', '7s', 'Jh', '8c', '7c'])
#    print guy.range([['As', '5c'], ['7s', 'Jh'], ['8c', '7c']])
#    print 'above is range output'
#    print guy.allcards()
#    print guy.cardremoval(['As', '5c', '6d'])
    cards = [['Ks', '4c'], ['3d', '5h'], ['8c', '5s']]
#    cards = ['3d', '5s']
    board = ['Ks', '3s', '5c']
#    cards = guy.rangehands(cards)
    print cards
#    board = guy.range(board)
    print board
#    print "above is range"
    print "flopzilla"
#    moard = guy.rangehands(board)
#    dards = guy.range(cards)
#    print moard
#    print dards
#    print 'evalpair work?'
    result = guy.flopzilla(cards,board)
    pairs = []
    for x in result:
        if x != []:
            pairs.append(x)
    print 'pairs'
    pairnum = float(len(pairs))
    print 'range'
    cardnum =  float(len(cards))
    val = (pairnum/cardnum)
    print val

if __name__ == '__main__':
#    unittest.main()
    db()



def finder(x):
    length = len(x)
    for i in range(length-2):
        if x[i:i+3] == [1, 1, 1]:
               print "found at ", i

#i think i wrote this to find straights but stopped