from __future__ import print_function
#  
#  Copyright (c) 2012 Edward Langley
#  All rights reserved.
#  
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:
#  
#  Redistributions of source code must retain the above copyright notice,
#  this list of conditions and the following disclaimer.
#  
#  Redistributions in binary form must reproduce the above copyright
#  notice, this list of conditions and the following disclaimer in the
#  documentation and/or other materials provided with the distribution.
#  
#  Neither the name of the project's author nor the names of its
#  contributors may be used to endorse or promote products derived from
#  this software without specific prior written permission.
#  
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
#  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
#  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
#  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
#  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#  
#  

import sys
import collections
import pygame

class Cell(object):
	north = None
	south = None
	east = None
	west = None
	rules = {}


	def rule(self, *a):
		'''The rule used to determine the new value for the current cell, add_rule reassigns this based on the current value'''
		return self.value

	@classmethod
	def add_rule(self, value):
		'''Add a rule to correspond to the current value of the cell'''
		def _inner(rule):
			self.rules[value] = rule
			return rule
		return _inner

	def __init__(self):
		self.value = None
		self.update_neighbors()

	def set_value(self, v):
		'''Change the cells value and select the appropriate rule'''
		if v != self.value:
			self.value = v
			if v is not None:
				self.rule = self.rules[v]

	def neighbor_value(self):
		'''Get the total of the values of neighbouring cells'''
		result = 0
		for c in self.neighbors:
			if c is None: continue
			elif c.value is None: continue
			result += c.value
		return result

	def update_neighbors(self):
		'''Change the neighbors attribute to reflect the current situation'''
		self.neighbors = (self.north, self.south, self.east, self.west, self.northwest, self.northeast, self.southwest, self.southeast)

	def autoconnect(self):
		'''Set up the reverse links appropriate to the current situation'''
		updated = []

		if self.south and self.south.north is not self:
			self.south.north = self
			updated.append(self.south)
		if self.north and self.north.south is not self:
			self.north.south = self
			updated.append(self.north)
		if self.east and self.east.west is not self:
			self.east.west = self
			updated.append(self.east)
		if self.west and self.west.east is not self:
			self.west.east = self
			updated.append(self.west)

		for up in updated:
			up.autoconnect()

		self.update_neighbors()

	@property
	def northeast(self):
		r = self.north
		if r is not None:
			return r.east

	@property
	def northwest(self):
		r = self.north
		if r is not None:
			return r.west

	@property
	def southeast(self):
		r = self.south
		if r is not None:
			return r.east

	@property
	def southwest(self):
		r = self.south
		if r is not None:
			return r.west


	def __repr__(self):
		return '%s().set_value(%s)' % (self.__name__, self.value)

	def __str__(self):
		return str(self.value)

class CellSprite(pygame.sprite.DirtySprite):
	'''Display code for :py:class:`Cell`'''

	def __init__(self, cell, row, col, *a):
		self.image = pygame.surface.Surface( (6,6) )
		self.cell = cell
		self.row = row
		self.col = col
		cell.sprite = self
		self.spacing = 0

		row, col = self.row, self.col
		spacing = self.spacing
		size = width, height = self.image.get_size()
		self.rect = pygame.rect.Rect( (width*(col)+spacing*(col), (height*(row)+spacing*(row))), size )

		pygame.sprite.DirtySprite.__init__(self, *a)
		self.start_update(self.cell.value)


	colors = {
		None: (128,128,128),
		0: (0,0,0),
		1: (0,255,0),
		2: (128,64,0),
		3: (255,0,0)
	}

	def start_update(self, value):
		'''Begin to update the cell: store the new value and mark the sprite "dirty"'''
		self.new_value = value
		self.dirty = 1
		self.ud = True

	def update(self):
		'''Update the cell: set the cell's value and paint the new image'''
		if self.ud:
			self.cell.set_value(self.new_value)
			self.image.fill( self.colors[self.cell.value] )


class Board(object):
	'''Set up and store the cells'''

	def __init__(self, width, height):
		self.board_group = pygame.sprite.LayeredDirty(_use_update=True)
		self.rect = pygame.Rect(0,0,0,0)
		self.dct = {}

		for col in xrange(width):
			for row in xrange(0,height):
				cell = self.dct[row, col] = Cell()
				sprite = CellSprite(cell, row, col, self.board_group)

		for col in xrange(width):
			for row in xrange(height):
				cell = self.dct[row,col]
				cell.east = self.dct.get((row,col+1))
				cell.south = self.dct.get((row+1,col))
				cell.autoconnect()

		self.init = self.dct[0,0]
		self.rect.unionall_ip(list(self.board_group))


	def __str__(self):
		current = self.init
		result = []
		while current.east != None:
			top = current
			result.append([])
			while top.south != None:
				result[-1].append(str(top))
				top = top.south
			current = current.east
		result = zip(*result)
		return '\n'.join(
			' '.join(r) for r in result
		)

import random



class Controller(object):
	'''Initialize cell values and run the simulation'''
	def __init__(self, board):
		self.board = board
		self.observers = []

		column = self.board.init
		for sprite in self.board.board_group:
			sprite.start_update( random.choice([1]*7+[0]*5 +[2]) )
		self.board.board_group.update()


	def step(self):
		'''Run one iteration of the simulation'''
		for observer in self.observers:
			observer.act()

		c_sprites = pygame.sprite.Group()
		for sprite in self.board.board_group:
			cell = sprite.cell
			nvalue = cell.rule
			if callable(nvalue):
				nvalue = nvalue(cell)
			if nvalue is None:
				nvalue = cell.value
			if nvalue != cell.value:
				sprite.start_update(nvalue)
				c_sprites.add(sprite)
		c_sprites.update()
		return self

	def add_observer(self, cls, *args, **kwargs):
		'''add an observer to a cell'''
		observer = cls(*args, **kwargs)
		self.observers.append(observer)
		return observer

	def init(self, cb):
		self.init = cb
		return self

	def add_event(self, cb):
		self.events.append(cb)
		return self

	def loop(self):
		variables = {}
		variables.update(self.init())
		clck = pygame.time.Clock()
		variables['running'] = True

class Presence(object):
	'''Observer interface'''
	def __init__(self, locale):
		self.locale = locale

	def act(self):
		'''Override to implement behavior'''
		pass