#!/usr/bin/env python
# -*- mode: python; coding: utf-8; -*-
# ---------------------------------------------------------------------------
#
# Copyright (C) 1998-2003 Markus Franz Xaver Johannes Oberhumer
# Copyright (C) 2003 Mt. Hood Playing Card Co.
# Copyright (C) 2005-2009 Skomoroh
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# ---------------------------------------------------------------------------

from pysollib.game import Game
from pysollib.gamedb import GI, GameInfo, registerGame
from pysollib.hint import AbstractHint
from pysollib.layout import Layout
from pysollib.mygettext import _
from pysollib.pysoltk import MfxCanvasText
from pysollib.stack import \
        OpenTalonStack, \
        ReserveStack, \
        StackWrapper

# ************************************************************************
# * Ishido
# ************************************************************************


class Ishido_Hint(AbstractHint):
    # FIXME: no intelligence whatsoever is implemented here

    def computeHints(self):
        game = self.game
        for r in game.s.rows:
            if (not r.cards and
                    game.isValidPlay(r.id,
                                     game.s.talon.getCard().rank,
                                     game.s.talon.getCard().suit)):
                adjacentPiles = game.getAdjacent(r.id)
                adjacent = 0
                for pile in adjacentPiles:
                    if len(pile.cards) > 0:
                        adjacent += 1
                self.addHint(100 * adjacent, 1, game.s.talon, r)


class Ishido_RowStack(ReserveStack):
    def clickHandler(self, event):
        if (not self.cards and self.game.s.talon.cards and
                self.game.isValidPlay(self.id,
                                      self.game.s.talon.getCard().rank,
                                      self.game.s.talon.getCard().suit)):
            self.game.s.talon.playMoveMove(1, self)
            return 1
        return ReserveStack.clickHandler(self, event)

    rightclickHandler = clickHandler

    def acceptsCards(self, from_stack, cards):
        return not self.cards and self.game.isValidPlay(self.id,
                                                        cards[0].rank,
                                                        cards[0].suit)

    def canFlipCard(self):
        return False


class Ishido_Talon(OpenTalonStack):

    def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
        if self.game.SCORING:
            game = self.game
            old_state = game.enterState(game.S_FILL)
            game.saveStateMove(2 | 16)  # for undo
            game.updateScore(to_stack.id)
            game.saveStateMove(1 | 16)  # for redo
            game.leaveState(old_state)
        OpenTalonStack.moveMove(self, ncards, to_stack, frames=frames,
                                shadow=shadow)


class Ishido(Game):
    Talon_Class = Ishido_Talon
    RowStack_Class = StackWrapper(Ishido_RowStack, max_move=0)
    Hint_Class = Ishido_Hint

    REQUIRE_ADJACENT = True
    STRICT_FOUR_WAYS = True
    SCORING = False

    COLS = 12
    ROWS = 8

    #
    # game layout
    #

    def createGame(self):
        # create layout
        l, s = Layout(self), self.s

        self.score = 0
        self.fourways = 0

        ta = "ss"
        x, y = l.XM, l.YM + 2 * l.YS

        w2 = max(2 * l.XS, x)
        # set window
        w, h = w2 + l.XM * 2 + l.CW * self.COLS, l.YM * 2 + l.CH * self.ROWS
        self.setSize(w, h)

        # Create rows
        for j in range(self.ROWS):
            x, y = w2 + l.XM, l.YM + l.CH * j
            for i in range(self.COLS):
                s.rows.append(self.RowStack_Class(x, y, self))
                x = x + l.CW

        s.talon = self.Talon_Class(l.XM, l.YM, self)
        l.createText(s.talon, anchor=ta)

        # create text
        x, y = l.XM, h - l.YM
        if self.preview <= 1:
            self.texts.score = MfxCanvasText(
                self.canvas, x, y, anchor="sw",
                font=self.app.getFont("canvas_large"))
            x = self.texts.score.bbox()[1][0] + 16

        # define stack-groups
        l.defaultStackGroups()
        return l

    def startGame(self):
        self.score = 0
        self.fourways = 0
        self.moveMove(1, self.s.talon, self.s.rows[0], frames=0)
        self.s.rows[0].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[11], frames=0)
        self.s.rows[11].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[41], frames=0)
        self.s.rows[41].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[54], frames=0)
        self.s.rows[54].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[84], frames=0)
        self.s.rows[84].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[95], frames=0)
        self.s.rows[95].flipMove()
        self.s.talon.fillStack()

    def isGameWon(self):
        return len(self.s.talon.cards) == 0

    def _shuffleHook(self, cards):
        # prepare first cards
        symbols = []
        colors = []
        topcards = []
        for c in cards[:]:
            if c.suit not in colors and c.rank not in symbols:
                topcards.append(c)
                cards.remove(c)
                symbols.append(c.rank)
                colors.append(c.suit)
                if len(colors) >= 6 or len(symbols) >= 6:
                    break
        return cards + topcards

    def isValidPlay(self, playSpace, playRank, playSuit):
        # check that there's an adjacent card
        adjacent = self.getAdjacent(playSpace)
        rankMatches = 0
        suitMatches = 0
        totalMatches = 0
        for i in adjacent:
            if len(i.cards) > 0:
                totalMatches += 1
                if i.cards[-1].rank == playRank:
                    rankMatches += 1
                if i.cards[-1].suit == playSuit:
                    suitMatches += 1

                if i.cards[-1].suit != playSuit and \
                        i.cards[-1].rank != playRank:
                    return False

        if self.REQUIRE_ADJACENT and totalMatches == 0:
            return False

        if self.STRICT_FOUR_WAYS:
            if totalMatches > 1 and (rankMatches == 0 or suitMatches == 0):
                return False
            if totalMatches == 4 and (rankMatches < 2 or suitMatches < 2):
                return False

        return True

    def updateScore(self, playSpace):
        if len(self.s.talon.cards) == 3:
            self.score += 100
        elif len(self.s.talon.cards) == 2:
            self.score += 400
        elif len(self.s.talon.cards) == 1:
            self.score += 500

        if playSpace % 12 in (0, 11):
            return 0

        if playSpace + 12 > 96 or playSpace - 12 < -1:
            return 0

        adjacentPiles = self.getAdjacent(playSpace)
        adjacent = 0
        for pile in adjacentPiles:
            if len(pile.cards) > 0:
                adjacent += 1
        if adjacent >= 4:
            movescore = 8 + 25
        elif adjacent == 3:
            movescore = 4
        else:
            movescore = adjacent

        movescore *= (1 + self.fourways)

        if adjacent >= 4:
            self.fourways += 1

        self.score += movescore

    def updateText(self):
        if self.preview > 1 or not self.texts.score or not self.SCORING:
            return
        t = _("Points: %d") % self.score
        self.texts.score.config(text=t)

    def getGameScore(self):
        return self.score

    def _restoreGameHook(self, game):
        self.score = game.loadinfo.score
        self.fourways = game.loadinfo.fourways

    def _loadGameHook(self, p):
        self.loadinfo.addattr(score=p.load())
        self.loadinfo.addattr(fourways=p.load())

    def _saveGameHook(self, p):
        p.dump(self.score)
        p.dump(self.fourways)

    def setState(self, state):
        # restore saved vars (from undo/redo)
        self.score = state[0]
        self.fourways = state[1]

    def getState(self):
        # save vars (for undo/redo)
        return [self.score, self.fourways]

    def getAdjacent(self, playSpace):
        adjacentRows = []
        if playSpace % self.COLS != self.COLS - 1:
            adjacentRows.append(self.s.rows[playSpace + 1])

        if playSpace % self.COLS != 0:
            adjacentRows.append(self.s.rows[playSpace - 1])

        if playSpace + self.COLS < (self.COLS * self.ROWS):
            adjacentRows.append(self.s.rows[playSpace + self.COLS])

        if playSpace - self.COLS > -1:
            adjacentRows.append(self.s.rows[playSpace - self.COLS])

        return adjacentRows


class IshidoRelaxed(Ishido):
    STRICT_FOUR_WAYS = False


class FreeIshido(Ishido):
    REQUIRE_ADJACENT = False


class FreeIshidoRelaxed(Ishido):
    STRICT_FOUR_WAYS = False
    REQUIRE_ADJACENT = False


class IshidoScored(Ishido):
    SCORING = True


class LittleIshido(Ishido):
    ROWS = 6
    COLS = 8

    def startGame(self):
        self.score = 0
        self.fourways = 0
        self.moveMove(1, self.s.talon, self.s.rows[0], frames=0)
        self.s.rows[0].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[7], frames=0)
        self.s.rows[7].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[40], frames=0)
        self.s.rows[40].flipMove()
        self.moveMove(1, self.s.talon, self.s.rows[47], frames=0)
        self.s.rows[47].flipMove()
        self.s.talon.fillStack()

    def _shuffleHook(self, cards):
        # prepare first cards
        symbols = []
        colors = []
        topcards = []
        for c in cards[:]:
            if c.suit not in colors and c.rank not in symbols:
                topcards.append(c)
                cards.remove(c)
                symbols.append(c.rank)
                colors.append(c.suit)
                if len(colors) >= 4 or len(symbols) >= 4:
                    break
        return cards + topcards

class LittleIshidoRelaxed(LittleIshido):
    STRICT_FOUR_WAYS = False


def r(id, gameclass, name, decks, redeals, skill_level,
        game_type=GI.GT_ISHIDO, colors=6):
    gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
                  ranks=list(range(colors)), suits=list(range(colors)),
                  category=GI.GC_ISHIDO)
    registerGame(gi)
    return gi


r(18000, Ishido, 'Ishido', 2, 0, GI.SL_MOSTLY_SKILL)
r(18001, IshidoRelaxed, 'Ishido Relaxed', 2, 0, GI.SL_MOSTLY_SKILL)
r(18002, FreeIshido, 'Free Ishido', 2, 0, GI.SL_MOSTLY_SKILL)
r(18003, FreeIshidoRelaxed, 'Free Ishido Relaxed', 2, 0, GI.SL_MOSTLY_SKILL)
r(18004, IshidoScored, 'Ishido Scored', 2, 0, GI.SL_MOSTLY_SKILL,
  game_type=GI.GT_ISHIDO | GI.GT_SCORE)
r(18005, LittleIshido, 'Little Ishido', 2, 0, GI.SL_MOSTLY_SKILL, colors=4)
r(18006, LittleIshidoRelaxed, 'Little Ishido Relaxed', 2, 0,
  GI.SL_MOSTLY_SKILL, colors=4)