# Problem Set 4B
# Name: <your name here>
# Collaborators:
# Time Spent: x:xx

import string

### HELPER CODE ###
def load_words(file_name):
    '''
    file_name (string): the name of the file containing 
    the list of words to load    
    
    Returns: a list of valid words. Words are strings of lowercase letters.
    
    Depending on the size of the word list, this function may
    take a while to finish.
    '''
    print("Loading word list from file...")
    # inFile: file
    inFile = open(file_name, 'r')
    # wordlist: list of strings
    wordlist = []
    for line in inFile:
        wordlist.extend([word.lower() for word in line.split(' ')])
    print("  ", len(wordlist), "words loaded.")
    return wordlist

def is_word(word_list, word):
    '''
    Determines if word is a valid word, ignoring
    capitalization and punctuation

    word_list (list): list of words in the dictionary.
    word (string): a possible word.
    
    Returns: True if word is in word_list, False otherwise

    Example:
    >>> is_word(word_list, 'bat') returns
    True
    >>> is_word(word_list, 'asdf') returns
    False
    '''
    word = word.lower()
    word = word.strip(" !@#$%^&*()-_+={}[]|\:;'<>?,./\"")
    return word in word_list

def get_story_string():
    """
    Returns: a story in encrypted text.
    """
    f = open("story.txt", "r")
    story = str(f.read())
    f.close()
    return story











### END HELPER CODE ###

WORDLIST_FILENAME = 'words.txt'

class Message(object):
    
    def __init__(self, text):
        '''
        Initializes a Message object
                
        text (string): the message's text

        a Message object has two attributes:
            self.message_text (string, determined by input text)
            self.valid_words (list, determined using helper function load_words)
        '''
        
        self.message_text = text # show my input text
        self.valid_words = load_words(WORDLIST_FILENAME) # show all valid words
        
        

    def get_message_text(self):
        '''
        Used to safely access self.message_text outside of the class
        
        Returns: self.message_text
        '''
        return self.message_text


    def get_valid_words(self):
        '''
        Used to safely access a copy of self.valid_words outside of the class.
        This helps you avoid accidentally mutating class attributes.
        
        Returns: a COPY of self.valid_words
        '''
        # copy of list
        copy_valid_words = self.valid_words[:]
        return copy_valid_words


    def build_shift_dict(self, shift):
        '''
        Creates a dictionary that can be used to apply a cipher to a letter.
        The dictionary maps every uppercase and lowercase letter to a
        character shifted down the alphabet by the input shift. The dictionary
        should have 52 keys of all the uppercase letters and all the lowercase
        letters only.        
        
        shift (integer): the amount by which to shift every letter of the 
        alphabet. 0 <= shift < 26

        Returns: a dictionary mapping a letter (string) to 
                 another letter (string). 
        '''
        
        
        # assertion
        assert 0 <= shift < 26, "shift has to be: 0 <= shift < 26" 
        
        # alphabet string
        lowercase = string.ascii_lowercase
        uppercase = string.ascii_uppercase
        
        dict_lower = {}
        for i in range(len(lowercase)):
            if i+shift <= 25:
                dict_lower[lowercase[i]] = lowercase[i+shift]
            elif i+shift > 25:
                dict_lower[lowercase[i]] = lowercase[i+shift-26]
        
        dict_upper = {}
        for i in range(len(uppercase)):
            if i+shift <= 25:
                dict_upper[uppercase[i]] = uppercase[i+shift]
            elif i+shift > 25:
                dict_upper[uppercase[i]] = uppercase[i+shift-26]
        
        dict_final = dict_lower | dict_upper
        return dict_final
        
        

    def apply_shift(self, shift):
        '''
        Applies the Caesar Cipher to self.message_text with the input shift.
        Creates a new string that is self.message_text shifted down the
        alphabet by some number of characters determined by the input shift        
        
        shift (integer): the shift with which to encrypt the message.
        0 <= shift < 26

        Returns: the message text (string) in which every character is shifted
             down the alphabet by the input shift
        '''
        assert 0 <= shift < 26, "shift has to be: 0 <= shift < 26" 
        
        shift_dict = self.build_shift_dict(shift)
        raw_message_text = self.get_message_text()
        new_message_text = ""
        for char in raw_message_text:
            if char in string.ascii_lowercase+string.ascii_uppercase:
                new_message_text = new_message_text + shift_dict[char]
            else:
                new_message_text = new_message_text + char
        
        #return Message(new_message_text)
        return new_message_text
        
        


# Define sub-class

class PlaintextMessage(Message):
    def __init__(self, text, shift):
        '''
        Initializes a PlaintextMessage object        
        
        text (string): the message's text
        shift (integer): the shift associated with this message

        A PlaintextMessage object inherits from Message and has five attributes:
            self.message_text (string, determined by input text)
            self.valid_words (list, determined using helper function load_words)
            self.shift (integer, determined by input shift)
            self.encryption_dict (dictionary, built using shift)
            self.message_text_encrypted (string, created using shift)

        '''
        Message.__init__(self, text) # self.message_text and self.valid_words from parents

        self.shift = shift
        self.encryption_dict = self.build_shift_dict(shift)
        self.message_text_encrypted = self.apply_shift(shift)



    def get_shift(self):
        '''
        Used to safely access self.shift outside of the class
        
        Returns: self.shift
        '''
        
        return self.shift


    def get_encryption_dict(self):
        '''
        Used to safely access a copy self.encryption_dict outside of the class
        
        Returns: a COPY of self.encryption_dict
        '''
        # copy of a dictionary
        copy_encryption_dict = self.encryption_dict.copy()
        return copy_encryption_dict
        
        

    def get_message_text_encrypted(self):
        '''
        Used to safely access self.message_text_encrypted outside of the class
        
        Returns: self.message_text_encrypted
        '''
        
        return self.message_text_encrypted
        
    def change_shift(self, new_shift):
        '''
        Changes self.shift of the PlaintextMessage and updates other 
        attributes determined by shift.        
        
        shift (integer): the new shift that should be associated with this message.
        0 <= shift < 26

        Returns: nothing
        '''
        
        assert 0 <= new_shift < 26, "shift has to be: 0 <= shift < 26" 
        
        # updates other attributes
        self.shift = new_shift
        self.encryption_dict = self.build_shift_dict(new_shift)
        self.message_text_encrypted = self.apply_shift(new_shift)



class CiphertextMessage(Message):
    def __init__(self, text):
        '''
        Initializes a CiphertextMessage object
                
        text (string): the message's text

        a CiphertextMessage object has two attributes:
            self.message_text (string, determined by input text)
            self.valid_words (list, determined using helper function load_words)
        '''
        
        Message.__init__(self, text)


    def decrypt_message(self):
        '''
        Decrypt self.message_text by trying every possible shift value
        and find the "best" one. We will define "best" as the shift that
        creates the maximum number of real words when we use apply_shift(shift)
        on the message text. If s is the original shift value used to encrypt
        the message, then we would expect 26 - s to be the best shift value 
        for decrypting it.

        Note: if multiple shifts are equally good such that they all create 
        the maximum number of valid words, you may choose any of those shifts 
        (and their corresponding decrypted messages) to return

        Returns: a tuple of the best shift value used to decrypt the message
        and the decrypted message text using that shift value
        '''
        
        best_shift_word = {}
        
        for shift_i in range(26):
            words_score = 0
            
            # with each shift value, shift the encrypted message
            decrypt_msg = self.apply_shift(shift_i)
            # split it based on whitespace to create a list of words
            decrypt_msg_word_list = decrypt_msg.split(" ")
            
            # calculate the score of this list of words
            for i in range(len(decrypt_msg_word_list)):
                if is_word(self.get_valid_words(), decrypt_msg_word_list[i]):
                    words_score = words_score + 1
            
            # output a dictionary with {shift value: score}    
            best_shift_word[shift_i] = words_score
        
        # subset the shift value with max(score) in the distionary
        best_shift = max(best_shift_word, key=best_shift_word.get)
        
        # return a tuple (best shift value, decrypted message text)
        final_decrypt_msg = self.apply_shift(best_shift)
        return ((best_shift, final_decrypt_msg))





if __name__ == '__main__':

    #Example test case (PlaintextMessage)
    plaintext = PlaintextMessage('hello', 2)
    print('Expected Output: jgnnq')
    print('Actual Output:', plaintext.get_message_text_encrypted())

    #Example test case (CiphertextMessage)
    ciphertext = CiphertextMessage('jgnnq')
    print('Expected Output:', (24, 'hello'))
    print('Actual Output:', ciphertext.decrypt_message())

    # example: if you type the non-existed word
    story = get_story_string()
    
    ciphertext = CiphertextMessage(story)
    print(ciphertext.decrypt_message())