#!/usr/bin/env python

'''This demonstrates controlling a screen oriented application (curses).
It starts two instances of gnuchess and then pits them against each other.
'''

import pexpect
import string
import ANSI
import sys
import os
import time


class Chess:

    def __init__(self, engine="/usr/local/bin/gnuchess -a -h 1"):
        self.child = pexpect.spawn(engine)
        self.term = ANSI.ANSI()

        #self.child.expect ('Chess')
        # if self.child.after != 'Chess':
        #        raise IOError, 'incompatible chess program'
        #self.term.process_list (self.child.before)
        #self.term.process_list (self.child.after)

        self.last_computer_move = ''

    def read_until_cursor(self, r, c, e=0):
        '''Eventually something like this should move into the screen class or
        a subclass. Maybe a combination of pexpect and screen...
        '''
        fout = open('log', 'a')
        while self.term.cur_r != r or self.term.cur_c != c:
            try:
                k = self.child.read(1, 10)
            except Exception as e:
                print 'EXCEPTION, (r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c)
                sys.stdout.flush()
            self.term.process(k)
            fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c))
            fout.flush()
            if e:
                sys.stdout.write(k)
                sys.stdout.flush()
            if self.term.cur_r == r and self.term.cur_c == c:
                fout.close()
                return 1
        print 'DIDNT EVEN HIT.'
        fout.close()
        return 1

    def expect_region(self):
        '''This is another method that would be moved into the
        screen class.
        '''
        pass

    def do_scan(self):
        fout = open('log', 'a')
        while True:
            c = self.child.read(1, 10)
            self.term.process(c)
            fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c))
            fout.flush()
            sys.stdout.write(c)
            sys.stdout.flush()

    def do_move(self, move, e=0):
        time.sleep(1)
        self.read_until_cursor(19, 60, e)
        self.child.sendline(move)

    def wait(self, color):
        while True:
            r = self.term.get_region(14, 50, 14, 60)[0]
            r = r.strip()
            if r == color:
                return
            time.sleep(1)

    def parse_computer_move(self, s):
        i = s.find('is: ')
        cm = s[i + 3:i + 9]
        return cm

    def get_computer_move(self, e=0):
        time.sleep(1)
        self.read_until_cursor(19, 60, e)
        time.sleep(1)
        r = self.term.get_region(17, 50, 17, 62)[0]
        cm = self.parse_computer_move(r)
        return cm

    def switch(self):
        print 'switching'
        self.child.sendline('switch')

    def set_depth(self, depth):
        self.child.sendline('depth')
        self.child.expect('depth=')
        self.child.sendline('%d' % depth)

    def quit(self):
        self.child.sendline('quit')


def LOG(s):
    print s
    sys.stdout.flush()
    fout = open('moves.log', 'a')
    fout.write(s + '\n')
    fout.close()

print 'Starting...'

black = Chess()
white = Chess()
white.read_until_cursor(19, 60, 1)
white.switch()

done = 0
while not done:
    white.wait('Black')
    move_white = white.get_computer_move(1)
    LOG('move white:' + move_white)

    black.do_move(move_white)
    black.wait('White')
    move_black = black.get_computer_move()
    LOG('move black:' + move_black)

    white.do_move(move_black, 1)

g.quit()