# Many thanks to https://stackoverflow.com/questions/18923321/making-a-clock-in-kivy
import collections
import datetime
import math
import sys
import traceback

from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.uix.slider import Slider
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.graphics import Color, Line, Rectangle

from multiprocessing import Process
from playsound import playsound

Builder.load_string('''
<MyClockWidget>:
    on_pos: self.update_display()
    on_size: self.update_display()

    FloatLayout
        id: face
        size_hint: None, None
        pos_hint: {"center_x":0.5, "center_y":0.5}
        size: 0.9*min(root.size), 0.9*min(root.size)
        canvas:
            Color:
                rgb: 0.1, 0.1, 0.1
            Ellipse:
                size: self.size
                pos: self.pos

    FloatLayout
        id: hands
        size_hint: None, None
        pos_hint: {"center_x":0.5, "center_y":0.5}
        size: 0.9*min(root.size), 0.9*min(root.size)

    FloatLayout
        id: set_alarm_button
        size_hint: None, None
        pos_hint: {"center_x":0.9, "center_y":0.1}
        size: 0.1*min(root.size), 0.1*min(root.size)

    FloatLayout
        id: settings_button
        size_hint: None, None
        pos_hint: {"center_x":0.9, "center_y":0.9}
        size: 0.1*min(root.size), 0.1*min(root.size)

    FloatLayout
        id: settings_menu
        size_hint: None, None
        pos_hint: {"center_x":0.5, "center_y":0.5}
        size: 0.7*min(root.size), 0.7*min(root.size)
        canvas:
            Color:
                rgb: 0.1, 0.1, 0.1
            Rectangle:
                size: self.size
                pos: self.pos
        GridLayout:
            rows: 6
            cols: 2
            Label:
                text:"Volume"
            Slider:
                id: volume_slider
                min: 0
                max: 20
                value: 4
                on_value: root.volume_slider_value(*args)
            Label:
                text:"Wake up brightness"
            Slider:
                id: wake_up_bightness_slider
                min: 0
                max: 20
                value: 20
            Label:
                text:"Reading light brightness"
            Slider:
                id: reading_light_brightness_slider
                min: 0
                max: 20
                value: 1
            Label:
                text:"Wifi network"
            Label:
                text:"wifi name"
            Label:
                text:"Wifi password"
            Label:
                text:"wifi password"
            Label:
                text:"Calendar URL"
            Label:
                text:"calendar url"
''')

Position = collections.namedtuple('Position', 'x y')

global sound_process
sound_process = None

def play_sound(source):
    while True:
        print("beep beep!")
        playsound(source)

class AlarmSettings():
    alarm_time = datetime.datetime(2022, 12, 10, 7, 30, 0, 0)
    alarm_activated = False

    alarm_modified = False
    led_color = [0, 0, 0]
    # sound_source = "https://icecast.omroep.nl/radio1-bb-mp3"
    sound_source = "Woodpecker Chirps - QuickSounds.com.mp3"
    seconds_to_sunrise = 30 * 60

    volume = 4
    wake_up_brightness = 20
    reading_light_brightness = 1

class MyClockWidget(FloatLayout):
    grabbed = ""
    face_numbers = []

    # if not grabbed, set_alarm_timeout_counter is incremented at every update call (ie: 60 Hz); 
    # this is used to blink the hands at 1 Hz when setting the alarm and releasing the hand
    set_alarm_timeout_counter = 0
    seconds_to_next_alarm = 0
    led_color = [0, 0, 0]

    # view can be "clock" "set_alarm" "settings" or "calendar"
    view = "clock"

    def hide_widget(self, widget, hide=True):
        if hasattr(widget, 'saved_attrs'):
            if not hide:
                widget.height, widget.size_hint_y, widget.opacity, widget.disabled = widget.saved_attrs
                del widget.saved_attrs
        elif hide:
            widget.saved_attrs = widget.height, widget.size_hint_y, widget.opacity, widget.disabled
            widget.height, widget.size_hint_y, widget.opacity, widget.disabled = 0, None, 0, True

    def draw_face(self):
        """
        Add number labels when added in widget hierarchy
        """

        alarm_settings = App.get_running_app().alarm_settings

        if self.view == "set_alarm":
            time = alarm_settings.alarm_time
        else:
            time = datetime.datetime.now()

        for i in range(1, 13):
            if time.hour < 12:
                offset = 0
            else:
                offset = 12

            self.face_numbers.append(Label(
                text=str(i + offset),
                pos_hint={
                    # pos_hint is a fraction in range (0, 1)
                    "center_x": 0.5 + 0.45*math.sin(2 * math.pi * i/12),
                    "center_y": 0.5 + 0.45*math.cos(2 * math.pi * i/12),
                }
            ))
            self.ids["face"].add_widget(self.face_numbers[i - 1])

    def draw_settings(self):
        Color(1, 1, 1)
        # self.ids["settings_menu"].add_widget(Rectangle(pos=(10, 10), size=(500, 500)))
        return

    def update_face(self):
        alarm_settings = App.get_running_app().alarm_settings

        if self.view == "set_alarm":
            time = alarm_settings.alarm_time
        else:
            time = datetime.datetime.now()

        for i in range(0, 12):
            if time.hour < 12:
                offset = 0
            else:
                offset = 12

            self.face_numbers[i].text=str(i + 1 + offset)


    def on_parent(self, myclock, parent):
        self.draw_face()
        self.draw_settings()

    def position_on_clock(self, fraction, length):
        """
        Calculate position in the clock using trygonometric functions
        """
        center_x = self.size[0]/2
        center_y = self.size[1]/2
        return Position(
            center_x + length * math.sin(2 * math.pi * fraction),
            center_y + length * math.cos(2 * math.pi * fraction),
        )

    def update_set_alarm_button(self):
        app = App.get_running_app()
        alarm_settings = app.alarm_settings

        if (self.view == "set_alarm") or alarm_settings.alarm_activated:
            source = 'alarm_on.png'
            rgb = [0.9, 0.0, 0.0]
        else:
            source = 'alarm_off.png'
            rgb = [1.0, 1.0, 1.0]

        set_alarm_button = self.ids["set_alarm_button"]
        set_alarm_button.canvas.clear()
        with set_alarm_button.canvas:
            Color(rgb[0], rgb[1], rgb[2])
            Rectangle(size=set_alarm_button.size, pos=set_alarm_button.pos, source=source)

    def update_settings_button(self):
        app = App.get_running_app()
        alarm_settings = app.alarm_settings

        if (self.view == "settings"):
            source = 'settings_visible.png'
            rgb = [0.9, 0.0, 0.0]
        else:
            source = 'settings_not_visible.png'
            rgb = [1.0, 1.0, 1.0]

        settings_button = self.ids["settings_button"]
        settings_button.canvas.clear()
        with settings_button.canvas:
            Color(rgb[0], rgb[1], rgb[2])
            Rectangle(size=settings_button.size, pos=settings_button.pos, source=source)

    def sun_rise(self):
        alarm_settings = App.get_running_app().alarm_settings

        # to do: calculate brightness and color according to sun rise instead of linear increment
        intensity = math.floor((1.0 - self.seconds_to_next_alarm / alarm_settings.seconds_to_sunrise) * 256.0)
        if intensity < 0:
            intensity = 0

        led_color = [0, 0, 0]
        for i in range(3):
            led_color[i] = intensity

        if self.led_color != led_color:
            self.led_color = led_color

    def check_sun_rise(self):
        alarm_settings = App.get_running_app().alarm_settings

        if alarm_settings.alarm_activated == False:
            return

        if self.seconds_to_next_alarm < alarm_settings.seconds_to_sunrise:
            self.sun_rise()

    def check_play_sound(self):
        global sound_process
        alarm_settings = App.get_running_app().alarm_settings

        if alarm_settings.alarm_activated == False:
            return

        if self.seconds_to_next_alarm < 0.1 and sound_process is None:
            sound_process = Process(target=play_sound, args=(alarm_settings.sound_source,))
            sound_process.start()

    def calc_seconds_to_next_alarm(self):
        alarm_settings = App.get_running_app().alarm_settings

        if alarm_settings.alarm_activated == False:
            return

        # Make sure alarm_time is in the future but not more than 24 h from now
        now = datetime.datetime.now()
        d = alarm_settings.alarm_time - now
        alarm_settings.alarm_time -= datetime.timedelta(days=d.days)

        # Calculate number of seconds until next alarm
        d = alarm_settings.alarm_time - now
        self.seconds_to_next_alarm = d.days * 24 * 3600 + d.seconds + d.microseconds / 1000000.0

    def check_alarm(self):
        self.calc_seconds_to_next_alarm()
        self.check_sun_rise()
        self.check_play_sound()

    def update_clock(self):
        self.hide_widget(self.ids["face"], False)
        self.hide_widget(self.ids["hands"], False)
        self.check_alarm()
        """
        Redraw clock hands
        """
        alarm_settings = App.get_running_app().alarm_settings
        if self.view == "set_alarm":
            time = alarm_settings.alarm_time
        else:
            time = datetime.datetime.now()

        hands = self.ids["hands"]
        seconds_hand = self.position_on_clock(time.second/60, length=0.45*hands.size[0])
        minutes_hand = self.position_on_clock(time.minute/60+time.second/3600, length=0.40*hands.size[0])
        hours_hand = self.position_on_clock(time.hour/12 + time.minute/720, length=0.35*hands.size[0])

        self.update_face()

        hands.canvas.clear()
        with hands.canvas:
            if self.view == "set_alarm":
                if self.grabbed != "" or self.set_alarm_timeout_counter < 1 * 60 or \
                      self.set_alarm_timeout_counter % 60 <= 30 or alarm_settings.alarm_modified == False:
                    Color(0.9, 0.0, 0.0)
                    Line(points=[hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], width=3, cap="round")
                    Color(0.8, 0.0, 0.0)
                    Line(points=[hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], width=2, cap="round")

                if self.grabbed == "":
                    self.set_alarm_timeout_counter += 1

                if self.set_alarm_timeout_counter >= 4 * 60 + 30:
                    self.view = "clock"
                    self.set_alarm_timeout_counter = 0

                    if alarm_settings.alarm_modified:
                        alarm_settings.alarm_activated = True
                    alarm_settings.alarm_modified = False
            else:
                Color(0.9, 0.9, 0.9)
                Line(points=[hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], width=3, cap="round")
                Color(0.8, 0.8, 0.8)
                Line(points=[hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], width=2, cap="round")
                Color(0.7, 0.7, 0.7)
                Line(points=[hands.center_x, hands.center_y, seconds_hand.x, seconds_hand.y], width=1, cap="round")

    def update_settings(self):
        self.hide_widget(self.ids["settings_menu"], False)

    def update_display(self, *args):
        # Hide all dynamic widgets; will be enabled when updating respecive view
        self.hide_widget(self.ids["face"], True)
        self.hide_widget(self.ids["hands"], True)
        self.hide_widget(self.ids["settings_menu"], True)

        self.update_set_alarm_button()
        self.update_settings_button()
        if self.view == "clock" or self.view == "set_alarm":
            self.update_clock()
        elif self.view == "settings":
            self.update_settings()

    def volume_slider_value(self, *args):
        alarm_settings = App.get_running_app().alarm_settings
        alarm_settings.volume = int(args[1])
        print(str(int(args[1])))

    def on_alarm_button_pressed(self):
        alarm_settings = App.get_running_app().alarm_settings
        alarm_settings.alarm_modified = False
        self.set_alarm_timeout_counter = 0

        if self.view == "set_alarm":
            self.view = "clock"
            alarm_settings.alarm_activated = False
        else:
            self.view = "set_alarm"
            alarm_settings.alarm_activated = True

    def on_settings_button_pressed(self):
        print("settings button pressed from view " + self.view)
        if self.view != "settings":
            self.view = "settings"
        else:
            self.view = "clock"
        print("view updated to " + self.view)

    def on_touch_up(self, touch):
        self.grabbed = ""
        alarm_settings = App.get_running_app().alarm_settings

        if (self.view == "set_alarm") and (self.grabbed == "hour" or self.grabbed == "minute"):
            self.set_alarm_timeout_counter = 0

        super(MyClockWidget, self).on_touch_up(touch)

    def on_touch_move(self, touch):
        alarm_settings = App.get_running_app().alarm_settings
        self.alarm_set_timeout = 0
        x = touch.pos[0] - self.size[0]/2
        y = touch.pos[1] - self.size[1]/2
        angle = math.atan2(y, x) / math.pi; # angle is between -1 and 1
        if self.grabbed == "minute":
            alarm_settings.alarm_modified = True
            self.set_alarm_timeout_counter = 0
            minute = round(-angle * 30 + 15)
            if minute < 0:
                minute += 60
            if minute == 60:
                minute = 59

            # hour correction
            hour = alarm_settings.alarm_time.hour
            if alarm_settings.alarm_time.minute >= 55 and minute <= 5:
                hour += 1
            elif alarm_settings.alarm_time.minute <= 5 and minute >= 55:
                hour -= 1

            if hour == 24:
                hour = 0
            elif hour == -1:
                hour = 23

            alarm_settings.alarm_time = datetime.datetime(alarm_settings.alarm_time.year, \
                alarm_settings.alarm_time.month, alarm_settings.alarm_time.day, \
                hour, minute, alarm_settings.alarm_time.second, 0)
        elif self.grabbed == "hour":
            alarm_settings.alarm_modified = True
            self.set_alarm_timeout_counter = 0
            hour = round(-angle * 6 + 3)
            if hour < 0:
                hour += 12
            if hour == 12:
                hour = 0 

            if alarm_settings.alarm_time.hour >= 12:
                hour += 12

            # AM / PM correction
            if alarm_settings.alarm_time.hour == 11 and hour == 0:
                hour = 12
            elif alarm_settings.alarm_time.hour == 23 and hour == 12:
                hour = 0
            elif alarm_settings.alarm_time.hour == 0 and hour == 11:
                hour = 23
            elif alarm_settings.alarm_time.hour == 12 and hour == 23:
                hour = 11

            # AM / PM boundary
            alarm_settings.alarm_time = datetime.datetime(alarm_settings.alarm_time.year, \
                alarm_settings.alarm_time.month, alarm_settings.alarm_time.day, \
                hour, alarm_settings.alarm_time.minute, alarm_settings.alarm_time.second, 0)

        super(MyClockWidget, self).on_touch_move(touch)

    def on_touch_down(self, touch):
        global sound_process

        alarm_settings = App.get_running_app().alarm_settings
        time = alarm_settings.alarm_time
        hands = self.ids["hands"]
        minutes_hand = self.position_on_clock(time.minute/60+time.second/3600, length=0.40*hands.size[0])
        hours_hand = self.position_on_clock(time.hour/12 + time.minute/720, length=0.35*hands.size[0])

        self.grabbed = ""
        app = App.get_running_app()
        alarm_settings = app.alarm_settings

        if (0.85 <= touch.spos[0] <= 0.95) and (0.05 <= touch.spos[1] <= 0.15):
            self.on_alarm_button_pressed()
        elif (0.85 <= touch.spos[0] <= 0.95) and (0.85 <= touch.spos[1] <= 0.95):
            self.on_settings_button_pressed()
        elif sound_process is not None:
            kill_sound_process()
        elif self.view == "set_alarm":
            self.set_alarm_timeout_counter = 0
            if (minutes_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= minutes_hand.x + 0.1 * self.size[0]) and \
                (minutes_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= minutes_hand.y + 0.1 * self.size[1]):
                self.grabbed = "minute"
            elif (hours_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= hours_hand.x + 0.1 * self.size[0]) and \
                (hours_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= hours_hand.y + 0.1 * self.size[1]):
                self.grabbed = "hour"

        super(MyClockWidget, self).on_touch_down(touch)


class MyApp(App):
    alarm_settings = AlarmSettings()

    def build(self):
        clock_widget = MyClockWidget()
        # update initially, just after construction of the widget is complete
        Clock.schedule_once(clock_widget.update_display, 0)
        # then update 60 times per second
        Clock.schedule_interval(clock_widget.update_display, 1.0/60.0)
        return clock_widget

def kill_sound_process():
    global sound_process
    if sound_process is not None:
        sound_process.kill()
        sound_process = None

def except_hook(type, value, tb):
    kill_sound_process()

if __name__ == '__main__':
    # sys.excepthook = except_hook
    MyApp().run()