Assignment 2 Electric Boogaloo

import turtle #Before we do anything, we must import the turtle module.
import time #imports the time module to add a delay after each text section is printed.
#We need to initialize some flag variables to keep track of possible errors
#error_section_type = False

errors_present = False


header = input()
print('***Header:', header) #Prints the header into the console for clarity.
time.sleep(0.5)
sections = int(input()) #Creates an int variable equal to the number of text/image sections.


line = 1 #creates a variabe to keep track of the line the code is currently on.
i = 1 #initializes a simple counter variable to be used in the while loop below. increments for every section passed:
checksum = 0 #creates a variable to keep track of checksum errors.


while i <= sections: #Creates a while loop. This will repeat until the counter variable is greater than the total number of allowed sections. All of the code will be in here basically.
        checksum = 0     #Resets the checksum variable for the next section counter.
        section_type = input() #Creates a variable to check the current section type. Only 'text' and 'image' will run code, any others will be skipped as seen below:
        if section_type == 'text': #If the section_type variable is 'text', the code will run differently as described below
                while True: #Text will repeat until an 'END' statement breaks the code
                        text_input = input() #Creates a variable 'text_input' to keep track of the current input
                        if text_input == 'END': #If the input is 'END', this signifies the end of this text section. This code will increase the section counter i and break the while loop above
                                i = i+1 #update the number of sections iterated through
                                break
                        checksum = checksum + len(text_input) #updates the checksum variable based on the length of the text supplied
                        print(text_input) #prints the text_input
                text_length = int(input()) #One the loop is broken by the END statement, we need to check for any check_sum errors. The text_length will be set to the value of the expected length as given by the input document
                if checksum != text_length: #If the two do not equal, an error is present somewhere in the code. This will define the expected length and executed length, as well as the section the error is present within.
                        time.sleep(0.5) #adds some delay for aesthetics or something like that
                        print('***Checksum error located for section', i-1)
                        time.sleep(0.5)
                        print('***expected length: ', text_length)
                        errors_present = True #Errors have occurred. This can be updated (if not already)
                time.sleep(1) #delays the code for 1 second using the time module ########################################################################################################################################################################
        elif section_type == 'image': #if the section type is image, the below loop will run. ###STILL NEED RLE SUPPORT AND CHECKSUM!!!!!!!###
                t=turtle.Turtle()  #initiates the turtle module in such a way it can be used using t. instead of turtle.
                t._tracer(500)
                t.reset() #resets the previous image, should one exist
                t.penup() #Just in case the pen happens to be down (which should be impossible but hey better safe than sorry
                image_input = input() #The first two values will be the size of the turtle window provided. We don't have to use loops here as we need to create variables.
                checksum = checksum + len(image_input) #Update the checksum value
                turtle_width = int(image_input) #The first image input is the width of the turtle window
                image_input = input()
                checksum = checksum + len(image_input)
                turtle_height = int(image_input) #The second is the height
                t.screen.setup(height=turtle_height,width=turtle_width) #Set the width and height as such
                t.goto(-turtle_width/2,turtle_height/2) #moves the turtle to the top left corner of the window
                for iteration_height in range(turtle_height): #We'll have a for loop nested in another for loop to build the image row by row
                        x_corr = t.xcor() #saves these values to be manipulate later. This can be used to move the turtle down after the end of a row is complete
                        y_corr = t.ycor()
                        for iteration_width in range(turtle_width): #Number of repetitions is equal to the width of the window.
                                x = t.xcor() #Saves the turtle's corruent position so it can be updated in the statements below
                                y = t.ycor()
                                image_input = input()#saves the input. We are saving this value in order to check the length later
                                turtle_action = int(image_input) #creates an int version of the variable above to update the turtle
                                ##if the text == 'end' we must do SOMETHING!
                                elif turtle_action == 0: #if the input is equal to 0
                                        t.goto(x+1,y) #nothing is needed to be drawn, so we can safely move to the next variable
                                elif turtle_action == 1: #if the input is equal to 1.
                                        t.pendown() #put the pen down to draw...
                                        t.goto(x+1,y) #move exactly one pixel across...
                                        t.penup() #and put the pen back up.
                                else: #If the data is not 0, 1, 'END', or a negative RLE, it is an unknown data type and an error message should be printed
                                        print('***Error - Bad numerical data', turtle_action)
                                        print('***Value ignored, continuing data:')
                        t.goto(x_corr,y_corr-1)

        else: #if the section type is unrecognized
                print('***Unknown section type: "', section_type, ' " - Section', i) #prints error message
                time.sleep(0.5)
                print('***Skipping bad data:')
                errors_present = True #Errors have occurred. This can be updated (if not already)
                while True: #Loops until the input type is 'END' to ignore unusable lines of data
                        bad_section_type = input() #Loops through every line
                        if bad_section_type == 'END': #when the end statement is reached
                                i = i+1 #update the number of sections iterated through
                                break
                        checksum = checksum + len(bad_section_type)
                bad_length = int(input()) #One the loop is broken by the END statement, we need to check for any check_sum errors. The bad_length will be set to the value of the expected length as given by the input document
                if checksum != bad_length: #If the two do not equal, an error is present somewhere in the code. This will define the expected length and executed length, as well as the section the error is present within.
                        time.sleep(0.5) #adds some delay for aesthetics or something like that
                        print('***Checksum error located for Section', i-1)
                        time.sleep(0.5)
                        print('***Expected length:', bad_length)
                        errors_present = True #Errors have occurred. This can be updated (if not already)


print('***End of input')
if errors_present == True:
        print('***Errors were found in the program.')
        #elif section_type == 'image':
       #         #image shit mmhmm yeah baby
        #t=turtle.Turtle() #This allows us to type t. instead of turtle. for every turtle module command.