def option_1():###User enters a sentance to create the light show###
      
        phrase = raw_input("Please enter your phrase ").lower()

        ###Checks the letters in the phrase, then works out the co- ordinates###
        for letter in phrase:
            index  = ord(letter)-65
            #print index ### remove when complete###
            if index > 0:
                x = int(index/8.0)
                #print x ### remove when complete###
                x = x - 4
                y = int(index%8)
                #print (x, y)
                
                UH.clear
                UH.brightness(0.20)
                UH.set_pixel(y, x, 255, 255, 255)
                #UH.set_pixel(x, y, 0, 255, 0)
                UH.show()
                time.sleep(0.5)
                UH.clear()

            elif index <= 0:
                random_sparkle()        

def draw_dot( x1, y1, r1, g1, b1, str1):
  "This draws the dot and outputs some text"
  UH.set_pixel(x1,y1,r1,g1,b1)
  UH.show()
  # print (str1 + str(x1) + ' ' + str(y1))
  time.sleep(0.1)
  return

def drawTile(y, x, value):
    rgb=colour[(index[value])]
    unicorn.set_pixel((x*2),(y*2),rgb[0],rgb[1],rgb[2])
    unicorn.set_pixel((x*2)+1,(y*2),rgb[0],rgb[1],rgb[2])
    unicorn.set_pixel((x*2),(y*2)+1,rgb[0],rgb[1],rgb[2])
    unicorn.set_pixel((x*2)+1,(y*2)+1,rgb[0],rgb[1],rgb[2])
    unicorn.show()

def clearsystem():
    led.clear()
    led.rotation(0)
    os.system("arp -d *")
    os.system("ip neigh flush all")
    led.show()
    return;

def main():
    while True:
        led.clear()
        led.show()
        timestamp = datetime.datetime.now().time()
        if (os.system("ping -c " + p + " 192.168.111.25")) == 0:
            if starttime <= timestamp <= endtime:
                clearsystem()
                if (os.system("ping -c " + p + " " + hosts[1])) == 0:
                    led_reset()
                    led_piping()
                else:
                    led_reset()
                    led_router()
            else:
                if (os.system("ping -c " + p + " " + hosts[8])) == 0:
                    led.clear()
                    sshconnect(hosts[8], "base64-password", "poweroff")
                    led_poweroff(hosts[8])
                    led_reset()
                if (os.system("ping -c " + p + " " + hosts[10])) == 0:
                    led.clear()
                    sshconnect(hosts[10], "base64-password", "poweroff")
                    led_poweroff(hosts[10])
                    led_reset()
                continue
        else:
            led_arrow()
            continue

def paint():
    global last_members
    index = 0
    members = r.find_members()
    if(len(last_members) != len(members)):
        UH.clear()
        UH.show()

    last_members = members
    for member in members:
        temp = r.get_key(member + ".temp")
        baseline = r.get_key(member + ".temp.baseline")
        motion = r.get_key(member + ".motion")

        if safeFloat(motion) > 0:
            if(quiet == False):
                print("moved")
            on(index, 0, 0, 255)
        elif is_hot(temp, baseline):
            on(index, 255, 0, 0)
            if(quiet == False):
                print("HOT")
        else:
            on(index, 0, 255, 0)
        index = index +1

def draw_heart(hue, brightness):
  for x, y in pixels_to_light:
    color = colorsys.hsv_to_rgb(hue, 1, brightness)
    color = [int(c * 255) for c in color]
    r, g, b = color  
    unicorn.set_pixel(x, y, r, g, b)
  unicorn.show()

def fill(r=0,g=255,b=0):
    for x in range(8):
        for y in range(8):
            unicorn.set_pixel(8-x-1, 8-y-1, r, g, b)
            unicorn.show()
            time.sleep(0.05)
    time.sleep(2)

 def display_matrix(max_x, max_y, text=False, r=255, g=255, b=255):
     """
     Display the matrix, either on the unicorn or on the stdout
     :param max_x:
     :param max_y:
     :param text: If True, display on stdout instead of unicornhat. For debugging
     """
     if text:
         for x in range(max_x):
             for y in range(max_y):
                 coordinate_tuple = (x, y)
                 if LifeCell.matrix[coordinate_tuple].current_state == 'alive':
                     print '*',
                 else:
                     print '.',
             print
         print
     else:
         for x in range(max_x):
             for y in range(max_y):
                 coordinate_tuple = (x, y)
                 if LifeCell.matrix[coordinate_tuple].current_state == 'alive':
                     unicorn.set_pixel(x, y, r, g, b)
                 else:
                     unicorn.set_pixel(x, y, 0, 0, 0)
         unicorn.show()

def drawpet(pet):
	for y in range(8):
		for x in range(8):
			#set pixel with color
			r, g, b = pet[y][x]
			unicorn.set_pixel(x,y,r,g,b)
	unicorn.show()

 def __init__(self):
     self._logger = logging.getLogger(self.__class__.__name__)
     self._current_value = self.BLUE
     UH.brightness(1.0)
     pixels = self._set_whole_grid(self._current_value)
     UH.set_pixels(pixels)
     UH.show()

def writePixel(pixel):
   #try:
      #GPIO.setup(int(pin), GPIO.IN)
      #if GPIO.input(int(pin)) == True:
      #   response = "Pin number " + pin + " is high!"
      #else:
      #   response = "Pin number " + pin + " is low!"
   #except:
      #response = "There was an error reading pin " + pin + "."

   color = int(pixel)

   for i in range(0,8):
   	UH.set_pixel(0,i,color,color,color)

   UH.show()

   response="All correct"   

   now = datetime.datetime.now()
   timeString = now.strftime("%Y-%m-%d %H:%M")

   templateData = {
      'title' : 'Status of Pixel' + str(pixel),
      'time': timeString,
      'response' : response
      }

   return render_template('main.html', **templateData)

def go():
    unicorn.brightness(1)
    unicorn.rotation(90)

    wrd_rgb = [[154, 173, 154], [0, 255, 0], [0, 200, 0], [0, 162, 0], [0, 145, 0], [0, 96, 0], [0, 74, 0], [0, 0, 0,]]

    clock = 0

    blue_pilled_population = [[randint(0,7), 7]]
    t_end = time.time() + 10
    while time.time() < t_end:
            for person in blue_pilled_population:
                    y = person[1]
                    for rgb in wrd_rgb:
                            if (y <= 7) and (y >= 0):
                                    unicorn.set_pixel(person[0], y, rgb[0], rgb[1], rgb[2])
                            y += 1
                    person[1] -= 1
            unicorn.show()
            time.sleep(0.1)
            clock += 1
            if clock % 5 == 0:
                    blue_pilled_population.append([randint(0,7), 7])
            if clock % 7 == 0:
                    blue_pilled_population.append([randint(0,7), 7])
            while len(blue_pilled_population) > 100:
                    blue_pilled_population.pop(0)

def option_2():###Select a website to create the light show
        your_webiste_choice = raw_input("Please enter the web address")
        final_address = "http://%s" %(your_webiste_choice)
        print "finding", final_address 
        website = urllib2.urlopen(final_address )
        ##print website.read()

        sentence = website.read()

        print sentence
        
        ###Checks the letters in the website, then works out the co- ordinates###
        for letter in sentence:
            index  = ord(letter)-65
            #print index ### remove when complete###
            if index > 0:
                x = int(index/8.0)
                #print x ### remove when complete###
                #x = x - 4
                y = int(index%8)
                #print (x, y)
                
                UH.clear
                UH.brightness(0.2)
                UH.set_pixel(y, x, 0, 255, 0)
                UH.set_pixel(x, y, 0, 255, 0)
                UH.show()
                time.sleep(0.02)
                UH.clear()

            elif index <= 0:
                random_sparkle()

def load_rainbow(update_rate=5):
    """ A lightly modified version of Pimeroni's "rainbow" example.
    Displays a moving rainbow of colors that increases with load.

    Args:
        update_rate (float): How often to update the load value (seconds).
    """

    i = 0.0
    offset = 30
    function_values[load_fetcher] = 1
    threading.Thread(target=load_fetcher).start()
    while True:
        load_function = function_values[load_fetcher]/10 if function_values[load_fetcher] <= 10 else 10
        for w in range(int(update_rate/0.01)):
            i = i + load_function
            for y in range(height):
                for x in range(function_pos[load_rainbow] + 1):
                    r = 0#x * 32
                    g = 0#y * 32
                    xy = x + y / 4
                    r = (math.cos((x+i)/2.0) + math.cos((y+i)/2.0)) * 64.0 + 128.0
                    g = (math.sin((x+i)/1.5) + math.sin((y+i)/2.0)) * 64.0 + 128.0
                    b = (math.sin((x+i)/2.0) + math.cos((y+i)/1.5)) * 64.0 + 128.0
                    r = max(0, min(255, r + offset))
                    g = max(0, min(255, g + offset))
                    b = max(0, min(255, b + offset))
                    unicorn.set_pixel(x,y,int(r),int(g),int(b))
            unicorn.show()
            time.sleep(0.01)

 def set_build_success(self):
     self.logger.debug("Last build worked !")
     for y in range(8):
         for x in range(8):
             UH.set_pixel(x, y, 0, 255, 0)
             UH.show()
             time.sleep(0.05)

def uh_show_matrix(mat, pause = .075):
    for y in range(len(mat)):
        for x in range(len(mat[0])):
            uh.set_pixel(x, y, mat[x][y][0], mat[x][y][1], mat[x][y][2])
            
    uh.show()
    time.sleep(pause)

def effect():
    # trigger effect
    for i in range(steps_per * 8):
        for y in range(8):
            for x in range(8):              
                r, g, b = background(x, y, i)
                r = int(max(0, min(255, r)))
                g = int(max(0, min(255, g)))
                b = int(max(0, min(255, b)))
                unicorn.set_pixel(x, y, r, g, b)

        unicorn.show()

        time.sleep(0.01)

    for i in range(200):
        v = (math.sin(i / 6.0) + 1.0) / 2.0
        for y in range(8):
            for x in range(8):
                r = 0
                b = 0             
                g = 100
                g *= tick_mask[y][x]
                g *= v
                r = int(max(0, min(255, r)))
                g = int(max(0, min(255, g)))
                b = int(max(0, min(255, b)))
                unicorn.set_pixel(x, y, r, g, b)

        unicorn.show()

        time.sleep(0.02)

def go():
    effects = [tunnel, rainbow_search, checker, swirl]

    unicorn.brightness(1)

    step = 0
    t_end = time.time() + 10
    while time.time() < t_end:
        for i in range(500):
            for y in range(8):
                for x in range(8):              
                    r, g, b = effects[0](x, y, step)
                    if i > 400:
                        r2, g2, b2 = effects[-1](x, y, step)

                        ratio = (500.00 - i) / 100.0
                        r = r * ratio + r2 * (1.0 - ratio)
                        g = g * ratio + g2 * (1.0 - ratio)
                        b = b * ratio + b2 * (1.0 - ratio)
                    r = int(max(0, min(255, r)))
                    g = int(max(0, min(255, g)))
                    b = int(max(0, min(255, b)))
                    unicorn.set_pixel(x, y, r, g, b)

            step += 1
            
            unicorn.show()

            time.sleep(0.01)

        effect = effects.pop()
        effects.insert(0, effect)

 def update(self):
   while True:
     self.t = datetime.datetime.now()
     self.set_hour()
     self.set_min()
     self.set_sec()
     UH.show()