import random
import geometry as geo

def doubles(lista):
    """returns all elements in the list that appear at least twice"""
def intersection(lista, listb):
    """
        returns a list of elements common to both lists.
        Used to find collisions between robots and heaps.
    """

    result = []
    for element in lista:
        if element in listb:
            result.append(element)
    return result

class Location:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __str__(self):
        return "({} {})".format(self.x, self.y)
    def generate_random_locality(geometry):
        return Location(random.randint(0, geometry.width-1),
                        random.randint(0, geometry.height-1))
    def update_location(self, direction, geometry):
        if direction.code == 'N':
            self.y = min(geometry.height-1, self.y+1)
        elif direction.code == 'E':
            self.x = min(geometry.width-1, self.x+1)
        elif direction.code == 'S':
            self.y = max(0, self.y-1)
        elif direction.code == 'W':
            self.x = max(0, self.x-1)
        elif direction.code == 'NE':
            self.y = min(geometry.height-1, self.y+1)
            self.x = min(geometry.width-1, self.x+1)
        elif direction.code == 'NW':
            self.y = min(geometry.height-1, self.y+1)
            self.x = max(0, self.x-1)
        elif direction.code == 'SE':
            self.y = max(0, self.y-1)
            self.x = min(geometry.width-1, self.x+1)
        elif direction.code == 'SW':
            self.y = max(0, self.y-1)
            self.x = max(0, self.x-1)
        elif direction.code == '0':
            pass
        else:
            raise ValueError
    def get(self):
        return self.x, self.y
            
class Direction:
    codes = {'N', 'W', 'E', 'S', 'NW', 'NE', 'SW', 'SE', '0'}
    def __init__(self, code):
        if code in Direction.codes:
            self.code = code
        else:
            raise ValueError
    def __str__(self):
        return "Direction {}".format(self.code)
    def move_towards(mover, aim):
        """determines a robot location mover towards an avatar location aim
           robots now move diagonally
        """
        if mover.x < aim.x and mover.y<aim.y:
            return Direction('NE')
        elif mover.x < aim.x and mover.y==aim.y:
            return Direction('E')
        elif mover.x < aim.x and mover.y>aim.y:
            return Direction('SE')
        elif mover.x==aim.x and mover.y<aim.y:
            return Direction('N')
        elif mover.x==aim.x and mover.y==aim.y:
            return Direction('0')
        elif mover.x==aim.x and mover.y>aim.y:
            return Direction('S')
        elif mover.x>aim.x and mover.y<aim.y:
            return Direction('NW')
        elif mover.x>aim.x and mover.y==aim.y:
            return Direction('W')
        elif mover.x>aim.x and mover.y>aim.y:
            return Direction('SW')

class Avatar:
    def __init__(self, location):
        self.location = location
    def __str__(self):
        return "Avatar at {}".format(self.location)
    def move(self, direction, geometry):
        self.location.update_location(direction, geometry)

class Robot:
    def __init__(self, location):
        self.location = location
    def __str__(self):
        return "Robot at {}".format(self.location)
    def move(self, avatar, geometry):
        direction = Direction.move_towards(self.location, avatar.location)
        self.location.update_location(direction, geometry)

class Heap:
    def __init__(self, location):
        self.location = location
    def __str__(self):
        return "Heap {}".format(self.location)

class Model:
    def __init__(self, geometry, nrrobots):
        self.geometry = geometry
        self.heaps = []
        self.avatar = Avatar(Location.generate_random_locality(geometry))
        self.robots = []
        while len(self.robots)<nrrobots:
            robot = Robot(Location.generate_random_locality(geometry))
            if (robot.location not in [rob.location for rob in self.robots] and
            robot.location != self.avatar.location):
                self.robots.append(robot)
                
    def __str__(self):
        return "{}\n{}\n{}".format(self.avatar,
                                    [str(robot) for robot in self.robots],
                                    [str(heap) for heap in self.heaps])
    
    def update(self, avatar_direction):
        """
        Updates the model based on the direction of the avatar.
        """
        #Deal with a teletransport first
        if avatar_direction=='T':
            while True:
                self.avatar.location = Location.generate_random_locality(self.geometry)
                if (self.avatar.location not in [r.location for r in self.robots] and
                    self.avatar.location not in [h.location for h in self.heaps]):
                    break
            return 0
        #Now we have a normal move
        direction = Direction(avatar_direction)
        self.avatar.move(direction, self.geometry)
        for r in self.robots:
            r.move(self.avatar, self.geometry)
        #check whether a robot has the same location as the avatar
        
        #check whether an avatar has the same location :
        
        #check for robot collisions among themselves
        collisions = doubles([r.location for r in self.robots])
        self.robots = [r for r in self.robots if r.location not in collisions]
        self.heaps += [Heap(loc) for loc in collisions]
        #check for robots colliding with heaps
        
        #done
        return 0
        
        
    


















           
def test():
    print("location tests")
    l1 = Location(5, 3)
    l2 = Location(5, 3)
    l3 = Location(2, 4)
    print(l1, l2, l3)
    print("Should be (5 3) (5 3) (2 4)")
    print(l1 is l1, l1 is l2, l1 == l2, l1 is l3, l1 == l3)
    print("Should be True False True False False")
    print("generate random locality:")
    geometry = geo.Geometry(30, 40)
    for _ in range(3):
        print(Location.generate_random_locality(geometry))
    print("Testing direction")
    try:
        d1 = Direction("EW")
    except ValueError:
        print("passed test")
    d2 = Direction("N")
    print(d2)
    print("Testing Avatar:")
    avatar = Avatar(Location.generate_random_locality(geometry))
    print(avatar)

def interactive_test():
    geometry = geo.Geometry(20, 10)
    location = Location(2,2)
    avatar = Avatar(location)
    robot = Robot(Location(18,18))
    user = ""
    while True:
        try:
            print("avatar:", avatar, "robot:", robot)
            user = input("Direction? ")
            avatar.move(Direction(user), geometry)
            robot.move(avatar, geometry)      
        except ValueError:
            break