from pygame.sprite import Sprite

from mamba.data import load_image
from mamba.constants import TILE_SIZE
from mamba import mutators


def tile_sizify(pos):
    ts_x, ts_y = TILE_SIZE
    p_x, p_y = pos
    return (ts_x * p_x, ts_y * p_y)


class SpriteImageVariants(object):
    VARIANTS = {
        '....': ('-0', ()),

        'X...': ('-1', (mutators.R90,)),
        '.X..': ('-1', (mutators.R270,)),
        '..X.': ('-1', (mutators.NULL,)),
        '...X': ('-1', (mutators.R180,)),

        'XX..': ('-2o', (mutators.NULL,)),
        '..XX': ('-2o', (mutators.R90,)),

        'X.X.': ('-2a', (mutators.R180,)),
        'X..X': ('-2a', (mutators.R270,)),
        '.XX.': ('-2a', (mutators.R90,)),
        '.X.X': ('-2a', (mutators.NULL,)),

        '.XXX': ('-3', (mutators.R90,)),
        'X.XX': ('-3', (mutators.R270,)),
        'XX.X': ('-3', (mutators.NULL,)),
        'XXX.': ('-3', (mutators.R180,)),

        'XXXX': ('', ()),
        }

    def __init__(self, base_image_name):
        self.base_image_name = base_image_name

    def __call__(self, top, bottom, left, right):
        variant_str = ''.join('X' if d else '.'
                              for d in [top, bottom, left, right])
        variant_suffix, mutators = self.VARIANTS[variant_str]
        return (self.base_image_name + variant_suffix, mutators)


class SolidSpriteImageVariants(SpriteImageVariants):
    VARIANTS = {
        '....': ('-0', ()),

        'X...': ('-1', (mutators.R270,)),
        '.X..': ('-1', (mutators.R90,)),
        '..X.': ('-1', (mutators.NULL,)),
        '...X': ('-1', (mutators.R180,)),

        'XX..': ('', ()),
        '..XX': ('', ()),

        'X.X.': ('-2a', (mutators.R180,)),
        'X..X': ('-2a', (mutators.R90,)),
        '.XX.': ('-2a', (mutators.R270,)),
        '.X.X': ('-2a', (mutators.NULL,)),

        '.XXX': ('', ()),
        'X.XX': ('', ()),
        'XX.X': ('', ()),
        'XXX.': ('', ()),

        'XXXX': ('', ()),
        }


class InvariantSpriteImageVariants(SpriteImageVariants):
    def __call__(self, top, bottom, left, right):
        return (self.base_image_name, ())


class BaseSprite(Sprite):
    tileset = 'common'
    variants_class = InvariantSpriteImageVariants
    variants = None

    def __init__(self, tile_char=None, tileset=None, image_name=None,
                 mutators=(), solid=False):
        super(BaseSprite, self).__init__()
        self.tile_char = tile_char
        self.solid = solid
        if tileset is not None:
            self.tileset = tileset
        if image_name is not None:
            self.image_name = image_name
            self.image = self.load_image(image_name, mutators=mutators)

    def load_image(self, image_name, mutators=()):
        return load_image('tiles/%s/%s.png' % (self.tileset, image_name),
                          mutators)

    def set_tile_pos(self, tile_pos):
        self.tile_pos = tile_pos
        self.rect = self.image.get_rect().move(tile_sizify(tile_pos))

    def get_variant(self, top, bottom, left, right):
        if self.variants is None:
            self.variants = self.variants_class(self.image_name)
        return self.variants(top, bottom, left, right)

    def use_variant(self, *args):
        self.image = self.load_image(*self.get_variant(*args))

    def get_solid(self, snake_mutations):
        return self.solid


class TileSprite(BaseSprite):
    def __init__(self, tileset, **kw):
        kw['tileset'] = tileset
        super(TileSprite, self).__init__(**kw)


class SingleImageTileSprite(TileSprite):

    image_name = None  # subclasses will override this

    def __init__(self, **kw):
        kw.setdefault('image_name', self.image_name)
        super(SingleImageTileSprite, self).__init__(**kw)


class DoorSprite(TileSprite):
    def __init__(self, colour, **kw):
        self.colour = colour
        image_name = 'door_%s' % (colour,)
        kw.setdefault('image_name', image_name)
        super(DoorSprite, self).__init__(**kw)

    def get_solid(self, snake_mutations):
        return self.colour in self.snake_mutations


class EntrySprite(SingleImageTileSprite):
    image_name = 'entrance-1'

    def __init__(self, direction, **kw):
        self.direction = direction
        super(EntrySprite, self).__init__(**kw)


class ExitSprite(SingleImageTileSprite):
    image_name = 'exit-1'


class PuddleSprite(SingleImageTileSprite):
    image_name = 'puddle'
    variants_class = SolidSpriteImageVariants

    def __init__(self, variant=(0, 0, 0, 0), **kw):
        super(PuddleSprite, self).__init__(**kw)
        self.image = self.load_image(*self.get_variant(*variant))


class EdibleTile(SingleImageTileSprite):
    def eat(self):
        self.image = None
        self.solid = False


class BigMouse(EdibleTile):
    image_name = "rat-big"

    def interact(self, snake):
        print "Embiggen!"
        self.eat()


class SmallMouse(EdibleTile):
    image_name = "rat-small"

    def interact(self, snake):
        print "Ensmallen!"
        self.eat()


class Frog(EdibleTile):
    image_name = "frog"

    def interact(self, snake):
        print "Swimmery!"
        self.eat()