#!/usr/bin/python

"""
__version__ = "$Revision: 1.49 $"
__date__ = "$Date: 2006/01/24 20:49:27 $"
"""

try:
    import psyco
    psyco.full()
except ImportError:
    pass

import os, sys
import shutil
import wx
import util as lifeutil
from PythonCard import clipboard, configuration, dialog, graphic, model, util

from patterns import Patterns
from lexicon import Lexicon


class Life(model.Background):

    def on_initialize(self, event):
        self.createConfigDir()
        self.filename = None

        self.grid = None
        self.toggleToLife = 1
        self.resizing = False
        # used to protect against
        # mouseClick after file dialog
        self.openingFileDialog = False
        scale = self.getScaleFromMenu()
        if scale:
            self.setCanvasAttributes(self.getScaleFromMenu())
        else:
            self.menuBar.setChecked('menuScale5')
            self.setCanvasAttributes(5)

        self.initSizers()

        self.lexiconWindow = model.childWindow(self, Lexicon)
        self.lexiconWindow.position = (650, 25)
        self.patternsWindow = model.childWindow(self, Patterns)
        self.patternsWindow.position = (650, 300)

    def initSizers(self):
        sizer1 = wx.BoxSizer(wx.VERTICAL)
        sizer2 = wx.BoxSizer(wx.HORIZONTAL)
        comp = self.components
        flags = wx.LEFT | wx.RIGHT | wx.BOTTOM | wx.ALIGN_BOTTOM
        sizer2.Add(comp.btnStart, 0, flags, 5)
        sizer2.Add(comp.btnStop, 0, flags, 5)
        sizer2.Add(comp.btnStep, 0, flags, 5)
        sizer1.Add(sizer2, 0, flags, 5)
        sizer1.Add(comp.bufOff, 1, wx.EXPAND)
        
        sizer1.Fit(self)
        sizer1.SetSizeHints(self)
        self.sizer = sizer1
        self.panel.SetSizer(sizer1)
        self.panel.SetAutoLayout(1)
        self.panel.Layout()

    def createConfigDir(self):
        self.configPath = os.path.join(configuration.homedir, 'life')
        if not os.path.exists(self.configPath):
            os.mkdir(self.configPath)
        basePath = self.application.applicationDirectory
        self.lexiconPath = os.path.join(self.configPath, 'lexicon.txt')
        if not os.path.exists(self.lexiconPath) and os.path.exists(os.path.join(basePath, 'lexicon.txt')):
            shutil.copy2(os.path.join(basePath, 'lexicon.txt'), self.lexiconPath)
        else:
            # currently lexicon.txt is not part of the distribution
            # but it might be in the future
            pass
        self.patternsPath = os.path.join(self.configPath, 'patterns')
        if not os.path.exists(self.patternsPath):
            os.mkdir(self.patternsPath)
        basePath = os.path.join(basePath, 'patterns')
        for name in os.listdir(basePath):
            if name.lower().endswith('.lif') and not os.path.exists(os.path.join(self.patternsPath, name)):
                shutil.copy2(os.path.join(basePath, name), os.path.join(self.patternsPath, name))

    def initGrid(self):
        # a populated grid has (x, y) tuples for keys
        # with 1 (alive) or 0 (dead) for the value of each key
        self.grid = {}
        self.generation = 0

    def recenterCells(self, oldCenter):
        diffX = self.center[0] - oldCenter[0]
        diffY = self.center[1] - oldCenter[1]
        grid = {}
        #print "self.center", self.center, "oldCenter", oldCenter
        for cell in self.grid:
            grid[(cell[0] + diffX, cell[1] + diffY)] = self.grid[cell]
        self.grid = grid

    def setCanvasAttributes(self, scale):
        # whenever the window size or scale changes
        # this needs to be called
        canvas = self.components.bufOff

        color = 'blue'
        canvas.fillColor = color
        canvas.foregroundColor = color

        if self.grid is None or scale != self.scale or canvas.size != (self.width, self.height):
            self.scale = scale
            # have to resize the grid
            
            # setting self.spacing to 0 will mean
            # that the blocks have no space between them
            if self.scale < 3:
                self.spacing = 0
            else:
                self.spacing = 1

            if self.grid is not None:
                oldCenter = self.center
                oldSize = self.size

            self.width, self.height = canvas.size
            self.width = self.width / self.scale
            self.height = self.height / self.scale
            self.universeSize = (self.width, self.height)
            self.center = (self.width / 2, self.height / 2)

            if self.grid is None:
                self.initGrid()
            else:
                #self.initGrid()
                # attempt to preserve the existing pattern
                self.recenterCells(oldCenter)

        #print "self.universeSize:", self.universeSize, "self.center:", self.center, "self.scale:", self.scale
        #print "Universe Size: (%d, %d)  Scale: %d" % (self.universeSize[0], self.universeSize[1], self.scale)

    def doRunLife(self, steps=-1):
        while self.keepDrawing and steps != 0:
            grid = self.grid
            newgrid = {}
            for cell in grid:
                sum = 0
                #neighbors = lifeutil.neighborsTuple(cell[0], cell[1])
                # it is a bit faster to inline this rather than
                # calling a function
                col, row = cell
                prevRow = row - 1
                nextRow = row + 1
                prevCol = col - 1
                nextCol = col + 1
                neighbors = ((prevCol, prevRow), (col, prevRow), (nextCol, prevRow),
                            (prevCol, row), (nextCol, row),
                            (prevCol, nextRow), (col, nextRow), (nextCol, nextRow))

                # I tried a version where the dictionary kept a copy of the neighbors tuple
                # but the overhead in storing the data seemed to outweigh the cost
                # of calculating the neighbors and made this about 50% slower
                # also using get() with a default appears to be about 20-25% faster
                # than using a try/except block style access of sum += grid[neighbor]
                for neighbor in neighbors:
                    sum += grid.get(neighbor, 0)
                #print "cell", cell, grid[cell]
                #print neighbors
                #print sum
                if sum == 3 or (grid[cell] and sum == 2):
                    # cell will be alive next generation
                    newgrid[cell] = 1
                    for neighbor in neighbors:
                        newgrid.setdefault(neighbor, 0)

            self.generation += 1
            steps -= 1
            self.grid = newgrid
            self.displayGeneration()
            wx.SafeYield(self)

    def displayGeneration(self):
        canvas = self.components.bufOff
        width = self.scale - self.spacing
        canvas.autoRefresh = False
        canvas.clear()
        grid = self.grid

        # uncomment to see the size of the dictionary (hash)
        # a blinker (3 live cells in a row) will have a 15 total cells
        # in the dictionary for the 3 cells and the 12 surrounding neighbors
        #print "len(grid)", len(grid)

        population = 0
        # very small optimization
        # but it avoids an if statement for every iteration
        if width == 1:
            points = []
            for cell in grid:
                if grid[cell]:
                    population += 1
                    points.append(cell)
            canvas.drawPointList(points)
        else:
            rects = []
            scale = self.scale
            for cell in grid:
                if grid[cell]:
                    population += 1
                    rects.append((cell[0] * scale, cell[1] * scale, width, width))
                    #canvas.drawRectangle(cell[0] * scale, cell[1] * scale, width, width)
            canvas.drawRectangleList(rects)

        canvas.refresh(True)
        self.statusBar.text = "Generation: %d    Population: %d" % (self.generation, population)

    def cellAlive(self, position):
        col = position[0] / self.scale
        row = position[1] / self.scale
        return self.grid.get((col, row), 0)

    def setCell(self, col, row, alive):
        self.grid[(col, row)] = alive
        if alive:
            # make sure neighbors are in grid
            for neighbor in lifeutil.neighborsTuple(col, row):
                self.grid.setdefault(neighbor, 0)
        
    def toggleCell(self, position):
        x, y = position
        scale = self.scale
        cellWidth = scale - self.spacing
        row = y / scale
        col = x / scale
        
        alive = self.grid.get((col, row), 0)
        #print x, y, col, row, scale, alive

        if alive == self.toggleToLife:
            # no need to toggle
            return

        self.setCell(col, row, self.toggleToLife)

        y1 = row * scale
        x1 = col * scale
        canvas = self.components.bufOff
        
        if not self.toggleToLife:
            # need to erase a cell
            oldColor = canvas.foregroundColor
            canvas.foregroundColor = canvas.backgroundColor
            canvas.fillColor = canvas.backgroundColor
        
        if cellWidth == 1:
            canvas.drawPoint((x1, y1))
        else:
            canvas.drawRectangle((x1, y1), (cellWidth, cellWidth))

        if not self.toggleToLife:
            # need to restore the colors
            canvas.foregroundColor = oldColor
            canvas.fillColor = oldColor
    
    def on_bufOff_mouseDown(self, event):
        if self.openingFileDialog:
            return

        self.toggleToLife = not self.cellAlive(event.position)
        self.toggleCell(event.position)

    def on_bufOff_mouseDrag(self, event):
        if self.openingFileDialog:
            return

        self.toggleCell(event.position)
        
    def on_btnStart_mouseClick(self, event):
        self.components.btnStart.enabled = False
        self.components.btnStep.enabled = False
        self.keepDrawing = True
        startTime = util.time()

        self.doRunLife()
        
        print "Draw time: %f" % (util.time() - startTime)

    def on_btnStop_mouseClick(self, event):
        self.keepDrawing = False
        self.components.btnStart.enabled = True
        self.components.btnStep.enabled = True

    def on_btnStep_mouseClick(self, event):
        self.keepDrawing = True
        self.doRunLife(1)

    def initAndPlacePatterns(self, patterns, topLeft, size):
        width, height = size
        # at some point there might be an option to
        # not clear the current grid/universe
        # so that patterns can be placed, moved, and rotated
        # without disturbing existing patterns
        self.initGrid()
        centerX, centerY = self.center
        # if the pattern will fit within the current grid
        # it may still need to be shifted in order to be
        # centered correctly
        # this is my first attempt to shift the patterns
        # it isn't quite right so it is best to have at least a few
        # blank rows and columns of padding on each side if possible
        # until this algorithm is corrected
        left, top = topLeft
        if (left + width) > (width / 2):
            # need to shift the pattern left
            xDiff = (width / 2) + left
        elif (left + (width / 2)) < 0:
            xDiff = ((width / 2) + left)
        else:
            xDiff = 0
        if (top + height) > (height / 2):
            yDiff = (height / 2) + top
        elif (top + (height / 2)) < 0:
            yDiff = ((height / 2) + top)
        else:
            yDiff = 0
        #print "topLeft", topLeft, "xDiff, yDiff", xDiff, yDiff
        
        for pattern in patterns:
            x, y = pattern['position']
            column = centerX + x - xDiff
            row = centerY + y - yDiff
            self.grid = lifeutil.placePattern(self.grid, column, row, pattern['rows'])
        self.displayGeneration()

    def openFile(self):
        self.openingFileDialog = 1
        wildcard = "Life files (*.lif)|*.lif;*.LIF"
        directory = os.path.join(self.application.applicationDirectory, 'patterns')
        result = dialog.openFileDialog(None, "Import which file?", directory, '', wildcard)
        if result.accepted:
            path = result.paths[0]
            os.chdir(os.path.dirname(path))
            self.filename = path
            
            description, patterns, topLeft, size = lifeutil.readLifeFile(path)
            print description
            print "topLeft:", topLeft, "size", size
            self.initAndPlacePatterns(patterns, topLeft, size)

    def on_menuFileOpen_select(self, event):
        self.openFile()

    def on_menuFileSaveAs_select(self, event):
        if self.filename is None:
            path = ''
            filename = ''
        else:
            path, filename = os.path.split(self.filename)
        wildcard = "All files (*.*)|*.*"
        result = dialog.saveFileDialog(None, "Save As", path, filename, wildcard)
        if result.accepted:
            path = result.paths[0]
            fileType = graphic.bitmapType(path)
            print fileType, path
            try:
                bmp = self.components.bufOff.getBitmap()
                bmp.SaveFile(path, fileType)
                return True
            except IOError:
                return False
        else:
            return False

    def on_menuEditCopy_select(self, event):
        clipboard.setClipboard(self.components.bufOff.getBitmap())

    # assumes the clipboard contains a valid
    # text pattern like you would find in the lifep glossary.doc
    #
    # acorn
    # .*.....
    # ...*...
    # **..***
    def on_menuEditPaste_select(self, event):
        data = clipboard.getClipboard()
        if isinstance(data, str):
            description, patterns, topLeft, size = lifeutil.translateClipboardPattern(data)
            print description
            print "topLeft:", topLeft, "size", size
            self.initAndPlacePatterns(patterns, topLeft, size)

    def on_editClear_command(self, event):
        #self.components.bufOff.clear()
        self.initGrid()
        self.displayGeneration()

    def on_close(self, event):
        self.keepDrawing = False
        event.skip()

    # it would be nice to get the scales from the resource file
    # rather than hard coding them here
    # that should be possible by walking the resource or the Scale menu
    # looking for a prefix menu item name of 'menuScale'
    def getScaleFromMenu(self):
        for i in [1, 2, 3, 4, 5, 10]:
            if self.menuBar.getChecked('menuScale' + str(i)):
                return i

    def uncheckScaleMenuItems(self, scale):
        for i in [1, 2, 3, 4, 5, 10]:
            if i != scale:
                self.menuBar.setChecked('menuScale' + str(i), False)
        
    def on_setScale_command(self, event):
        scale = int(event.target.name[9:])
        self.uncheckScaleMenuItems(scale)
        self.setCanvasAttributes(scale)
        self.displayGeneration()

    def on_doAutomata_command(self, event):
        automata = event.target.name

        if automata == 'menuAutomataLife':
            result = dialog.textEntryDialog(self, 'Steps (-1 means continuous):', 'Number of steps', '-1')
            if result.accepted:
                steps = int(result.text)
                self.keepDrawing = True
                startTime = util.time()
                self.doRunLife(steps)
                print "Draw time: %f" % (util.time() - startTime)

    def on_idle(self, event):
        # have to handle resizing during idle
        # because the sizer hasn't done the work yet
        # of resizing self.components.bufOff
        #print "idle", self.resizing, self.GetSize(), self.components.bufOff.size
        if self.resizing:
            self.setCanvasAttributes(self.scale)
            self.displayGeneration()
            self.resizing = False
        self.openingFileDialog = False
            
    def on_size(self, event):
        # user resized the window
        self.resizing = True
        #print "on_size"
        #self.setCanvasAttributes(self.scale)
        event.skip()

    def on_menuAutomataLexicon_select(self, event):
        self.lexiconWindow.visible = True

    def on_menuAutomataPatternsList_select(self, event):
        self.patternsWindow.visible = True
        
    def on_menuAutomataDownloadLexiconAndPatterns_select(self, event):
        cwd = os.getcwd()
        os.chdir(self.application.applicationDirectory)
        self.statusBar.text = 'Downloading Lexicon...'
        lifeutil.getLexicon(self.configPath)
        self.lexiconWindow.populatePatternsList()
        self.statusBar.text = 'Downloading Patterns...'
        lifeutil.getPatterns(self.configPath)
        self.patternsWindow.populatePatternsList()
        os.chdir(cwd)
        self.statusBar.text = 'Done'
        
if __name__ == '__main__':
    app = model.Application(Life)
    app.MainLoop()