from logging import disable

import kivy

kivy.require('2.2.1')

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.popup import Popup
from kivy.uix.screenmanager import Screen, ScreenManager
from kivy.uix.stacklayout import StackLayout

from tinge import HueBridge, HueGroup, HueUtils, Tinge


class HueApp(App):

    def build(self):
        self.tinge = Tinge()
        sm = ScreenManager()
        sm.add_widget(BridgeScreen(sm, self.tinge, name='bridge_screen'))

        return sm


class GroupScreen(Screen):

    def __init__(self, sm, tinge, id: int, bridge: HueBridge, **kwargs):
        super(GroupScreen, self).__init__(**kwargs)
        self.sm = sm
        self.tinge = tinge
        self.id = id
        self.group = bridge.get_group_by_id(id)
        self.bridge = bridge
        self.layout = StackLayout()
        self.add_widget(self.layout)
        for button in self.get_light_buttons():
            self.layout.add_widget(button)

    def get_light_buttons(self):
        buttons = []
        for light in self.group.get_lights():
            button = Button(text=str(light),
                            size_hint=(1, 0.1),
                            on_press=lambda _: self.press_button(light))
            buttons.append(button)
        backbutton = Button(text="Back",
                            size_hint=(1, 0.1),
                            on_press=lambda _: self.press_back_button())
        buttons.append(backbutton)
        return buttons

    def press_back_button(self):
        self.sm.current = "bridge_" + str(self.bridge.id)

    def press_button(self, light):
        print(button, light)


class SingleBridgeScreen(Screen):

    def __init__(self, sm, tinge, bridge: HueBridge, **kwargs):
        super(SingleBridgeScreen, self).__init__(**kwargs)
        self.sm = sm
        self.tinge = tinge
        self.bridge = bridge
        self.layout = StackLayout()
        self.add_widget(self.layout)
        self.groups = []
        for group in self.bridge.get_groups():
            self.layout.add_widget(self.get_group_button(group))
        self.layout.add_widget(
            Button(text="Back",
                   size_hint=(1, 0.1),
                   on_press=lambda _: self.press_back_button()))

    def get_group_button(self, group):
        button = Button(text=str(group), size_hint=(1, 0.1))
        button.bind(on_press=lambda _: self.press_button(group.get_id()))
        return button

    def press_back_button(self):
        self.sm.current = "bridge_screen"

    def press_button(self, group: int):
        print(group)
        group_name: str = 'group_' + str(group)
        group_screen = GroupScreen(self.sm,
                                   self.tinge,
                                   group,
                                   self.bridge,
                                   name=group_name)
        if not self.sm.has_screen(group_name):
            self.sm.add_widget(group_screen)
        self.sm.current = group_name


class BridgeScreen(Screen):
    bridges = []
    layout = BoxLayout()

    def __init__(self, sm, tinge, **kwargs):
        super(BridgeScreen, self).__init__(**kwargs)
        self.sm = sm
        self.tinge = tinge
        for bridge_button in self.get_bridge_buttons():
            self.layout.add_widget(bridge_button)

    def press_button(self, bridge):
        bridge_name = "bridge_" + str(bridge.id)
        if not self.sm.has_screen(bridge_name):
            self.sm.add_widget(
                SingleBridgeScreen(self.sm,
                                   self.tinge,
                                   bridge,
                                   name=bridge_name))
        self.sm.current = bridge_name

    def discover_bridge(self):
        bridges = self.tinge.discover_new_bridges()
        if bridges:
            for bridge in bridges:
                print(bridge)
                if not self.tinge.bridge_discovered(bridge['ipaddress']):
                    # Display popup lable to add bridge and get username
                    popup = Popup(title='Connect Bridge',
                                  size_hint=(None, None),
                                  size=(400, 400))
                    new_bridge_button = Button(
                        text='Press button on Bridge',
                        size_hint=(1, 0.1),
                        on_press=lambda _: self.wait_for_button_press(
                            popup, bridge['ipaddress']))
                    popup.add_widget(new_bridge_button)
                    popup.open()

    def wait_for_button_press(self, popup, ipaddress):
        bridge_id = len(self.tinge.get_bridges())
        user_or_error = HueUtils.connect(ipaddress)
        while user_or_error.is_error():
            user_or_error = HueUtils.connect(ipaddress)
        self.tinge.append_bridge(
            HueBridge(bridge_id, ipaddress, user_or_error.get_user(),
                      ipaddress))
        self.tinge.write_all_bridges_to_conf()
        popup.dismiss()

    def get_bridge_buttons(self):
        buttons = []
        bridges = self.tinge.get_bridges()
        for bridge in bridges:
            bridge_button = Button(
                text=str(bridge.get_ipaddress()),
                size_hint=(1, 0.1),
                on_press=lambda _: self.press_button(bridge))
            buttons.append(bridge_button)
        bridge_button = Button(text='Discover Bridges',
                               size_hint=(1, 0.1),
                               on_press=lambda _: self.discover_bridge())
        buttons.append(bridge_button)
        sizer = Label(disabled=True)
        buttons.append(sizer)
        return buttons


if __name__ == '__main__':
    HueApp().run()