import wx
from random import random


bombsID_NEWGAME = wx.ID_HIGHEST
bombsID_EASY = wx.ID_HIGHEST + 1
bombsID_MEDIUM = wx.ID_HIGHEST + 2
bombsID_HARD = wx.ID_HIGHEST + 3

BG_HIDDEN   = 0x100
BG_BOMB     = 0x200
BG_MARKED   = 0x400
BG_EXPLODED = 0x800
BG_MASK     = 0x0FF
PROB        = 0.2
X_UNIT      = 4
Y_UNIT      = 4

class BombsGame:
    def __init__ (self):
        self.m_width = 0
        self.m_height = 0
        self.m_field = 0

    def Init (self, aWidth, aHeight):
        self.m_gridFocusX = -1
        self.m_gridFocusY = -1

        try:
            if self.m_field:
                self.m_field = []
        except:
            pass

        self.m_field = aWidth * aHeight*[0]

        self.m_width = aWidth
        self.m_height = aHeight

        for x in range (0, self.m_width):
            for y in range (0, self.m_height):
                if random() < PROB:
                    self.m_field [x + y * self.m_width] = BG_HIDDEN | BG_BOMB
                else:
                    self.m_field [x + y * self.m_width] = BG_HIDDEN

        self.m_numBombCells = 0
        for x in range (0, self.m_width):
            for y in range (0, self.m_height):
                if self.m_field [x + y * self.m_width] & BG_BOMB:
                    self.m_numBombCells += 1

                    for xx in range (x-1, x + 2):
                        if xx >= 0 and xx < self.m_width:
                            for yy in range (y - 1, y + 2):
                                if yy >= 0 and yy < self.m_height and (yy != y or xx != x):
                                    self.m_field [xx + yy * self.m_width] += 1

        self.m_numRemainingCells = self.m_height * self.m_width - self.m_numBombCells
        return True

    def GetWidth (self):
        return self.m_width

    def GetHeight (self):
        return self.m_height

    def Get (self, x, y):
        return self.m_field [x + y * self.m_width]

    def IsFocussed (self, x, y):
        return self.m_gridFocusX == x and self.m_gridFocusY == y

    def IsHidden (self, x, y):
        return self.Get (x, y) & BG_HIDDEN

    def IsMarked (self, x, y):
        return self.Get (x, y) & BG_MARKED

    def IsBomb (self, x, y):
        return self.Get (x, y) & BG_BOMB

    def IsExploded (self, x, y):
        return self.Get (x, y) & BG_EXPLODED

    def GetNumBombs(self):
        return self.m_numBombCells

    def GetNumRemainingCells(self):
        return self.m_numRemainingCells

    # Marks/unmarks a cell
    def Mark(self, x, y):
        self.m_field [x + y * self.m_width] ^= BG_MARKED

    # Unhides a cell
    def Unhide(self, x, y):
        if not self.IsHidden(x,y):
            return

        self.m_field [x + y * self.m_width] &= ~BG_HIDDEN

        if not self.IsBomb(x,y):
            self.m_numRemainingCells -= 1

    # Makes a cell exploded
    def Explode (self, x, y):
        self.m_field [x + y * self.m_width] |= BG_EXPLODED


class BombsCanvas (wx.Panel):
    def __init__(self, parent, game):
        wx.Panel.__init__(self, parent, wx.ID_ANY)
        # Cell size in pixels
        self.m_game = game
        dc = wx.ClientDC (self)

        m_game = game
        dc = wx.ClientDC (self)
        font = wx.Font(14, wx.ROMAN, wx.NORMAL, wx.NORMAL)

        dc.SetFont(font)

        buf = "M"

        chw, chh = dc.GetTextExtent(buf)
        dc.SetFont(wx.NullFont)

        dc.SetMapMode(wx.MM_METRIC)

        xcm = dc.LogicalToDeviceX(10)
        ycm = dc.LogicalToDeviceY(10)
        # To have a square cell, there must be :
        #    sx*ycm == sy*xcm
        if chw * ycm < chh * xcm:
            sy = chh
            sx = chh * xcm / ycm
        else:
            sx = chw
            sy = chw * ycm / xcm

        self.m_cellWidth = (sx + 3 + X_UNIT) / X_UNIT
        self.m_cellHeight = (sy + 3 + Y_UNIT) / Y_UNIT
        dc.SetMapMode(wx.MM_TEXT)
        self.m_bmp = 0

        self.Bind (wx.EVT_PAINT, self.OnPaint)
        self.Bind (wx.EVT_MOUSE_EVENTS, self.OnMouseEvent)
        self.Bind (wx.EVT_CHAR, self.OnChar)

    def UpdateGridSize(self):
        if self.m_bmp:
            self.m_bmp = None
        self.Refresh()

    def GetGridSizeInPixels(self):
        return wx.Size(self.m_cellWidth * X_UNIT * self.m_game.GetWidth(),  self.m_cellHeight * Y_UNIT * self.m_game.GetHeight())

    def OnPaint(self, event):
        dc = wx.PaintDC (self)

        numHorzCells = self.m_game.GetWidth()
        numVertCells = self.m_game.GetHeight()
        #// Insert your drawing code here.
        if not self.m_bmp:
            size = dc.GetSize()
            self.m_bmp = wx.EmptyBitmap (size.GetWidth(), size.GetHeight())
            if self.m_bmp:
                memDC = wx.MemoryDC()
                memDC.SelectObject(self.m_bmp)
                self.DrawField(memDC, 0, 0, numHorzCells - 1, numVertCells - 1)
                memDC.SelectObject(wx.NullBitmap)
        if self.m_bmp:
            memDC = wx.MemoryDC()
            memDC.SelectObject(self.m_bmp)
            size = dc.GetSize()
            dc.Blit(0, 0, size.GetWidth(), size.GetHeight(), memDC, 0, 0, wx.COPY)
            memDC.SelectObject(wx.NullBitmap)
        else:
            self.DrawField(dc, 0, 0, numHorzCells - 1, numVertCells - 1)

    def DrawField(self, dc, xc1, yc1, xc2, yc2):
        buf = ""

        wx.Black = wx.TheColourDatabase.Find("BLACK")
        wx.White = wx.TheColourDatabase.Find("WHITE")
        wx.Red = wx.TheColourDatabase.Find("RED")
        wx.Blue = wx.TheColourDatabase.Find("BLUE")
        wx.Grey = wx.TheColourDatabase.Find("LIGHT GREY")
        wx.Focused = wx.TheColourDatabase.Find("GREY")
        wx.Green = wx.TheColourDatabase.Find("GREEN")

        blackPen = wx.ThePenList.FindOrCreatePen(wx.Black, 1, wx.SOLID)
        redPen = wx.ThePenList.FindOrCreatePen(wx.Red, 1, wx.SOLID)
        bluePen = wx.ThePenList.FindOrCreatePen(wx.Blue, 1, wx.SOLID)
        whiteBrush = wx.TheBrushList.FindOrCreateBrush(wx.White, wx.SOLID)
        greyBrush = wx.TheBrushList.FindOrCreateBrush(wx.Grey, wx.SOLID)
        focusedBrush = wx.TheBrushList.FindOrCreateBrush(wx.Focused, wx.SOLID)
        redBrush = wx.TheBrushList.FindOrCreateBrush(wx.Red, wx.SOLID)

        dc.SetPen (blackPen)

        xMax = self.GetGridSizeInPixels().GetWidth()
        yMax = self.GetGridSizeInPixels().GetHeight()
        for x in range (xc1, xc2 + 1):
            dc.DrawLine(x * self.m_cellWidth * X_UNIT, 0, x * self.m_cellWidth * X_UNIT, yMax)
        for y in range (yc1, yc2 + 1):
            dc.DrawLine(0, y * self.m_cellHeight * Y_UNIT, xMax, y * self.m_cellHeight *Y_UNIT)


        font = wx.Font(14, wx.ROMAN, wx.NORMAL, wx.NORMAL)
        dc.SetFont(font)

        for x in range(xc1, xc2 + 1):
            for y in range(yc1, yc2 + 1):
                if self.m_game.IsMarked(x,y):
                    dc.SetPen (blackPen)

                    if self.m_game.IsFocussed(x, y):
                        dc.SetBrush (focusedBrush)
                    else:
                        dc.SetBrush (greyBrush)

                    dc.DrawRectangle (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, self.m_cellWidth * X_UNIT + 1, self.m_cellHeight * Y_UNIT + 1)
                    buf = "M"
                    if not self.m_game.IsHidden (x, y) and self.m_game.IsBomb(x,y):
                        dc.SetTextForeground(wx.Blue)
                    else:
                        dc.SetTextForeground(wx.Red)

                    dc.SetTextBackground(wx.Grey)
                    chw, chh = dc.GetTextExtent(buf)
                    dc.DrawText (buf, x * self.m_cellWidth * X_UNIT + (self.m_cellWidth * X_UNIT-chw) / 2, y * self.m_cellHeight * Y_UNIT + (self.m_cellHeight * Y_UNIT - chh) / 2 )

                    if not self.m_game.IsHidden(x,y) and self.m_game.IsBomb(x,y):
                        dc.SetPen (redPen)
                        dc.DrawLine (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, (x + 1) * self.m_cellWidth * X_UNIT, (y + 1) * self.m_cellHeight * Y_UNIT)
                        dc.DrawLine (x * self.m_cellWidth * X_UNIT, (y + 1) * self.m_cellHeight * Y_UNIT,   (x + 1) * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT)
                elif self.m_game.IsHidden (x, y):
                    dc.SetPen (blackPen)
                    if self.m_game.IsFocussed (x, y):
                        dc.SetBrush (focusedBrush)
                    else:
                        dc.SetBrush (greyBrush)

                    dc.DrawRectangle (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, self.m_cellWidth * X_UNIT+1, self.m_cellHeight * Y_UNIT + 1)
                elif self.m_game.IsBomb(x,y):
                    dc.SetPen (blackPen)
                    dc.SetBrush (redBrush)
                    dc.DrawRectangle (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, self.m_cellWidth * X_UNIT + 1, self.m_cellHeight * Y_UNIT + 1)
                    buf = "B"
                    dc.SetTextForeground (wx.Black)
                    dc.SetTextBackground (wx.Red)
                    chw, chh = dc.GetTextExtent (buf)
                    dc.DrawText (buf, x * self.m_cellWidth * X_UNIT + (self.m_cellWidth * X_UNIT - chw) / 2, y * self.m_cellHeight * Y_UNIT + (self.m_cellHeight * Y_UNIT - chh) / 2)
                    if self.m_game.IsExploded (x, y):
                        dc.SetPen (bluePen)
                        dc.DrawLine (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, (x + 1) * self.m_cellWidth * X_UNIT, (y + 1) * self.m_cellHeight * Y_UNIT)
                        dc.DrawLine (x * self.m_cellWidth * X_UNIT, (y + 1) * self.m_cellHeight * Y_UNIT, (x + 1) * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT)
                else:   # Display a digit
                    dc.SetPen (blackPen)
                    if self.m_game.IsFocussed (x, y):
                        dc.SetBrush (focusedBrush)
                    else:
                        dc.SetBrush (whiteBrush)
                    dc.DrawRectangle (x * self.m_cellWidth * X_UNIT, y * self.m_cellHeight * Y_UNIT, self.m_cellWidth * X_UNIT + 1, self.m_cellHeight * Y_UNIT + 1)

                    digit_value = self.m_game.Get (x, y) & BG_MASK
                    if digit_value == 0:
                        buf = "0"
                        dc.SetTextForeground (wx.Green)
                    elif digit_value == 1:
                        buf = "1"
                        dc.SetTextForeground (wx.Blue)
                    else:
                        buf = "%d" % digit_value
                        dc.SetTextForeground (wx.Black)
                chw, chh = dc.GetTextExtent (buf)
                dc.SetTextBackground(wx.White)
                dc.DrawText (buf, x * self.m_cellWidth * X_UNIT + (self.m_cellWidth * X_UNIT-chw) / 2, y * self.m_cellHeight * Y_UNIT + (self.m_cellHeight * Y_UNIT-chh) / 2)
        dc.SetFont (wx.NullFont)

        wx.LogStatus ("%d bombs  %d remaining cells" % (self.m_game.GetNumBombs(), self.m_game.GetNumRemainingCells()))

    def RefreshField(self, xc1, yc1, xc2, yc2):
        dc = wx.ClientDC (self)
        self.DrawField (dc, xc1, yc1, xc2, yc2)
        if self.m_bmp:
            memDC = wx.MemoryDC()
            memDC.SelectObject (self.m_bmp)
            self.DrawField (memDC, xc1, yc1, xc2, yc2)
            memDC.SelectObject(wx.NullBitmap)

    def Uncover(self, x, y):
        self.m_game.Unhide (x, y)
        self.RefreshField (x, y, x, y)

        gridWidth = self.m_game.GetWidth()
        gridHeight = self.m_game.GetHeight()

        hasWon = self.m_game.GetNumRemainingCells() == 0
        if self.m_game.IsBomb (x,y) or hasWon:
            wx.Bell()
            if hasWon:
                wx.MessageBox("Nice! You found all the bombs!", "wxWin Bombs", wx.OK | wx.CENTRE)
            else: # x,y is a bomb
                self.m_game.Explode(x, y)

            for x in range (0, gridWidth):
                for y in range (0, gridHeight):
                    self.m_game.Unhide (x, y)
            self.RefreshField (0, 0, gridWidth - 1, gridHeight - 1)
        elif not self.m_game.Get (x, y):
            left = 0
            if x > 0:
                left = x-1

            right = gridWidth - 1
            if x < gridWidth - 1:
                right = x + 1
            top = 0
            if y > 0:
                top = y - 1
            bottom = gridHeight - 1
            if y < gridHeight - 1:
                bottom = y + 1

            for j in range (top, bottom + 1):
                for i in range (left, right + 1):
                    if (i != x or j != y) and self.m_game.IsHidden (i, j) and not self.m_game.IsMarked(i, j):
                        self.Uncover (i, j)

    def OnMouseEvent(self, event):
        gridWidth = self.m_game.GetWidth()
        gridHeight = self.m_game.GetHeight()

        #wx.Coord fx, fy
        fx, fy = event.GetPosition()
        x = fx / (self.m_cellWidth * X_UNIT)
        y = fy / (self.m_cellHeight * Y_UNIT)
        if x < gridWidth and y < gridHeight:
            if ((event.RightDown() or (event.LeftDown() and event.ShiftDown())) or (self.m_game.IsHidden(x,y) and not self.m_game.GetNumRemainingCells())):
                #// store previous and current field
                prevFocusX = self.m_game.m_gridFocusX
                prevFocusY = self.m_game.m_gridFocusY
                self.m_game.m_gridFocusX = x
                self.m_game.m_gridFocusY = y
                self.RefreshField (prevFocusX, prevFocusY, prevFocusX, prevFocusY)
                self.m_game.Mark (x, y)
                self.RefreshField (x, y, x, y)
                return
            elif event.LeftDown() and self.m_game.IsHidden(x,y) and not self.m_game.IsMarked(x,y):
                #// store previous and current field
                prevGridFocusX = self.m_game.m_gridFocusX
                prevGridFocusY = self.m_game.m_gridFocusY
                self.m_game.m_gridFocusX = x
                self.m_game.m_gridFocusY = y
                self.RefreshField (prevGridFocusX, prevGridFocusY, prevGridFocusX, prevGridFocusY)
                self.Uncover(x, y)
                return

    def OnChar(self, event):
        keyCode = event.GetKeyCode()
        prevGridFocusX = self.m_game.m_gridFocusX
        prevGridFocusY = self.m_game.m_gridFocusY

        gridWidth = self.m_game.GetWidth()
        gridHeight = self.m_game.GetHeight()

        if keyCode == wx.WXK_RIGHT:
            self.m_game.m_gridFocusX += 1
            if self.m_game.m_gridFocusX >= gridWidth:
                self.m_game.m_gridFocusX = 0

        elif keyCode == wx.WXK_LEFT:
            self.m_game.m_gridFocusX -= 1
            if self.m_game.m_gridFocusX < 0:
                self.m_game.m_gridFocusX = gridWidth - 1

        elif keyCode == wx.WXK_DOWN:
            self.m_game.m_gridFocusY += 1
            if self.m_game.m_gridFocusY >= gridHeight:
                m_game.m_gridFocusY = 0

        elif keyCode == wx.WXK_UP:
            self.m_game.m_gridFocusY -= 1
            if self.m_game.m_gridFocusY < 0:
                self.m_game.m_gridFocusY = gridHeight - 1

        elif keyCode == wx.WXK_RETURN:
            if ((prevGridFocusX == self.m_game.m_gridFocusX) and (prevGridFocusY == self.m_game.m_gridFocusY) and (self.m_game.IsHidden (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY))):
                self.m_game.Mark (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY)
                if not self.m_game.IsMarked (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY):
                    self.Uncover (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY)
                self.RefreshField (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY, self.m_game.m_gridFocusX, self.m_game.m_gridFocusY)
        else:
            event.Skip()

        if (prevGridFocusX != self.m_game.m_gridFocusX) or (prevGridFocusY != self.m_game.m_gridFocusY):
            # cause focused field to be visible after first key hit after launching new game
            if self.m_game.m_gridFocusX < 0:
                self.m_game.m_gridFocusX = 0
            if self.m_game.m_gridFocusY < 0:
                self.m_game.m_gridFocusY = 0

            # refresh previous field and focused field
            self.RefreshField (prevGridFocusX, prevGridFocusY, prevGridFocusX, prevGridFocusY)
            self.RefreshField (self.m_game.m_gridFocusX, self.m_game.m_gridFocusY, self.m_game.m_gridFocusX, self.m_game.m_gridFocusY)


class BombsFrame (wx.Frame):
    def __init__(self, game, parent = None):
        wx.Frame.__init__(self, None, wx.ID_ANY, "wxBombs", wx.DefaultPosition, wx.Size(300, 300), wx.DEFAULT_DIALOG_STYLE | wx.MINIMIZE_BOX)

        self.m_game = game
        if parent:
            try:
                self.SetIcon(wx.Icon(parent.prefs.pluginsdirectory + "/bitmaps/bombs.ico", wx.BITMAP_TYPE_ICO))
            except:
                pass
        else:
            try:
                self.SetIcon(wx.Icon('bombs.ico', wx.BITMAP_TYPE_ICO))
            except:
                pass


        self.CreateStatusBar()

        # Create a menu bar for the frame
        self.menuBar = wx.MenuBar()
        self.menuFile = wx.Menu()
        self.menuLevel = wx.Menu()
        self.menuLevel.AppendRadioItem(bombsID_EASY, "&Easy (10x10)\tCtrl-1")
        self.menuLevel.AppendRadioItem(bombsID_MEDIUM, "&Medium (15x15)\tCtrl-2")
        self.menuLevel.AppendRadioItem(bombsID_HARD, "&Hard (25x20)\tCtrl-3")

        self.menuFile.AppendMenu(bombsID_NEWGAME, "&New Game",  self.menuLevel, "Starts a new game")

        self.menuFile.AppendSeparator()
        self.menuFile.Append(wx.ID_EXIT, "E&xit", "Quits the application")

        self.menuBar.Append(self.menuFile, "&File")


        self.menuHelp = wx.Menu()
        self.menuHelp.Append (wx.ID_ABOUT, "&About", "Displays the program information")

        self.menuBar.Append(self.menuHelp, "&Help")

        self.SetMenuBar(self.menuBar)

        # Create child subwindows.
        self.m_canvas = BombsCanvas(self, self.m_game)

        # Ensure the subwindows get resized o.k.
        #  OnSize(width, height)

        # Centre frame on the screen.
        self.Centre(wx.BOTH)

        # Show the frame.
        self.Show()

        self.Bind(wx.EVT_MENU, self.OnNewEasyGame, id = bombsID_EASY)
        self.Bind(wx.EVT_MENU, self.OnNewMediumGame, id = bombsID_MEDIUM)
        self.Bind(wx.EVT_MENU, self.OnNewHardGame, id = bombsID_HARD)
        self.Bind(wx.EVT_MENU, self.OnExit, id = wx.ID_EXIT)
        self.Bind(wx.EVT_MENU, self.OnAbout, id = wx.ID_ABOUT)

    def NewGame(self, level, query):
        if query:
            ok = wx.MessageBox ("Start new game regardless previous board?", "Confirm", wx.YES_NO | wx.ICON_QUESTION, self)
            if ok != wx.YES:
                return

        numHorzCells = 20
        numVertCells = 20

        if level == bombsID_EASY:
            numHorzCells = 10
            numVertCells = 10
        elif level == bombsID_MEDIUM:
            numHorzCells = 15
            numVertCells = 15
        elif level == bombsID_HARD:
            numHorzCells = 25
            numVertCells = 20
        else:
            wx.FAIL_MSG("Invalid level")

        self.m_game.Init (numHorzCells, numVertCells)

        self.GetMenuBar().Check(level, True)

        self.m_canvas.UpdateGridSize()
        self.SetClientSize(self.m_canvas.GetGridSizeInPixels())

    def OnNewEasyGame(self, event):
        self.NewGame(bombsID_EASY, True)

    def OnNewMediumGame(self, event):
        self.NewGame(bombsID_MEDIUM, True)

    def OnNewHardGame(self, event):
        self.NewGame(bombsID_HARD, True)

    def OnExit(self, event):
        self.Close()

    def OnAbout(self, event):
        wx.MessageBox("wxBombs (c) 1996 by P. Foggia\n<foggia@amalfi.dis.unina.it>\nTransmitted from wxWidgets to wxPython by Franz Steinhaeusler 2005", "About wxBombs")


class BombsApp (wx.App):

    def OnInit(self, parent = None):
        self.m_game = BombsGame()
        self.m_frame = BombsFrame(self.m_game, parent)
        self.m_frame.NewGame(bombsID_EASY, False)
        return True

def Plugin(DrFrame):

    def OnBombs (event):
        m_game = BombsGame()
        m_frame = BombsFrame(m_game, DrFrame)
        m_frame.NewGame(bombsID_EASY, False)

    try:
        DrFrame.miscmenu
    except:
        #else create
        DrFrame.miscmenu = wx.Menu()
        if DrFrame.PLATFORM_IS_WIN:
            menuBarName = "&Misc"
        else:
            menuBarName = "Misc"
    
        DrFrame.menuBar.Insert(8, DrFrame.miscmenu, menuBarName)

    ID_BOMBS = DrFrame.GetNewId()

    DrFrame.Bind(wx.EVT_MENU, OnBombs, id = ID_BOMBS)

    DrFrame.AddPluginShortcutFunction("Bombs", "Bombs", OnBombs)
    DrFrame.AddPluginPopUpMenuFunction("Bombs", "Bombs", OnBombs)
    DrFrame.LoadPluginShortcuts('Bombs')

    DrFrame.miscmenu.Append(ID_BOMBS, DrFrame.GetPluginMenuLabel('Bombs', 'Bombs', 'Bombs'))

if __name__ == '__main__':
    app = BombsApp(0)
    app.MainLoop()