import pygame
import pygame.locals

def load_tile_table(filename, width, height):
    image = pygame.image.load(filename).convert()
    image_width, image_height = image.get_size()
    tile_table = []
    for tile_x in range(0, int(image_width/width)):
        line = []
        tile_table.append(line)
        for tile_y in range(0, int(image_height/height)):
            rect = (tile_x*width, tile_y*height, width, height)
            line.append(image.subsurface(rect))
    return tile_table


if __name__=='__main__':
    pygame.init()
    screen = pygame.display.set_mode((500, 500))
    screen.fill((255, 255, 255))
    table = load_tile_table("tiles.png", int(16), int(16))
    print (table)
    screen.blit(table[0][0], (int(0), int(0)))
    screen.blit(table[1][0], (int(24), int(0)))
    pygame.display.flip()
    while pygame.event.wait().type != pygame.locals.QUIT:
        pass


OP = (0, 1)
NED = (0, -1)
VENSTRE = (-1, 0)
HOJRE = (1, 0)

robot = {
    OP: 'A',
    NED: 'V',
    VENSTRE: '<',
    HOJRE: '>',
}

MUR = 'm'
TOM = '.'
ROBOT = 'r'
TARGET = 't'

def _v(retning):
    dx, dy = retning
    return -dy, dx

def _h(retning):
    dx, dy = retning
    return dy, -dx


def plus(xy, dxy):
    x, y = xy
    dx, dy = dxy
    return (x+dx, y+dy)

class ConsoleRenderer(object):
    def __init__(self):
        self.blocks = dict()
        self.x_size = 10
        self.y_size = 10

    def set_block(self, position, blok):
        self.blocks[position] = blok

    def vis(self):
        lines = list()
        for y in range(self.y_size):
            lines.append("".join(self.blocks.get((x, y), TOM) for x in range(self.x_size)))
        print("\r".join(reversed(lines)))

    def vis_kig(self, position, til_position):
        print("Kigger på {0}".format(til_position))

    def vis_flyt(self, position):
        print("Flytter til {0}".format(position))

    def vis_drej(self, position, retning, ):
        pass


class Level(object):
    def __init__(self):
        self.x_size = 10
        self.y_size = 10
        self.blocks = dict()
        self.spawn = (0, 0)
        self.target = (9, 9)

    def __getitem__(self, position):
        x, y = position
        if x < 0 or y < 0 or x >= self.x_size or y >= self.y_size:
            return MUR
        return self.blocks.get(position, TOM)

    def __setitem__(self, position, blok):
        self.blocks[position] = blok


class Robot(object):
    def __init__(self, level, renderer):
        self.level = level
        self.retning = OP
        self.position = level.spawn
        self.renderer = renderer
        self.scan()

    def scan(self):
        for y in range(self.level.y_size):
            for x in range(self.level.x_size):
                self.renderer.set_block((x, y), self.kig((x,y)))
        self.renderer.vis()

    def flyt(self, til_position=None):
        til_position = til_position or plus(self.position, self.retning)
        if self.kig(til_position, vis=False) == MUR:
            self.renderer.vis_bump(self.position, til_position)
            return False
        else:
            fra_position = self.position
            self.position = til_position
            self.renderer.vis_flyt(fra_position, til_position)
            return True

    def kig_frem(self):
        print("kig_frem")
        return self.kig(plus(self.position, self.retning))

    def kig_venstre(self):
        print("kig_venstre")
        return self.kig(plus(self.position, _v(self.retning)))

    def kig_hojre(self):
        print("kig_hojre")
        return self.kig(plus(self.position, _h(self.retning)))

    def drej_venstre(self):
        print("drej_venstre")
        ny_retning = _v(self.retning)
        self.renderer.vis_drej(self.position, self.retning, ny_retning)
        self.retning = ny_retning

    def drej_hojre(self):
        print("drej_hojre")
        ny_retning = _h(self.retning)
        self.renderer.vis_drej(self.position, self.retning, ny_retning)
        self.retning = ny_retning

    def kig(self, position, retning=(0,0), vis=True):
        position = plus(position, retning)
        self.renderer.vis_kig(self.position, position)
        if position == self.level.target:
            return TARGET
        elif position == self.position:
            return robot[self.retning]
        else:
            return self.level[position] or '!'

def f():

    level = Level()
    level[1, 0] = MUR

    robot = Robot(level, ConsoleRenderer())
    turn = 0
    done = False
    while turn < 100 and not done:
        if robot.kig_venstre() == MUR:
            if robot.kig_frem() != MUR:
                robot.flyt()
            elif robot.kig_frem() == MUR:
                robot.drej_hojre()
        elif robot.kig_venstre() != MUR:
            robot.drej_venstre()
        turn += 1
        done = robot.position == robot.level.target
    print(done)