#!/usr/local/bin/ioL /usr/bin/python3

import random

def mainMenu():  #provides an interface for the user to begin a new game
    global numRows
    global numCols

    print('<span size=36,{pt} {New game...}></p>')
    print('<box {')
    print  ('Select size of game board...</p>')
    print  ('Rows: <rows:input 8></t>')
    print  ('Columns: <columns:input 8></p>')
    print  ('<button {Begin game} onclick=<put {b,<rows>,<columns></n>}>>')  #request user input to start a new game to be returned in the format 'b,rows,cols' -- b means begin.
    print  ('<button {Exit} onclick=<put {q</n>}>>')
    print('}>') #end box

    #add a text area for an error message if the inputs aren't valid
    print('</p><errortext:span color={orange} {Notes:</n>1: You need to make a horizontal or vertical line to win the game. Diagonal lines have not been implemented yet.</n>2. The computer player isn\'t very bright.}>')

    while True: #wait for the user to enter valid input
        choice = input().split(',')
        print('<errortext.clear>') #clear any previous error message
        if choice[0] == 'q': exit()
        elif choice[0] == 'b': #begin new game. But validate the input first...
            try:
                numRows = int(choice[1])
                numCols = int(choice[2])
                if numRows < 1 or numCols < 1:
                    print('<errortext.set {That board size is impossibly small!}>')
                else:
                    return True
            except:
                print('<errortext.set {Please enter valid integers!}>')
                

def drawBoard(rows, cols):
    print('<loading:span {Creating the board. Please wait...}>')

    #prints the game board table to the screen.
    print('<board:table border=2')
    for r in range(rows):
        print('<r' + str(r) + ':tr') #label the <tr> with the row number (e.g. '<r1:tr>'. This effectively defines a new <rN> tag that we can now use to manipulate it.)
        for c in range(cols):
            print('<c' + str(c) + ':td {</ >} border-left=1 border-right=3 outer-margin-top=0 outer-margin-bottom=0 margin=0.5,{em} width=2.5,{em}')
            coordStr = str(r) + ',' + str(c)
            print  ('onmousein=<put {i,'+ coordStr + '</n>}>') #defines actions for when the user interacts with the board
            print  ('onmouseout=<put {o,'+ coordStr + '</n>}>') #mouse out
            print  ('onclick=<put {c,'+ coordStr + '</n>}>') #click
            print('>') #end of table data cell
        print('>') #end of <tr>
    print('>') #end of table
    print('<loading.clear>') #clear the loading message.


def setBoardCell(row,col,value,color):
    print('<board <r' + str(row))  #drill down to the appropriate row in the document hierarchy
    print(  '<c' + str(col) + '.set {' + value + '}>') #set the value string
    print(  '<c' + str(col) + '.color.set {' + color + '}>') #set the color string (e.g. red or blue player's piece)
    print('>>')


def isCellVacant(row,col): 
    #returns 0 if a piece is already in this spot, otherwise returns the topmost occupied row number in this column. (== number of unoccupied rows)
    global board
    global numRows
    if board[row][col] != 0: return 0 #occupied.
    
    for r in range(row, numRows):
        if board[r][col] != 0: return r
    return numRows #nothing occupied in this column

def furtherMovesPossible():
    #returns True iff at leas one further move can be made.
    global board
    global numCols
    for c in range(numCols):
        if board[0][c] == 0: #found one! We only need to check the top row for each columns -- these are the last to be filled.
            return True
    return False



def isWinningMove(row,col):
    #returns True if the specified cell is part of a winning move, regardless of whether the cell has been taken by human or computer player.
    
    global numRows
    global numCols
    global board

    #1. check for 4 consecutive cells horizontally, with the same value as the current one.
    r = row
    c = col
    connected = 1
    for c in range(col-1,-1,-1):   #check elements to the left
        if board[row][c] != board[row][col]: break
        else: connected += 1
    for c in range(col+1, numCols):  #check elements to the right
        if board[row][c] != board[row][col]: break
        else: connected +=1
    if connected > 3: return True

    #2. check vertically now.
    r = row
    c = col
    connected = 1
    for r in range(row-1,-1,-1):   #check elements to the left
        if board[r][col] != board[row][col]: break
        else: connected += 1
    for r in range(row+1, numRows):  #check elements to the right
        if board[r][col] != board[row][col]: break
        else: connected +=1
    if connected > 3: return True


##############main###############

print('<program.title.set {Connect 4}>') # set titlebar text
print('<program.onexit <put {q</n>}>>')  # create an exit handler

while True:     #allow multiple games until the user quits.... TODO!
    mainMenu()

    print('<baseframe {') #put the game board on new 'screen'
    #set up the 2D array
    board = [[0 for c in range(numCols)] for r in range(numRows)] #each 2D array element stores 0 for empty, 1 for human player, 2 for computer player.
    drawBoard(numRows,numCols)

    print('</p><dialog:span italic=true color={orange}>') #messages from the computer player will be displayed in this span.
    print('</p><button {Exit} onclick=<put {q</n>}>>')
    print('<dialog.set {Only one of us can win. Your move, human...}>')

    while True:
        cmd = input().split(',')
        if cmd[0] == 'q': exit() #user clicked quit button, or triggered our exit handler by closing the window.
        row = int(cmd[1])
        col = int(cmd[2])
        if cmd[0] == 'i': #mouse into cell - provide visual feedback only if the cell if vacant
            if isCellVacant(row,col): setBoardCell(row,col, "</#9676>", "")
            continue
        elif cmd[0] == 'o': #mouse out of cell - reset the appearance of the cell if it's vacant.
            if isCellVacant(row,col): setBoardCell(row,col, "</ >", "")
            continue
        elif cmd[0] == 'c': #user has clicked a cell - have they made a valid move?
            freeRowsHere = isCellVacant(row,col)
            if freeRowsHere > 0: #they've selected a vacant cell. Good.
                setBoardCell(row,col, "</ >", "") #clear the visual feedback on the cell the user has clicked.
                row = freeRowsHere-1  #the player's piece will fall down to the bottommost free cell.
                board[row][col] = 1  #human player occupies this cell now.
                setBoardCell(row,col,"</#9678>","cyan")

                #now determine whether the player has won
                if isWinningMove(row,col):
                    print('<dialog.set {You win.}>')
                    break #game over

                #now it's the computer's turn to move...
                print('<dialog.set {My turn now...}>')

                if not furtherMovesPossible():
                    print('<dialog.set {Neither player wins.}>')
                    break #game over
                    
                while True : #computer will keep picking random columns until it finds an unfilled one.
                    col = random.randrange(0,numCols) #pick a random column number
                    if isCellVacant(0,col): break
                row = isCellVacant(0,col) - 1
                board[row][col] = 2  #computer player occupies this cell now.
                setBoardCell(row,col,"</#9677>","orange")

                #now determine if computer has won:
                if isWinningMove(row,col):
                    print('<dialog.set {I win! You lose. Sorry.}>')
                    break #game over

        if not furtherMovesPossible():
            print('<dialog.set {Neither player wins.}>')
            break #game over
        else:
            print('<dialog.set {Your move, human.}>')

    #game over.
    print('<dialog.bold.set true>') #make the final dialog text bold
    print('}>') #terminate the baseframe.
    while True:
        nextAction = input().strip()
        if nextAction == 'q': exit()

#END OF FILE