class DelayMarchBot(Bot):
    """Robot that waits, and then proceeds at a constant pace in a consistent direction"""
    def __init__(self, position, direction=plane.Vector2(1,0), wait_time=0):
        """Constructor sets up the bot with a position, direction, and wait_time"""
        super().__init__(position)
        self.direction = direction
        self.wait_time = wait_time
    def update(self):
        """If wait_time>0, waits. Otherwise, march in a consistent direction"""
        if self.wait_time>0:
            self.wait_time -= 1 # wait for an update cycle
        else:
            self.position += self.direction # after the waiting is done, march!

class PauseMarchBot(Bot):
    """Robot that either waits or marches, based on a random choice"""
    def __init__(self, position, direction=plane.Vector2(1,0)):
        """Constructor sets up the bot with a position and direction"""
        super().__init__(position)
        self.direction = direction
    def update(self):
        """Decides using random.choice whether to pause or march"""
        choice = random.choice(["pause", "march"])
        if choice == "march":
              self.position += self.direction
        # otherwise, if choice == "pause", do nothing
        

        
class TeleportBot(Bot):
    """Stands still 90% of the time. Teleports randomly 10% of the time."""
    
    def __init__(self, position, width=60, height=30):
        """Constructor sets up the bot at given position. Also saves width & height of plane"""
        super().__init__(position)
        self.width = width
        self.height = height
        
    def update(self):
        """Decides using random.choice whether to pause or march"""
        
        # random.random() generates random number between 0 and 1
        if random.random() < 0.9: # 90% chance
            pass # Do nothing
        else: # 10% chance
            # Build a Point2 object for a new, random position
            newpos = plane.Point2(
                random.randrange(self.width),  # random element of range(self.width)
                random.randrange(self.height)
            )
            self.position = newpos

E = RotateEncoder(5)
s = E.encode("Hello world!") # Mjqqt btwqi!
print(s) # Mjqqt btwqi!
print(E.decode(s)) # Hello world!

F = SubstitutionEncoder("lmno","nolm")
s = F.encode("Hello everyone!")
print(s) # Hennm everymle!
print(F.decode(s)) # Hello everyone!

class BaseEncoder():
    """Base class for simple encoders"""
    
    def encode(self, text):
        """Base class returns string unchanged"""
        return text
    
    def decode(self, text):
        """Base class returns string unchanged"""
        return text

    
    
class SubstitutionEncoder():
    """Substitutes one string of text for another"""
    
    def __init__(self, pre, post):
        """Store attributes of characters to be replaced"""
        self.pre = pre
        self.post = post

    def encode(self, text):
        """Encodes the test using the rotate encoder"""
        text_encoded = ""
        for c in text:
            if c in self.pre:
                text_encoded += self.post[self.pre.index(c)] # substitute with the corresponding letter from post
            else:
                text_encoded += c # or add c, unchanged
        return text_encoded

    def decode(self, text):
        """Decodes the text using the rotate encoder"""
        text_decoded = ""
        for c in text:
            if c in self.post:
                text_decoded += self.pre[self.post.index(c)] # substitute with the corresponding letter from pre
            else:
                text_decoded += c # or add c, unchanged
        return text_decoded

    
    
    
class RotateEncoder(SubstitutionEncoder):
    """Encoding rotates alphabet letters forward by a certain number of steps"""
    
    def __init__(self, num_steps):
        """Constructor sets the integer number of steps to rotate by"""

        # Create the alphabet substitution blocks
        abc_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        abc_lower = abc_upper.lower()

        # pre is the alphabet, with all upper/lowercase letters in order
        pre = abc_upper + abc_lower
        # post is a "shuffled" version of the alphabets, offset by n
        post = abc_upper[num_steps:] + abc_upper[:num_steps] + abc_lower[num_steps:] + abc_lower[:num_steps]

        # Use pre and post as inputs in the superclass SubstitutionEncoder constructor
        # Then you don't need to write custom encode/decode functions
        super().__init__(pre, post)

        
        
        
class Rot13Encoder(RotateEncoder):
    """Encoding rotates alphabet letter by 13 steps"""
    
    def __init__(self):
        """Constructor calls super class RotateEncoder with num_steps 13"""

        # Use 13 as input in the superclass RotateEncoder constructor
        # Then you don't need to write custom encode/decode functions
        super().__init__(13)

E = RotateEncoder(5)
s = E.encode("Hello world!") # Mjqqt btwqi!
print(s) # Mjqqt btwqi!
print(E.decode(s)) # Hello world!

F = SubstitutionEncoder("lmno","nolm")
s = F.encode("Hello everyone!")
print(s) # Hennm everymle!
print(F.decode(s)) # Hello everyone!

class WriteOnceDict(dict):
    """
    Dictionary where an existing value cannot be changed.
    """
    def __setitem__(self,k,v):
        "Create new key `k` with value `v`; if `k` is already a key, raise ValueError"
        if k in self:
            raise ValueError("Attempt to change value associated to existing key {}.  This is not allowed by {}.".format(
                k,
                self.__class__.__name__ # name of this class, as a string
            ))
        else:
            super().__setitem__(k,v) # Call `dict` class setitem method
                                     # Note: can't just say self[k]=v since that will call this method!
                                     # Also, super() doesn't allow item assignment, e.g. super()[k]=v fails.
            
d = WriteOnceDict({"first_key":"first_value"}) # Create write once dict containing 1 key and 1 corresponding value
print(d)

d["second_key"] = "second_value" # Verify that we can add a brand new key:value pair without any issues
print(d)

d["second_key"] = "updated_value" # Raises ValueError when we try to rewrite mykey (as expected)