#!/usr/bin/python
# -*- encoding: utf-8 -*-

from __future__ import print_function
import httplib2
import os
import subprocess
from subprocess import call
from time import strftime
import sys

from PIL import Image, ImageDraw
from samplebase import SampleBase
from rgbmatrix import RGBMatrix, RGBMatrixOptions, graphics
import time
import datetime

import pyowm
from pyowm import OWM
from pyowm import timeutils
from pyowm.exceptions import OWMError
import argparse

import pickle # NEW
import os.path # NEW
#from apiclient.discovery import build
from googleapiclient.discovery import build # NEW

#from httplib2 import Http
#from oauth2client import file, client, tools
from google_auth_oauthlib.flow import InstalledAppFlow # NEW
from google.auth.transport.requests import Request # NEW

import pygame
import feedparser
import RPi.GPIO as GPIO

from random import randrange

pygame.mixer.init()
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
pir_sensor = 15
shutdown_channel = 14
audio_channel = 21
GPIO.setup(pir_sensor, GPIO.IN)
GPIO.setup(shutdown_channel, GPIO.IN, GPIO.PUD_DOWN)
GPIO.setup(audio_channel, GPIO.OUT)
GPIO.setup(2, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(3, GPIO.IN, pull_up_down=GPIO.PUD_UP)


#try:
#    import argparse
#    flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()
#except ImportError:
#    flags = None

# If modifying these scopes, delete your previously saved credentials
# at ~/.credentials/calendar-python-quickstart.json
SCOPES = 'https://www.googleapis.com/auth/calendar.readonly'
#store = file.Storage('/home/pi/credentials.json')
#creds = store.get()
creds = None # NEW
if os.path.exists('token.pickle'):			#NEW
	with open('token.pickle', 'rb') as token:	#NEW
        	creds = pickle.load(token)		#NEW

#if not creds or creds.invalid:
#	flow = client.flow_from_clientsecrets('client_secret.json', SCOPES)
#	creds = tools.run_flow(flow, store)
##################NEW##############
if not creds or not creds.valid:
	if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

#service = build('calendar', 'v3', http=creds.authorize(Http()))
service = build('calendar', 'v3', credentials=creds)

###################################################
metexemin=[2,32]
calexemin=[5,37]
rssmin=[11]
	   
API_key = '********************************'
owm = pyowm.OWM(API_key)

dizionario = {'200':"TEMPORALI CON PIOGGIA LEGGERA",'201':"TEMPORALE CON PIOGGIA",
                '202':"TEMPORALE CON PIOGGIA PESANTE",'210':"LEGGERI TEMPORALI",
                '211':"TEMPORALI",'212':"TEMPORALE INTENSO", '221':"TEMPORALI IRREGOLARI",
                '230':"TEMPORALE CON PIOGGIA LEGGERA",'231':"TEMPORALI CON PIOGGE",
                '232':"TEMPORALE CON PIOGGE PESANTI", '300':"PIOVIGGINE DI LEGGERA INTENSITA",
                '301':"PIOVIGGINE",'302':"PIOVIGGINE DI INTENSITA PESANTE",'310':"FINE PIOVIGGINE DI LEGGERA INTENSITA",'311':"FINE PIOVIGGINE",
                '312':"FINE PIOVIGGINE DI PESANTE INTENSITA",'313':"ACQUAZZONI E PIOVIGGINE",
                '314':"PESANTI ACQUAZZONI E PIOVIGGINE",'321':"SCROSCI DI PIOVIGGINE",
                '500':"PIOGGIA LEGGERA",'501':"PIOGGIA MODERATA",'502':"PIOGGIA DI FORTE INTENSITA",
                '503':"PIOGGIA MOLTO PESANTE",'504':"PIOGGIA ESTREMA",'511':"GRANDINE",
                '520':"ACQUAZZONI DI LEGGERA INTENSITA",'521':"ACQUAZZONI",'522':"ACQUAZZONI DI PESANTE INTENSITA",
                '531':"ACQUAZZONI IRREGOLARI",'600':"LEGGERE NEVICATE",'601':"NEVICATE",
                '602':"FORTI NEVICATE",'611':"NEVISCHIO",'612':"NEVISCHIO A SCROSCI",
                '615':"PIOGGIA LEGGERA E NEVE",'616':"PIOGGIA E NEVE",'620':"LEGGERE NEVICATE",
                '621':"NEVICATE",'622':"PESANTI NEVICATE",'701':"BANCHI DI NEBBIA",'711':"FUMO",
                '721':"FOSCHIA",'731':"SABBIA, TURBINI DI POLVERE",'741':"NEBBIA",
                '751':"SABBIA",'761':"POLVERE",'762':"CENERE VULCANICA",'771':"BURRASCHE",
                '781':"TORNADO",'800':"CIELO SERENO",'801':"SCARSA NUVOLOSITA",
                '802':"NUBI SPARSE",'803':"BANCHI DI NUBI",'804':"COPERTO",'900':"TORNADO",
                '901':"TEMPESTA TROPICALE",'902':"URAGANO",'903':"FREDDO INTENSO",
                '904':"CALDO INTENSO",'905':"VENTO INTENSO",'906':"INTENSE GRANDINATE",
                '951':"SERENO",'952':"BREZZA LEGGERA",'953':"BREZZA LIEVE",'954':"BREZZA MODERATA",
                '955':"BREZZA FRESCA",'956':"FORTE BREZZA",'957':"VENTO FORTE, TENDENTE A BURRASCA",
                '958':"BURRASCA",'959':"VIOLENTA BURRASCA",'960':"TEMPESTA",'961':"TEMPESTA VIOLENTA",
                '962':"URAGANO"}

available_options = {'1':"timer",'2':"owm",'3':"calendar",'4':"ansa",'5':"exit",'6':"shutdown",'7':"magic",'8':"reboot"}


magicball = ["Per quanto posso vedere, si","E' certo","E' decisamente cosi","Molto probabilmente","Le prospettive sono buone","I segni indicano di si","Senza alcun dubbio","Si","Si, senza dubbio","Ci puoi contare",
                "E' difficile rispondere, prova di nuovo","Rifai la domanda piu tardi","Meglio non risponderti adesso","Non posso predirlo ora","Concentrati e rifai la domanda","Non ci contare","La mia risposta e' no",
                "Le mie fonti dicono di no","Le prospettive non sono buone","Molto incerto","E' una questione di culo"]

wd_italian = {"0":"lun","1":"mar","2":"mer","3":"gio","4":"ven","5":"sab","6":"dom"}
month_italian = {"1":"gen","2":"feb","3":"mar","4":"apr","5":"mag","6":"giu","7":"lug","8":"ago","9":"set","10":"ott","11":"nov","12":"dic"}

alertmeteoelenco = [202,212,232,314,502,503,504,511,600,601,602,621,622,701,721,711,741,731,761,762,771,781,900,901,902,903,904,905,906,957,958,959,960,961,962]

keysound=['/home/pi/dbsounds/click.mp3','/home/pi/dbsounds/clickenter.mp3']

allarme = 0

options = RGBMatrixOptions()
options.rows = 16
options.chain_length = 2
options.parallel = 2
options.hardware_mapping = 'regular'
options.brightness = 70
options.pwm_bits = 8
options.gpio_slowdown = 3
matrix = RGBMatrix(options = options)
font = graphics.Font()

eventsTOD=None
eventsTOM=None
events=[]

meteoactive=False
display_on = False

def dirvento(direzione):
        if (direzione<=23):return "NORD"
        if (direzione<=68):return "NORDEST"
        if (direzione<=113):return "EST"
        if (direzione<=158):return "SUDEST"
        if (direzione<=203):return "SUD"
        if (direzione<=251):return "SUDOVEST"
        if (direzione<=293):return "OVEST"
        if (direzione<=337):return "NORDOVEST"
        if (direzione<=360):return "NORD"
        if (direzione==361):return "N/D"

def getevents():
	try:
		global eventsTOD
		global eventsTOM
		#global events
		dom = datetime.datetime.now()
		dot = dom + datetime.timedelta(days=1) # quanti giorni avanti
		now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time
		ho = dom.strftime("%Y-%m-%dT00:00:00.000000Z")
		dn = dom.strftime("%Y-%m-%dT23:59:00.000000Z")
		he = dot.strftime("%Y-%m-%dT00:00:00.000000Z")
		ht = dot.strftime("%Y-%m-%dT23:59:00.000000Z")
		eventsResultTOD = service.events().list(calendarId='primary', timeMin=ho, timeMax=dn, maxResults=10, singleEvents=True,orderBy='startTime').execute()
		eventsResultTOM = service.events().list(calendarId='primary', timeMin=he, timeMax=ht, maxResults=10, singleEvents=True,orderBy='startTime').execute()
                eventsTOD = eventsResultTOD.get('items', [])
                eventsTOM = eventsResultTOM.get('items', [])
		#eventsResult = service.events().list(calendarId='primary', timeMin=now, maxResults=5, singleEvents=True, orderBy='startTime').execute()
                #events = eventsResult.get('items', [])
	except httplib2.ServerNotFoundError as err:
                f = open("/home/pi/googex.txt","w+")
                errore = str(err)
                f.write(errore)
                f.close()
                time.sleep(3)
	except:
                f = open("/home/pi/googex.txt","w+")
                errore = "ERRORE SCONOSCIUTO"
                info_0 = str(sys.exc_info()[0])
                info_1 = str(sys.exc_info()[1])
                info_2 = str(sys.exc_info()[2])
                f.write(errore)
                f.close()
                time.sleep(60)
		pass

def calendarevents():
		time.sleep(1)
		global meteoactive
 		eventoincorso=""
 		reminder=""
		roberto = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
        	luisa = datetime.datetime.strptime(roberto, '%Y-%m-%d %H:%M')
        	leo = luisa + datetime.timedelta(hours=1)
	        trm = luisa + datetime.timedelta(minutes=2) # let meteo scrolling
    		meteoactive = False
    		for event in eventsTOD:
			try:
	        		start = event['start'].get('dateTime', event['start'].get('date'))
        			auc = (event['start'].get('dateTime'))
        			aoc = datetime.datetime.strptime(auc[:19], "%Y-%m-%dT%H:%M:%S")
        			aocr=datetime.datetime.strptime(auc[:19], "%Y-%m-%dT%H:%M:%S")
        			if (luisa == aoc):
                			eventoincorso =  " * " + event['summary'] + " * " + eventoincorso
        			if (leo == aocr):
                			reminder = " * " + event['summary'] + " * " + reminder
        			if (luisa < aoc <= trm):
                			meteoactive = True
			except TypeError:
				print("EVENTO GIORN")
				pass
    		bir = datetime.datetime.now().strftime("%H:%M")
    		kir = leo.strftime("%H:%M")
    		if eventoincorso: 
			GPIO.output(audio_channel, GPIO.HIGH)
			interludenotification()
			for x in range (4):
				notification("EVENTO", bir, eventoincorso)
			GPIO.output(audio_channel, GPIO.LOW)
    		if reminder: 
			GPIO.output(audio_channel, GPIO.HIGH)
			interludereminder()
			for x in range (4):
				notification("REMINDER", kir, reminder)
			GPIO.output(audio_channel, GPIO.LOW)

def caleventlist():
        	for event in eventsTOD:
			try:
                		start = event['start'].get('dateTime', event['start'].get('date'))
                		#coso=datetime.datetime.strptime(start[:19], "%Y-%m-%dT%H:%M:%S")
				auc = (event['start'].get('dateTime'))
		                coso=datetime.datetime.strptime(auc[:19], "%Y-%m-%dT%H:%M:%S")
                		evt=coso.strftime("%H:%M")
                		evdesc=event['summary']
				day = "OGGI "
				calendarlist(day, evt, evdesc)
			except TypeError:
                                #print("EVENTO GIORN")
                                pass
		#print(eventsTOD)
        	if not eventsTOD:
			day = "OGGI "
			evt = ""
			evdesc = "NESSUN EVENTO"
			calendarlist(day, evt, evdesc)
        	for event in eventsTOM:
			try:
	                	start = event['start'].get('dateTime', event['start'].get('date'))
        	        	#coso=datetime.datetime.strptime(start[:19], "%Y-%m-%dT%H:%M:%S")
		                auc = (event['start'].get('dateTime'))
 		                coso=datetime.datetime.strptime(auc[:19], "%Y-%m-%dT%H:%M:%S")
                 		evt=coso.strftime("%H:%M")
                		evdesc=event['summary']
				day = "DOMANI "
                		calendarlist(day, evt, evdesc)
			except TypeError:
				#print("EVENTO GIORN")
                                pass
		print(eventsTOM)
        	if not eventsTOM:
			day = "DOMANI "
                	evt = ""
                	evdesc = "NESSUN EVENTO"
                	calendarlist(day, evt, evdesc)

def getweather():
	global umidita, temperatura, metora, vento, velocita, allarme, dirwind, metora3h, metorah9
	try:
	        obs = owm.weather_at_place('Napoli,IT')
		w = obs.get_weather()
        	fc = owm.three_hours_forecast('Napoli,IT')
        	f = fc.get_forecast()
        	domani=timeutils.tomorrow(9,0)
        	treore=timeutils.next_three_hours()
        	umidita = w.get_humidity()
        	temperatura = int(round((w.get_temperature('celsius'))['temp']))
        	metora = w.get_weather_icon_name().decode('utf8')[:-1]
        	vento = w.get_wind()
        	velocita = int(round(vento['speed']*3.6))   #conversion from m/s to Km/h
        	allarme = w.get_weather_code()
        	metora3h = fc.get_weather_at(treore)._weather_code
        	metorah9 = fc.get_weather_at(domani)._weather_code

	except OWMError as err:
		f = open("/home/pi/owmex.txt","w+")
		timenow = datetime.datetime.now()
		errore = str(err) + " " + str(timenow)
		f.write(errore)
		f.close()
		time.sleep(60)
		pass
	except:
		f = open("/home/pi/owmex.txt","w+")
                errore = "ERRORE SCONOSCIUTO"
		info_0 = str(sys.exc_info()[0])
		info_1 = str(sys.exc_info()[1])
		info_2 = str(sys.exc_info()[2])
                f.write(errore)
                f.close()
                time.sleep(60)
	try:
                direzione = int(round(vento['deg']))
        except:
                direzione = 361
	dirwind = dirvento(direzione)

def currentweatherconditions():
	if (allarme in alertmeteoelenco):
		weatalert = "***** ALLERTAMETEO ****** "
		interludealert()
	else:
		weatalert = ""
	current = dizionario.get(str(allarme))
	forecast = weatalert + str(current) + "   TEMP: " + str(temperatura) + "C   UMIDITA: " + str(umidita) + "%  VENTO: " + str(velocita)+ " Kmh da: " + dirwind
	when = "CONDIZIONI"
	foretime = "  ATTUALI"
	weatherlist(when, foretime, forecast)

def threehrsfc():
	if (metora3h in alertmeteoelenco):
		weatalert = "***** ALLERTAMETEO ****** "
		interludealert()
        else:
                weatalert = ""
	h3fc = dizionario.get(str(metora3h))
	when  = "PREVISIONI"
	foretime = "  3 ORE"
	forecast = weatalert + str(h3fc)
	weatherlist(when, foretime, forecast)

def tomorrowfc():
	if (metorah9 in alertmeteoelenco):
		weatalert = "***** ALLERTAMETEO ****** "
		interludealert()
        else:
                weatalert = ""
        h9fc = dizionario.get(str(metorah9))
        when  = "PREVISIONI"
        foretime = "DOMANI ORE 9"
        forecast = weatalert + str(h9fc)
        weatherlist(when, foretime, forecast)

def notification(kind, eventime, eventdescription):
        offscreen_canvas = matrix.CreateFrameCanvas()
        font1 = graphics.Font()
        font2 = graphics.Font()
        font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x14.bdf")
        font2.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x7.bdf")
        textColor = graphics.Color(255, 0, 0)
        textColor1 = graphics.Color(255, 255, 255)
        pos = offscreen_canvas.width
	reptime = False
        while not reptime: 
            offscreen_canvas.Clear()
            len = graphics.DrawText(offscreen_canvas, font1, pos, 30, textColor, eventdescription)
            lon = graphics.DrawText(offscreen_canvas, font2, 16, 8, textColor1, kind)
            lun = graphics.DrawText(offscreen_canvas, font2, 20, 16, textColor1, eventime)
            pos -= 1
            if (pos + len < 0):
		reptime = True
                pos = offscreen_canvas.width

            time.sleep(0.02)
            offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)

def calendarlist(day, evt, evdesc):
        offscreen_canvas = matrix.CreateFrameCanvas()
        font1 = graphics.Font()
        font2 = graphics.Font()
        font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x14.bdf")
        font2.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x7.bdf")
        textColor = graphics.Color(51, 255, 153)
        textColor1 = graphics.Color(51, 51, 255)
        pos = offscreen_canvas.width
	article = "ALLE "
	if (evdesc == "NESSUN EVENTO"):
		article = ""
        testo= day + article 
	reptime = False
	while not reptime:
      		offscreen_canvas.Clear()
      		len = graphics.DrawText(offscreen_canvas, font1, pos, 30, textColor, evdesc)
       		lon = graphics.DrawText(offscreen_canvas, font2, 6, 8, textColor1, testo)
       		lun = graphics.DrawText(offscreen_canvas, font2, 20, 16, textColor1, evt)
       		pos -= 1
       		if (pos + len < 0):
			reptime = True
               		pos = offscreen_canvas.width
        	time.sleep(0.02)
        	offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)

def rss():
	d = feedparser.parse('http://www.ansa.it/sito/notizie/topnews/topnews_rss.xml')
	str=""
	for count in range(0,9): # i primi 10 post
                str=d.entries[count].title + " - " + str
	offscreen_canvas = matrix.CreateFrameCanvas()
	font1 = graphics.Font()
        font2 = graphics.Font()
	font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x14.bdf")
        font2.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x7.bdf")
	textColor1 = graphics.Color(0, 153, 0)
	textColor = graphics.Color(255, 255, 255)
	pos = offscreen_canvas.width
	reptime=False
	my_text = "NEWS DELLE"
	my_text1 = datetime.datetime.now().strftime("%H:%M")
	while not reptime:
                offscreen_canvas.Clear()
                len = graphics.DrawText(offscreen_canvas, font1, pos, 30, textColor, str)
                lon = graphics.DrawText(offscreen_canvas, font2, 8, 8, textColor1, my_text)
		lun = graphics.DrawText(offscreen_canvas, font2, 20, 16, textColor1, my_text1)
                pos -= 1
                if (pos + len < 0):
                        reptime = True
			pos = offscreen_canvas.width
		time.sleep(0.02)
                offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)	

def weatherlist(when, foretime, forecast):
        offscreen_canvas = matrix.CreateFrameCanvas()
        font1 = graphics.Font()
        font2 = graphics.Font()
        font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x14.bdf")
	font2.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x7.bdf")
        textColor = graphics.Color(51, 255, 51)
        textColor1 = graphics.Color(102, 178, 255)
        pos = offscreen_canvas.width
	reptime=False
	while not reptime:
      		offscreen_canvas.Clear()
       		len = graphics.DrawText(offscreen_canvas, font1, pos, 30, textColor, forecast)
       		lon = graphics.DrawText(offscreen_canvas, font2, 4, 8, textColor1, when)
       		lun = graphics.DrawText(offscreen_canvas, font2, 4, 16, textColor1, foretime)
       		pos -= 1
       		if (pos + len < 0):
			reptime = True
			pos = offscreen_canvas.width
       		time.sleep(0.02)
       		offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)

def interludecalendar():
	image = Image.open("/home/pi/owm/calendar1.png").convert("RGB")
	pygame.mixer.music.load("/home/pi/dbsounds/sonar.mp3")
	pygame.mixer.music.play()
	double_buffer = matrix.CreateFrameCanvas()
	img_width, img_height = image.size
	double_buffer.SetImage(image, 0, 0)
	double_buffer = matrix.SwapOnVSync(double_buffer)
	time.sleep(4)	

def interludeweather():
	pygame.mixer.music.load("/home/pi/dbsounds/" + metora + "d.mp3")
        pygame.mixer.music.play()
        image = Image.open("/home/pi/owm/owm.png").convert("RGB")
        double_buffer = matrix.CreateFrameCanvas()
        img_width, img_height = image.size
        double_buffer.SetImage(image, 0, 0)
        double_buffer = matrix.SwapOnVSync(double_buffer)
        time.sleep(4)

def interludenotification():
	pygame.mixer.music.load("/home/pi/dbsounds/campanello.mp3")
        pygame.mixer.music.play()
	image = Image.open("/home/pi/owm/calendar.png").convert("RGB")
	image1 = Image.open("/home/pi/owm/calnotif1.png").convert("RGB")
	image2 = Image.open("/home/pi/owm/calnotif2.png").convert("RGB")
	image3 = Image.open("/home/pi/owm/calnotif3.png").convert("RGB")
	double_buffer = matrix.CreateFrameCanvas()
	img_width, img_height = image.size
	for x in range (4):
	        double_buffer.SetImage(image, 0, 0)
        	double_buffer = matrix.SwapOnVSync(double_buffer)
        	time.sleep(.3)
		double_buffer.SetImage(image1, 0, 0)
        	double_buffer = matrix.SwapOnVSync(double_buffer)
        	time.sleep(.3)
		double_buffer.SetImage(image2, 0, 0)
        	double_buffer = matrix.SwapOnVSync(double_buffer)
        	time.sleep(.3)
		double_buffer.SetImage(image3, 0, 0)
        	double_buffer = matrix.SwapOnVSync(double_buffer)
        	time.sleep(.5)

def interludereminder():
	pygame.mixer.music.load("/home/pi/dbsounds/tictac.mp3")
        pygame.mixer.music.play()
	image = Image.open("/home/pi/owm/calendar.png").convert("RGB")
	image1 = Image.open("/home/pi/owm/reminder.png").convert("RGB")
	double_buffer = matrix.CreateFrameCanvas()
        img_width, img_height = image.size
        for x in range (4):
                double_buffer.SetImage(image, 0, 0)
                double_buffer = matrix.SwapOnVSync(double_buffer)
                time.sleep(.3)
                double_buffer.SetImage(image1, 0, 0)
                double_buffer = matrix.SwapOnVSync(double_buffer)
                time.sleep(.7)

def interludealert():
	pygame.mixer.music.load("/home/pi/dbsounds/alarm.mp3")
        pygame.mixer.music.play()
	image = Image.open("/home/pi/owm/allertameteo.png").convert("RGB")
        image1 = Image.open("/home/pi/owm/allertameteo1.png").convert("RGB")
        double_buffer = matrix.CreateFrameCanvas()
        img_width, img_height = image.size
        for x in range (4):
                double_buffer.SetImage(image, 0, 0)
                double_buffer = matrix.SwapOnVSync(double_buffer)
                time.sleep(.5)
                double_buffer.SetImage(image1, 0, 0)
                double_buffer = matrix.SwapOnVSync(double_buffer)
                time.sleep(.5)

def interluderss():
	pygame.mixer.music.load("/home/pi/dbsounds/telegrafo.mp3")
        pygame.mixer.music.play()
        image = Image.open("/home/pi/owm/ansa.png").convert("RGB")
        double_buffer = matrix.CreateFrameCanvas()
        img_width, img_height = image.size
        double_buffer.SetImage(image, 0, 0)
        double_buffer = matrix.SwapOnVSync(double_buffer)
        time.sleep(4)

def optionlist(opzione):
	current = available_options.get(str(opzione))
	image = Image.open("/home/pi/owm/" + str(current) + ".png").convert("RGB")
        double_buffer = matrix.CreateFrameCanvas()
        img_width, img_height = image.size
        double_buffer.SetImage(image, 0, 0)
        double_buffer = matrix.SwapOnVSync(double_buffer)

def optionmessage():
	image = Image.new("RGB", (64,32),"black")
	txt = "   S E T "
	draw = ImageDraw.Draw(image)
	font1 = graphics.Font()
        fnt = font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x18B.bdf")
	draw.text((0,10), txt, font=fnt, fill=(0,200,30))	
	matrix.SetImage(image, 0, 0)

def datemessage():
	image = Image.new("RGB", (64,32),"black")
	wd_numb = datetime.datetime.today().weekday()
	month_numb = datetime.datetime.today().month
	month = month_italian.get(str(month_numb))
	txt1 = wd_italian.get(str(wd_numb)) + datetime.datetime.now().strftime(" %d")
	txt1_posX = ((64 - (len(txt1) * 6))/2)
	txt = month
	txt_posX = ((64 - (len(txt) * 6))/2)
	txt2 = datetime.datetime.now().strftime("%Y")
	txt2_posX = ((64 - (len(txt2) * 6))/2)
        draw = ImageDraw.Draw(image)
        font1 = graphics.Font()
        fnt = font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x18B.bdf")
	draw.text((txt1_posX,0), txt1, font=fnt, fill=(0,200,30))
        draw.text((txt_posX,10), txt, font=fnt, fill=(0,200,30))
	draw.text((txt2_posX,20), txt2, font=fnt, fill=(0,200,30))
        matrix.SetImage(image, 0, 0)
	

def countdown(t):
	pygame.mixer.music.load("/home/pi/dbsounds/clock.mp3")
	while t:
        	mins, secs = divmod(t, 60)
        	timeformat = '{:02d}:{:02d}'.format(mins, secs)
		image = Image.new("RGB", (64,32),"black")
		txt = timeformat
		draw = ImageDraw.Draw(image)
		fnt = font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/clR6x12.bdf")
		draw.text((18,10), txt, font=fnt, fill=(255,255,255))
		matrix.SetImage(image, 0, 0)
		pygame.mixer.music.play()
        	time.sleep(1)
        	t -= 1
		confirm_state = GPIO.input(3) #CHANGE VALUE BUTTON
                if confirm_state == False:
			t = 0
	pygame.mixer.music.load("/home/pi/dbsounds/alarm.mp3")
	pygame.mixer.music.play()
	image = Image.new("RGB", (64,32),"black")
	txt = "00:00"
	draw = ImageDraw.Draw(image)
	fnt = font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/clR6x12.bdf")
	draw.text((18,10), txt, font=fnt, fill=(255,255,255))
	for repetition in range (4):
		matrix.SetImage(image, 0, 0)
		time.sleep(.5)
		matrix.Clear()
		time.sleep(.5)

def timertext(txt):
	image = Image.new("RGB", (64,32),"black")
	draw = ImageDraw.Draw(image)
	fnt = font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/clR6x12.bdf")
	draw.text((26,10), txt, font=fnt, fill=(255,255,255))
	matrix.SetImage(image, 0, 0)

def magicshow(magicphrase):
	image = Image.new("RGB", (64,32),"black")
        draw = ImageDraw.Draw(image)
	txt = "  CHIEDI"
	font = graphics.Font()
        fnt = font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x18B.bdf")
	draw.text((0,10), txt, font=fnt, fill=(255,255,255))
        matrix.SetImage(image, 0, 0)
	time.sleep(2)
        str=magicphrase
        offscreen_canvas = matrix.CreateFrameCanvas()
        font1 = graphics.Font()
        font2 = graphics.Font()
        font1.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x18B.bdf")
        font2.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/tom-thumb.bdf")
        textColor = graphics.Color(0, 255, 0)
        pos = offscreen_canvas.width
        reptime=False
        while not reptime:
                offscreen_canvas.Clear()
                len = graphics.DrawText(offscreen_canvas, font1, pos, 20, textColor, str)
                pos -= 1
                if (pos + len < 0):
                        reptime = True
                        pos = offscreen_canvas.width
                time.sleep(0.02)
                offscreen_canvas = matrix.SwapOnVSync(offscreen_canvas)

def quickeventfinder(buttontimer):
	eventoincorso = ""
	roberto = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
	luisa = datetime.datetime.strptime(roberto, '%Y-%m-%d %H:%M')
	bir = datetime.datetime.now().strftime("%H:%M")
	trm = luisa + datetime.timedelta(minutes=buttontimer)
	for event in events:
		start = event['start'].get('dateTime', event['start'].get('date'))
		auc = (event['start'].get('dateTime'))
		aoc = datetime.datetime.strptime(auc[:19], "%Y-%m-%dT%H:%M:%S")
		if (luisa <= aoc <= trm):
			bil = aoc.strftime("%H:%M")
			eventoincorso =  " * " + event['summary'] + " * " + eventoincorso
			interludenotification()
			notification("EVENTO", bil, eventoincorso)

def display():
                        textColor = graphics.Color(255, 0, 0)
                        textColor1 = graphics.Color(0, 255, 0)
                        textColor2 = graphics.Color(0, 0, 255)
                        image = Image.open("/home/pi/owm/" + metora + "d.png").convert("RGB")
                        double_buffer = matrix.CreateFrameCanvas()
                        my_text = datetime.datetime.now().strftime("%H:%M")
                        my_text2 = str(umidita) + "%"
                        font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/clR6x12.bdf")
                        if (temperatura > 0):
                                my_text1 = "+" + str(temperatura)+"C"
                        else:
                                my_text1 = str(temperatura)+"C"
                        graphics.DrawText(double_buffer, font, 32,8 , textColor, my_text)
                        graphics.DrawText(double_buffer, font, 35,20 , textColor1, my_text1)
                        graphics.DrawText(double_buffer, font, 40,32 , textColor2, my_text2)
                        img_width, img_height = image.size
                        double_buffer.SetImage(image, 0, 0)
                        double_buffer = matrix.SwapOnVSync(double_buffer)

getevents()
getweather()
 
while True:
	getevents()
	current_state = GPIO.input(pir_sensor)
	timenow = datetime.datetime.now()
	getweather()
	calendarevents()
	if not meteoactive:
		if (timenow.minute in metexemin):
			GPIO.output(audio_channel, GPIO.HIGH)
			interludeweather()
			for x in range (2): #repeat 2 times
				currentweatherconditions()
				threehrsfc()
				tomorrowfc()
			GPIO.output(audio_channel, GPIO.LOW)
                        double_buffer = matrix.CreateFrameCanvas()
                        matrix.SwapOnVSync(double_buffer).Clear
		if (timenow.minute in rssmin):
			GPIO.output(audio_channel, GPIO.HIGH)
			interluderss()
			rss()	
			GPIO.output(audio_channel, GPIO.LOW)
                        double_buffer = matrix.CreateFrameCanvas()
                        matrix.SwapOnVSync(double_buffer).Clear
		if (timenow.minute in calexemin): 
			GPIO.output(audio_channel, GPIO.HIGH)
			interludecalendar()
			for x in range(2):
				caleventlist()
			GPIO.output(audio_channel, GPIO.LOW)
			double_buffer = matrix.CreateFrameCanvas()
                	matrix.SwapOnVSync(double_buffer).Clear

        if (current_state):
                display()
                display_on = True
        else:
                double_buffer = matrix.CreateFrameCanvas()
                matrix.SwapOnVSync(double_buffer).Clear
                display_on = False
	while (getattr(datetime.datetime.now(), 'second') != 0):
		current_state = GPIO.input(pir_sensor)
		change_state = GPIO.input(2) ##ENTER BUTTON
		confirm_state = GPIO.input(3)
		shutdown_state = GPIO.input(shutdown_channel)
		if (shutdown_state == True):
			call("sudo shutdown -h now", shell=True)
		if (not display_on and current_state):
			display()
			display_on = True
			time.sleep(1)

		if (not current_state): 
			double_buffer = matrix.CreateFrameCanvas()
                        matrix.SwapOnVSync(double_buffer).Clear			
			display_on = False
		if (confirm_state == False and getattr(datetime.datetime.now(), 'second') < 57):
                        datemessage()
			display_on = False
                        time.sleep(2)
		if change_state == False:
			pygame.mixer.music.load(keysound[1])
			pygame.mixer.music.play()
			optionmessage()
			buttonsecond = datetime.datetime.now()
			buttonsecondelta = buttonsecond + datetime.timedelta(seconds=3)
			time.sleep(.2)
			while buttonsecondelta.second != buttonsecond.second:
				time.sleep(.2)
				buttonsecond = datetime.datetime.now()
				buttoncounter = 0
				confirm_state = GPIO.input(3) #CHANGE VALUE BUTTON
				if confirm_state == False:
					
					GPIO.output(audio_channel, GPIO.HIGH)
					while buttoncounter < 9:
						confirm_state = GPIO.input(3)
						if confirm_state == False:
							buttoncounter=buttoncounter+1
							pygame.mixer.music.load(keysound[0])
							pygame.mixer.music.play()
						if buttoncounter > 8:
							buttoncounter = 1
						opzione = buttoncounter
						optionlist(opzione)
						time.sleep(.2)
						change_state = GPIO.input(2) #ENTER BUTTON
						if change_state == False:
							pygame.mixer.music.load(keysound[1])
                                                        pygame.mixer.music.play()
							if buttoncounter == 1:
								buttontimer = 0
								timertext("0")
								time.sleep(.5)
								while buttontimer != 21: # SET HERE MAXIMUM TIMER TIME
									confirm_state = GPIO.input(3) #CHANGE VALUE
									change_state = GPIO.input(2) ##ENTER
									if confirm_state == False:
										buttontimer=buttontimer+1
										timertext(str(buttontimer))
										pygame.mixer.music.load(keysound[0])
										pygame.mixer.music.play()
									if change_state == False:
										quickeventfinder(buttontimer)
										countdown(buttontimer*60)
										buttontimer=21
										buttoncounter = 9
										pygame.mixer.music.load(keysound[1])
                                                                                pygame.mixer.music.play()
									time.sleep(.2)
								display_on = False
							if buttoncounter == 2:
								time.sleep(.5)
				                                currentweatherconditions()
                               					threehrsfc()
                               					tomorrowfc()
								buttoncounter = 9
								current_state = GPIO.input(pir_sensor)
								display_on = False
							if buttoncounter == 3:
								caleventlist()
								buttoncounter = 9
								display_on = False
							if buttoncounter == 4:
								rss()
								buttoncounter = 9
								display_on = False
							if buttoncounter == 5:	# EXIT
								display_on = False
								buttoncounter = 9
							if buttoncounter == 6:
								call("sudo shutdown -h now", shell=True)
							if buttoncounter == 7:
								random_index = randrange(0,len(magicball))
								magicshow(magicball[random_index])
								buttoncounter = 9
								display_on = False
							if buttoncounter == 8:
                                                                call("sudo reboot", shell=True)
								buttoncounter = 9
							time.sleep(.2)
							buttonsecond = datetime.datetime.now()
                                                        buttonsecondelta = buttonsecond + datetime.timedelta(seconds=0)
					GPIO.output(audio_channel, GPIO.LOW)
			display_on = False
		time.sleep(.2)

