#!/usr/bin/env python

import pygame, os, sys, random
from pygame.locals import *

def centeron( x, y, w, h ):
  return x - w/2, y - h/2

class JBoard:

  vals = []
  qlist = []
  clist = []
  alist = []
  covered = []
  remaining = 0

  def __init__(self, fn):
    lns = open( fn ).readlines()
    [cats, qs] = [int(x) for x in lns.pop(0).split()]
    for v in range(qs):
      self.vals.append( int(lns.pop(0).strip()) )
    for c in range(cats):
      self.clist.append( lns.pop(0).strip() )
      self.qlist.append( [] )
      self.alist.append( [] )
      self.covered.append( [] )
      for q in range(qs):
        self.qlist[c].append( lns.pop(0).strip() )
        self.alist[c].append( lns.pop(0).strip() )
        self.covered[c].append( True )
    self.remaining = cats*qs

  def getq(self, c, v):
    return self.qlist[c][v]

class TextJep(JBoard):

  def __init__(self, fn):
    self.board = JBoard( fn )

class GraphicalJep( JBoard ):

  teams = [ ('Team 1', (100,100,10)),
            ('Team 2', (10,100,100)),
            ('Team 3', (100,10,100)) ]

  def loadres(self):
    self.backimg = pygame.image.load( os.path.join('img', 'grad.jpeg') ).convert()
    self.qimg = pygame.image.load( os.path.join('img', 'cov.png') ).convert()
    self.qfont = pygame.font.Font( os.path.join('font','Vera.ttf'), 32 )
    self.qcol = (10,100,10)

  def drawboard( self, sf ):
    h = sf.get_height()
    w = sf.get_width()
    
    dw = w / len(self.clist)
    th = h / 10
    lh = h*2 / 10
    qh = h*7 / 10
    
    dh = qh / len(self.vals)

    for c in range( len(self.clist) ):
      cat =  self.qfont.render( self.clist[c], False, (10,100,10) )
      sf.blit( cat, (dw*c + dw/2 - cat.get_width()/2, th/2 - cat.get_height()/2) )

      for q in range( len(self.vals) ):
        if self.covered[c][q]:
          val = self.qfont.render( str(self.vals[q]), False, (10,100,10) )
          sf.blit( val, (dw*c + dw/2 - val.get_width()/2, th + dh*q + dh/2 - val.get_height()/2) )

    dw = w / len(self.teams)

    for t in range( len(self.teams)):
      tn = self.qfont.render( '%s: %s' % (self.teams[t][0], self.scores[t]), False, self.teams[t][1] )
      left,top = dw*t + dw/2 - tn.get_width()/2, th + qh + lh/2 - tn.get_height()/2
      sf.blit( tn, (left, top) )
      if t == self.rrpos:
        pygame.draw.rect( sf, self.teams[t][1],
                          pygame.Rect( left-3, top-3, tn.get_width()+6, tn.get_height()+6 ), 3 )

  def qselect( self ):
    c,q = -1,-1
    while c not in range(len(self.clist))   \
          or q not in range(len(self.vals)) \
          or not self.covered[c][q]:
      c = -1
      while c == -1:
        pygame.event.pump()
        e = pygame.event.wait()
        if e.type == KEYUP:
          if e.key == 27:
            return -1,-1
          if e.key >= 48 and e.key < 58 and (e.key-49) < len(self.clist):
            c = e.key-49
      q = -1
      while q == -1:
        pygame.event.pump()
        e = pygame.event.wait()
        if e.type == KEYUP:
          if e.key == 27:
            return -1,-1
          if e.key >= 48 and e.key < 58 and (e.key-49) < len(self.vals):
            q = e.key-49
    return c,q

  def waitkey( self ):
    while 1:
      pygame.event.pump()
      e = pygame.event.wait()
      if e.type == KEYUP:
        if e.key == 27:
          return True
        return False

  def showq( self, sf, qtext ):
    wrds = qtext.split()
    qlines = []
    u = 0
    for w in range(len(wrds)):
      qln = self.qfont.render( ' '.join( wrds[u:w+1] ), False, self.qcol )
      if qln.get_width() > (sf.get_width()*9/10):
        qlines.append( self.qfont.render( ' '.join( wrds[u:w] ), False, self.qcol ) )
        u = w
    qlines.append( self.qfont.render( ' '.join( wrds[u:] ), False, self.qcol ) )
    h = sf.get_height()/10
    for q in qlines:
      sf.blit( q, ( sf.get_width()/2 - q.get_width()/2, h ) )
      h += self.qfont.get_linesize()*11/10

  def steal( self, sf ):
    print "stealing"
    ticks = 5
    running = True
    pygame.time.set_timer( USEREVENT, 1000 )
    left,top,width,height = 0, sf.get_height()*17/20, sf.get_width(), sf.get_height()/20
    wrecked = pygame.Rect( left, top, width, sf.get_height() )
    sf.set_clip( wrecked )

    sf.blit( self.backimg, (0,0) )
    pygame.draw.rect( sf, ( 200 - 20*ticks, 20*ticks, 30 ),
                      pygame.Rect( width/2 - (width/2)*ticks/5, top, width*ticks/5, height ) )
    prompt = self.qfont.render( 'STEAL', False, (230,30,30) )
    sf.blit( prompt, ( width/2 - prompt.get_width()/2, top+height+5 ) )
    pygame.display.flip()

    while 1:
      pygame.event.pump()
      e = pygame.event.wait()
      if e.type == KEYUP:
        if e.key == 32 and not running:
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return -1
        if e.key == 32 and running:
          pygame.time.set_timer( USEREVENT, 0 )
          running = False
        if e.key >= 48 and e.key < 58 and (e.key-49) < len(self.teams):
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return e.key-49
      if e.type == USEREVENT:
        ticks -= 1
        sf.blit( self.backimg, (0,0) )
        pygame.draw.rect( sf, ( 200 - 20*ticks, 20*ticks, 30 ),
                          pygame.Rect( width/2 - (width/2)*ticks/5, top, width*ticks/5, height ) )
        sf.blit( prompt, ( width/2 - prompt.get_width()/2, top+height+5 ) )
        pygame.display.flip()
        if ticks <= 0:
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return -1
    print "Counted to infinity"
    pygame.time.set_timer( USEREVENT, 0 )
    sf.set_clip( None )

  def buzzer( self, sf, team ):
    print "waiting"
    ticks = 10
    running = True
    pygame.time.set_timer( USEREVENT, 1000 )
    left,top,width,height = 0, sf.get_height()*17/20, sf.get_width(), sf.get_height()/20
    wrecked = pygame.Rect( left, top, width, sf.get_height() )
    sf.set_clip( wrecked )

    sf.blit( self.backimg, (0,0) )
    prompt = self.qfont.render( self.teams[team][0], False, self.teams[team][1] )
    pygame.draw.rect( sf, ( 200 - 20*ticks, 20*ticks, 30 ),
                      pygame.Rect( width/2 - (width/2)*ticks/10, top, width*ticks/10, height ) )
    sf.blit( prompt, ( width/2 - prompt.get_width()/2, top+height+5 ) )
    pygame.display.flip()

    while 1:
      pygame.event.pump()
      e = pygame.event.wait()
      if e.type == KEYUP:
        if e.key == 32 and not running:
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return False
        if e.key == 32 and running:
          pygame.time.set_timer( USEREVENT, 0 )
          running = False
        if e.key == 10 or e.key == 13:
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return True
      if e.type == USEREVENT:
        ticks -= 1
        sf.blit( self.backimg, (0,0) )
        pygame.draw.rect( sf, ( 200 - 20*ticks, 20*ticks, 30 ),
                          pygame.Rect( width/2 - (width/2)*ticks/10, top, width*ticks/10, height ) )
        sf.blit( prompt, ( width/2 - prompt.get_width()/2, top+height+5 ) )
        pygame.display.flip()
        if ticks <= 0:
          pygame.time.set_timer( USEREVENT, 0 )
          sf.set_clip( None )
          return False
    print "Counted to infinity"
    pygame.time.set_timer( USEREVENT, 0 )
    sf.set_clip( None )

  def run(self, scr):

    self.loadres()
    self.scores = [0 for t in self.teams]
    self.rrpos = int( random.random()*len(self.teams) )

    while self.remaining > 0:
      scr.blit( self.backimg, (0,0) )
      self.drawboard( scr )
      pygame.display.flip()

      c,q = self.qselect()
      if c == -1:
        break
      self.remaining -= 1
      self.covered[c][q] = False

      scr.blit( self.backimg, (0,0) )
      self.showq( scr, self.qlist[c][q] )
      pygame.display.flip()

      if self.buzzer( scr, self.rrpos ):
        self.scores[ self.rrpos ] += self.vals[q]
      else:
        x = self.steal( scr )
        if x > -1:
          self.scores[ x ] += self.vals[q]

      print self.scores
      scr.set_clip( scr.get_rect() )
      scr.blit( self.backimg, (0,0) )
      pygame.display.flip()
      self.showq( scr, self.alist[c][q] )
      pygame.display.flip()
      print "see answer"
      quit = self.waitkey()
      if quit:
        break
      print "next question"

      self.rrpos = (self.rrpos+1) % len(self.teams)


if __name__ == '__main__':

  fn = os.path.join('data', 'default.jbd')
  if len(sys.argv) == 2:
    fn = sys.argv[1]
  
  pygame.init()
  scr = pygame.display.set_mode( (800,600) )
  pygame.event.set_allowed( (KEYUP, USEREVENT) )
  pygame.display.flip()

  img = pygame.image.load( os.path.join('img', 'ivcjep.jpeg') ).convert()
  scr.blit( img, (0,0) )
  pygame.display.flip()
  pygame.time.set_timer( USEREVENT, 2000 )
  while 1:
    pygame.event.pump()
    e = pygame.event.wait()
    if e.type == KEYUP:
      break
    if e.type == USEREVENT:
      break
  pygame.time.set_timer( USEREVENT, 0 )

  gj = GraphicalJep( fn )
  gj.run( scr )