from Tkinter import *
from threading import Thread

from time import sleep  ## just used to slow down Thread function so far

##  Breakdown of the FIBS Board State string (editted by don).
##  source:  FIBS Client Protocol Detailed Specification
##           Copyright 2003-2004 Evan McLean.  Revision 1.2 (October 10, 2004)
##           http://www.fibs.com/fibs_interface.html#board_state
##
##  board           [0]
##  :You:someplayer [1..2]      You're name will be "You" if you are playing
##  :3:0:0          [3..5]      matchLen(9999=unLim), yourScore, opponentScore
##  :0:-2:0:0:0:0:5:0:3:0:0:0:-5:5:0:0:0:-3:0:-5:0:0:0:0:2:0
##                  [6..31]     bar..bar
##  :1              [32]        turn is -1 if it's X's turn, 1 if it's O's turn
##  :6:2:0:0        [33..36]    Your dice, opponent's dice
##  :1              [37]        current cube value
##  :1:1            [38..39]    You/opponent may double if == 1
##  :0                          Was doubled
##  :1:-1           [41..42]    Color, direction
##  :0:25                       ?obsolete home and bar?
##  :0:0                        on home for Player/opponent
##  :0:0                        on bar for Player/opponent
##  :2              [49]        How many (0-4) may be moved with current roll
##  :0:0
##  :0                          instant redoubles allowed in unlimited
##
##  Which represents the board:
##
##      +13-14-15-16-17-18-------19-20-21-22-23-24-+ X: someplayer - score: 0
##      | O           X    |   |  X              O |
##      | O           X    |   |  X              O |
##      | O           X    |   |  X                |
##      | O                |   |  X                |
##      | O                |   |  X                |
##     v|                  |BAR|                   |    3-point match
##      | X                |   |  O                |
##      | X                |   |  O                |
##      | X           O    |   |  O                |
##      | X           O    |   |  O              X |
##      | X           O    |   |  O              X |
##      +12-11-10--9--8--7--------6--5--4--3--2--1-+ O: myself - score: 0
##
##      BAR: O-0 X-0   OFF: O-0 X-0   Cube: 1  You rolled 6 2.

def printa(event,name):
    print "aaaaaaaaaaaaaaaaaa",event.widget,name

def printb(event, torb, side, point):
    print ">>inprintb:", torb, side, point, event.widget, event.num

def printdump(event, p):
    print " event.num(%d)" % event.num,
    p._dump()

class Point:
    """ A class to store any ol' info about a point-widget, defined loosely
        as a container of checkers, I suppose.  (bar, home, ...) """
    def __init__(self, baseX, baseY, direction, type, canHold=5):
        self.baseX     = baseX      ##  left corner location of widget
        self.baseY     = baseY      ##  upper(lower) location of widget
        self.direction = direction  ##  -1|1 for up|down on board
        ##self.widget  = 0          ##  internal widget ID, handled exteriorly
        self.widgets   = []         ##  for holding widgets/checkers on point
        self.canHold   = canHold    ##  n checkers without stacking
        self.number    = 0          ##  FIBS point number
        self.occupied  = 0          ##  -n|n for color and number of checkers
        self.type      = type       ##  What am I?

    def _dump(self):
        """ util:  just dump info to console """
        print "x=%2d y=%2d dir=%2d canHold=%d number=%2d occupied=%2d" %(
            self.baseX, self.baseY, self.direction, self.canHold, self.number,
            self.occupied),\
            "widget=%3d(%d) type(%d)" % (self.widget, len(self.widgets), self.type)

class FIBSgraphics(Frame):
    """ This is the event driven core for the FIBS GUI.
        Actual telnet input is handled in Thread'ed method, connectFIBS. """
    
    def __init__(self, master=None):

        Frame.__init__(self, master)
        self.grid()

        self.checkerSize = 26   ## this EVEN determines size of board

        ##  The colors "white", "black", "red", "green", "blue", "cyan",
        ##  "yellow", and "magenta" will always be available.  For rgb's,
        ##  ref:  http://infohost.nmt.edu/tcc/help/pubs/tkinter/colors.html
        self.backgroundColor    = "cyan"
        self.edgeColor          = "black"
        self.pointColor         = ("blue", "green")
        self.checkerColor       = ("magenta", "yellow")

        ##  The following are for the FIBS' board-state.  See above comments
        ##  on the breakdown of the FIBS Board State string or visit the html.

        self.color           =  0   ##  -1 if you are X, 1 if you are O.
        self._colorIndex     = 41
        self.direction       =  0   ##  -1 if you play from 24 to 1, else 1
        self._directionIndex = 42

        ##  some utility internal variables:
        self._down =  1
        self._up   = -1

        self.createWidgets()

        ## test threading.... change to method, connectFIBS
        Thread(target=self.ordfunction).start() ##  method, connectFIBS

    def createWidgets(self):
        self.drawBoard()
        self.textWin = Text(self, height=10, width=80)
        self.textWin.grid()

    def drawBoard(self):
        """ size here is self.checkerSize.  The methods to draw areas on the
            Canvas generally operate at 1/2 checkersize.  This is where board
            area widgets are defined and stored in:
                self.points [24] 0..11 top ; 12..23 bottom ; both left->right
                self.dice   [2]  0 left, 1 right side of board
                self.homes  [4]  topleft, topright, bottomleft, bottomright
                self.bar    [2]  top, bottom"""
        self.b = Canvas(self,
                        height = self.checkerSize*14 - 1,
                        width  = self.checkerSize*18 - 1,
                        background = self.backgroundColor)
        self.b.grid(sticky=W)

        ##  draw top/bottom horizontals
        self.rectangle(0,  0, 37,  1, self.edgeColor)
        self.rectangle(0, 27, 37, 28, self.edgeColor)

        ##  draw left/right verticals
        for v in (0, 3, 32, 35):
            self.rectangle(v, 1, v+1, 27, self.edgeColor)
        self.rectangle( 1, 13,  3, 15, self.edgeColor)   ##  l center area
        self.rectangle(33, 13, 35, 15, self.edgeColor)   ##  r center area

        ##  draw bar
        self.rectangle(16,  1, 20, 27, self.edgeColor)
        ##  *could* place some hinges on bar...

        ##  draw points and point location widgets (invisible, bound to mouse)
        ##  ***Note*** These points will NOT map directly to self.pointdata
        self.points = []
        for topbot in (1,27):           ##  top, bottom
            for half in (2,10):         ##  left/right halves
                for point in range(6):  ##  each has 6 points

                    ##  no need to remember the triangle widget
                    self.triangle(point, half, topbot, self.checkerSize)

                    p = Point(2*(half+point), topbot,
                              self._down if topbot == 1 else self._up,
                              point)
                    self.pointRectangle(p)
                    self.points.append(p)

                    ##  bind area to mouse button
                    def handler(event, p=p):
                        return self._temp(event, p)
                    self.b.tag_bind(p.widget, "<Button>", handler)

        ##  home area location widgets (invisible, bound to mouse though
        ##  these bindings may never be used except for testing)
        self.homes = []
        for topbot in (1,27):           ##  top, bottom
            for half in (1,33):         ##  left/right halves

                h = Point(half, topbot,
                          self._down if topbot == 1 else self._up,
                          half, 6)
                self.pointRectangle(h)
                self.homes.append(h)

                ##  bind area to mouse button
                def handler(event, h=h):
                    return self._temp(event, h)
                self.b.tag_bind(h.widget, "<Button>", handler)

        ##   bar area location widgets (invisible, bound to mouse)
        self.bars = []
        for topbot in (3,25):           ##  top, bottom

            b = Point(17, topbot,
                      self._down if topbot == 3 else self._up,
                      topbot, 4)
            self.pointRectangle(b)
            self.bars.append(b)

            ##  bind area to mouse button
            def handler(event, b=b):
                return self._temp(event, b)
            self.b.tag_bind(b.widget, "<Button>", handler)

        ##  dice area location widgets (invisible, bound to mouse)
        self.dice = []
        for half in (2,10):         ##  left/right halves

            def handler(event,
                        foo = " roll dice ",
                        h = "  left " if half == 2 else " right ",
                        tp = 0):
                return printb(event, foo, h, tp)
            diceArea = self.rectangle(
                2*(half  ), 12,
                2*(half+6), 16)
            self.b.tag_bind(diceArea, "<Button>", handler)
            self.dice.append(diceArea)

        ##  cube area location widgets (invisible, bound to mouse)
        ##  this may be useless....
        self.cubes = []
        for cube in (1, 13, 25):

            def handler(event,
                        foo = " cube ",
                        h = str(cube),
                        tp = 0):
                return printb(event, foo, h, tp)
            cubeArea = self.rectangle(
                17, cube,
                19, cube +2)
            self.b.tag_bind(cubeArea, "<Button>", handler)
            self.dice.append(cubeArea)

##developing

        print "got here! in development"
        for x in range(0,28):
            self.b.create_text((10+1)*self.checkerSize/2+1,
                               x*self.checkerSize/2 + 2,
                               text=str(x), width=self.checkerSize,
                               font=("Courier", str(self.checkerSize/4*2), "bold"),
                               fill="white")
            
        self.b.create_text((12+1)*self.checkerSize/2+1,
                           (0+1)*self.checkerSize/4+1,
                           text="15", width=self.checkerSize,
                           font=("Helvetica", str(self.checkerSize/8*2), "bold"),
                           fill="white")
        self.b.create_text((12+1)*self.checkerSize/2+1,
                           (2*27+1)*self.checkerSize/4+1,
                           text="9", width=self.checkerSize,
                           font=("Helvetica", str(self.checkerSize/8*2), "bold"),
                           fill="white")
        ##width=, Helvetica, Times

    def _temp(self, event, p):
        """ testing function for adding/removing checkers, event is button """
        printdump(event, p)
        if event.num == 3:
            self.deleteChecker(p)
        elif event.num == 1:
            self.addChecker(p, self.checkerColor[0] if p.type/2*2 == p.type else self.checkerColor[1])

    def deleteChecker(self, point):
        """ delete a checker from a point (or home or bar) """

        if point.occupied:
            point.occupied -= 1
            self.b.delete(point.widgets.pop())

            if point.occupied > point.canHold:
                ##  we're dealing with a text stacked checker
                def _g(x):
                    ##  ..got tired of typing this ...
                    return x*self.checkerSize/2

                fudge = self.checkerSize/16
                ##  fudge seems to work sort of for centering text..

                if point.direction > 0:
                    y = _g(point.baseY + 2*(point.canHold) - 1)
                else:
                    y = _g(point.baseY - 2*(point.canHold) + 1)
                print "just before append"


t = self.b.create_text(
    (point.baseX + 1)*self.checkerSize/2 + fudge,
    y + fudge,
    text = str(point.occupied),
    font=("Times", str(self.checkerSize/2), "bold"),
    width = self.checkerSize)

##                point.widgets.append(t)
##                    (point.baseX + 1)*self.checkerSize/2 + fudge,
##                                       y + fudge,
##                                       text = str(point.occupied),
##                                       width = self.checkerSize,
##                                       font = ("Times", str(self.checkerSize/2), "bold"),
##                                       fill="black")

##                point.widgets.append(
##                    self.b.create_text((point.baseX + 1)*self.checkerSize/2 + fudge,
##                                       y + fudge,
##                                       text = str(point.occupied),
##                                       width=self.checkerSize))
##                                       font=("Times", str(self.checkerSize/2), "bold"),
##                                       fill="black"))



##                self.stacker(point)

##    def stacker(self, point):
##        """ add a text number-of-checkers to a point (or home or bar) """
##        print "in stacker"
##        def _f(x):
##            ##  ..got tired of typing this ...
##            return x*self.checkerSize/2
##        print "in stacker 2"
##
##        fudge = self.checkerSize/16
##        ##  fudge seems to work sort of for centering text..
##
##        if point.direction > 0:
##            y = _f(point.baseY + 2*(point.canHold) - 1)
##        else:
##            y = _f(point.baseY - 2*(point.canHold) + 1)
##        print "just before append"
####
####        point.widgets.append(
####            self.b.create_text((point.baseX + 1)*self.checkerSize/2 + fudge,
####                               y + fudge,
####                               text = str(point.occupied),
####                               width=self.checkerSize,
####                               font=("Times", str(self.checkerSize/2), "bold"),
####                               fill="black"))

    def addChecker(self, point, color):
        """ add a checker to a point (or home or bar) """
        def _f(x):
            ##  ..got tired of typing this ...
            return x*self.checkerSize/2

        if point.occupied < point.canHold:
            ##  Just add a checker
            if point.direction > 0:
                x0 = _f(point.baseX) + 1
                x1 = _f(point.baseX + 2)
                y0 = _f(point.baseY + 2*point.occupied) + 1
                y1 = _f(point.baseY + 2*point.occupied + 2)
            else:
                x0 = _f(point.baseX) + 1
                x1 = _f(point.baseX + 2)
                y0 = _f(point.baseY - 2*point.occupied - 2) + 1
                y1 = _f(point.baseY - 2*point.occupied)

            point.widgets.append(
                self.b.create_oval(x0, y0, x1, y1, fill = color, outline="white", width = 1))

        else:
            ##  Gotta go text mode for number of checkers
            fudge = self.checkerSize/16
            ##  fudge seems to work sort of for centering text..
            if point.occupied > point.canHold:
                ## trash previous number/text widget...
                self.b.delete(point.widgets.pop())

            if point.direction > 0:
                y = _f(point.baseY + 2*(point.canHold) - 1)
            else:
                y = _f(point.baseY - 2*(point.canHold) + 1)

            point.widgets.append(
                self.b.create_text((point.baseX + 1)*self.checkerSize/2 + fudge,
                                   y + fudge,
                                   text = str(point.occupied + 1),
                                   width=self.checkerSize,
                                   font=("Times", str(self.checkerSize/2), "bold"),
                                   fill="black"))

        point.occupied += 1
        self.b.tag_raise(point.widget)      ##  Gotta keep the invisible on top!

#### junk
##        x0 = 2*size; y0 = size/2
##        x1 = x0 + size; y1 = y0 + size
##        t = self.b.create_oval ( 1+x0, 1+y0, x1, y1,
##                            fill = "yellow",
##                            width = 0,
##                            tags="bozo")
##        self.b.tag_raise (self.points[0], "bozo")
##
##        x0 = 3*size; y0 = size/2
##        x1 = x0 + size; y1 = y0 + size
##        self.b.create_oval ( 1+x0, 1+y0, x1, y1,
##                            fill = "red",
##                            width = 0,
##                            tags="hey")
##        def handler(event,name="hey"):
##            self.b.delete("hey")
##            return printa(event,name)
##        self.b.tag_bind("hey","<Button-1>",handler)
##        self.b.tag_raise (self.points[1], "hey")

    def triangle(self, pOffset, half, topbot, size):
        """ Pretty specific routine for drawing individual points...
            but hey, it's only done once! """
        pcolor = self.pointColor[pOffset%2 if topbot == 1 else (pOffset+1)%2]
        pheight = 11 if topbot == 1 else -11
        x = (pOffset+half) * size
        y = topbot*size / 2
        self.b.create_polygon(1 + x,
                              1 + y,
                              1 + x + size,
                              1 + y,
                              1 + x + size/2,
                              1 + y + pheight*size/2,
                              1 + x,
                              1 + y,
                              fill = pcolor,
                              width = 0)

    def pointRectangle(self, point, color=""):
        """ Draw invisible point-sized rectangles invoking self.rectangle,
            >> store new widget in point.widget
            >> designate color for testing to see where the hell it is! """
        point.widget = self.rectangle(
            point.baseX  , point.baseY,
            point.baseX+2, 12 if point.direction == 1 else 16,
            color)

    def rectangle(self, x0, y0, x1, y1, color=""):
        """ Draw a rectangle on self.b gridded to 1/2 self.checkersize,
            filling squares (x0,y0) to (x1, y1).
            >> color may be used for testing (where the hell am I?) """
        size = self.checkerSize/2
        return self.b.create_rectangle(
            1 + x0*size, 1 + y0*size,
            1 + x1*size, 1 + y1*size,
            fill = color,
            width = 0)

    def board(self, board):
        """ parse and display a FIBS board
            http://www.fibs.com/fibs_interface.html#board_state"""
        if self.color     != int(board[self._colorIndex]) or \
           self.direction != int(board[self._directionIndex]):
            self.mapPoints(board)
        print board

    def mapPoints(self, board):
        """ Map local widgets onto self.pointData according to current input
            from FIBS.  There are 4 different mappings here (tho cludgy way to
            do it), allowing for play in both directions as FIBS decides. """

        self.color     = board[self._colorIndex]
        self.direction = board[self._directionIndex]

        if self.color == 1 and self.direction == -1:
            ##  +13-14-15-16-17-18-------19-20-21-22-23-24-+BO      color  1 
            ##    0  1  2  3  4  5  (BO)  6  7  8  9 10 11 (HX)
            ##   12 13 14 15 16 17  (BX) 18 19 20 21 22 23 (HO)    
            ##  +12-11-10--9--8--7--------6--5--4--3--2--1-+BX  direction -1
            ##  board[7:30] --> self.points[0:23]
            ##  (13,14,15,16,17,18,      19,20,21,22,23,24,
            ##   12,11,10, 9, 8, 7        6, 5, 4, 3, 2, 1)
            self.boardMap  = (13,14,15,16,17,18,19,20,21,22,23,24,
                              12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

##        print "pp bX bY +- wi mx -2 <-  -2"
        for i in range(24):
            self.points[i].number = self.boardMap[i]
            self.displayCheckers(board[self.boardMap[i]+7], self.points[i])

    ##  self.points[.baseX .baseY .direction .widget .widgets
    ##              .canHold .number .occupied)]

    def displayCheckers(self, point, pointObject, checkers):
        if pointObject != self.pointData[point][0]:
            if len(self.pointData[point][0]) > 0:
                self.pointData[point][0].pop()
            self.pointData[point][0].append(pointObject)
        while pointObject.occupied != checkers:
            self.addChecker(point, checkers)

##    def addChecker(self, point, checkers):
##        self.pointData[point][0][0].occupied = checkers
##        t = self.pointData[point][0][0]
##        print "%2d %2d %2d %2d %2d %2d %2d <- %3d" %\
##              (point, t.baseX, t.baseY, t.direction, t.widget, t.canHold,
##               t.occupied, checkers)


    def ordfunction(self): pass
##        print "\n I'm an ordinary function named nothing"
######        board = "board:You:someplayer:3:0:0:0:-2:0:0:0:0:5:0:3:0:0:0:-5:5:0:0:0:-3:0:-5:0:0:0:0:2:0:1:6:2:0:0:1:1:1:0:1:-1:0:25:0:0:0:0:2:0:0:0"
######        splitboard = board.split(':')
######        intboard = []
######        for i in range(len(splitboard)):
######            if i<3:
######                intboard.append(splitboard[i])
######            else:
######                intboard.append(int(splitboard[i]))
######        self.board(intboard)
##        c = 1
##        sign = 1
##        pid4 = 0.0
##        lastav = -1.0
##        agree = 1
##        for x in range (270):
##            sleep(1)
##            lastpi = pid4*4
##            pid4 += 1.0*sign/c
##            sign *= -1
##            c += 2
##            pi4 = pid4*4
##            av = (pi4+lastpi)/2
##            print "%8d %12.10f %12.10f" % (x+1, pi4 , av),
##            if str(lastav)[agree] == str(av)[agree]:
##                print agree-1
##                agree +=1
##            else:
##                print
##            lastav = av

app = FIBSgraphics()
app.master.title("PYjammonGammon")
app.mainloop()

##  Mapping board[7:30] --> self.points[0:23] the way FIBS does it:

##      +12-11-10--9--8--7--------6--5--4--3--2--1-+BO      color -1 
##        0  1  2  3  4  5  (B0)  6  7  8  9 10 11 (HX)
##       12 13 14 15 16 17  (B1) 18 19 20 21 22 23 (HO)    
##      +13-14-15-16-17-18-------19-20-21-22-23-24-+BX  direction  1
##
##      (12,11,10, 9, 8, 7        6, 5, 4, 3, 2, 1,
##       13,14,15,16,17,18,      19,20,21,22,23,24)

##      +13-14-15-16-17-18-------19-20-21-22-23-24-+BO      color  1 
##        0  1  2  3  4  5  (B0)  6  7  8  9 10 11 (HX)
##       12 13 14 15 16 17  (B1) 18 19 20 21 22 23 (HO)    
##      +12-11-10--9--8--7--------6--5--4--3--2--1-+BX  direction -1
##
##      (13,14,15,16,17,18,      19,20,21,22,23,24,
##       12,11,10, 9, 8, 7        6, 5, 4, 3, 2, 1)

##    BX+24-23-22-21-20-19-------18-17-16-15-14-13-+        color -1 
##        0  1  2  3  4  5  (B0)  6  7  8  9 10 11 (HX)
##       12 13 14 15 16 17  (B1) 18 19 20 21 22 23 (HO)    
##    BO+-1--2--3--4--5--6--------7--8--9-10-11-12-+    direction -1
##
##      (24,23,22,21,20,19,      18,17,16,15,14,13,
##        1 ,2, 3, 4, 5, 6,       7, 8, 9,10,11,12)

##      +-1--2--3--4--5--6--------7--8--9-10-11-12-+BO      color  1 
##        0  1  2  3  4  5  (B0)  6  7  8  9 10 11 (HX)
##       12 13 14 15 16 17  (B1) 18 19 20 21 22 23 (HO)    
##      +24-23-22-21-20-19-------18-17-16-15-14-13-+BX  direction  1
##
##      ( 1 ,2, 3, 4, 5, 6,       7, 8, 9,10,11,12,
##       24,23,22,21,20,19,      18,17,16,15,14,13)