from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.clock import Clock
from kivy.core.window import Window
from kivy.uix.video import Video
from kivy.uix.image import Image
from kivy.uix.boxlayout import BoxLayout
import requests
import os
import json
from kivy.config import Config
from kivy.logger import Logger
Config.set('kivy', 'keyboard_mode', 'systemanddock')

class MediaPlayer(Screen):
    def __init__(self, **kwargs):
        super(MediaPlayer, self).__init__(**kwargs)
        self.playlist = []
        self.current_index = 0
        self.video_player = Video()
        self.image_display = Image()
        self.layout = BoxLayout(orientation='vertical')
        self.layout.add_widget(self.video_player)
        self.layout.add_widget(self.image_display)
        self.add_widget(self.layout)
        Clock.schedule_interval(self.check_playlist_updates, 300)  # Check for updates every 5 minutes
        Window.bind(on_key_down=self.on_key_down)

    def on_key_down(self, window, key, *args):
        if key == 102:  # 'f' key
            Window.fullscreen = not Window.fullscreen

    def on_enter(self):
        self.load_playlist()
        self.download_media_files()
        self.play_media()

    def load_playlist(self):
        # Load playlist from the server or local storage
        try:
            Logger.debug("Attempting to load playlist from server...")
            server_ip = 'http://192.168.0.115:5000'
            hostname = 'player1.local'
            quickconnect_code = 'Initial01!'
            url = f'{server_ip}/api/playlists'
            params = {
                'hostname': "TvHolBa1",
                'quickconnect_code': quickconnect_code
            }
            response = requests.get(url, params=params)
            
            # Print the raw response content and status code for debugging
            Logger.debug(f'Status Code: {response.status_code}')
            Logger.debug(f'Response Content: {response.text}')
            
            # Check if the request was successful
            if response.status_code == 200:
                try:
                    # Parse the JSON response
                    self.playlist = response.json().get('playlist', [])
                    Logger.debug(f'Playlist: {self.playlist}')
                except json.JSONDecodeError as e:
                    Logger.error(f'Failed to parse JSON response: {e}')
            else:
                Logger.error(f'Failed to retrieve playlist: {response.text}')
        except requests.exceptions.RequestException as e:
            Logger.error(f"Failed to load playlist: {e}")

    def download_media_files(self):
        base_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse')  # Update this to the correct path
        if not os.path.exists(base_dir):
            os.makedirs(base_dir)

        for media in self.playlist:
            file_name = media.get('file_name', '')
            file_url = f"http://192.168.0.115:5000/media/{file_name}"  # Update this to the correct URL
            file_path = os.path.join(base_dir, file_name)

            try:
                response = requests.get(file_url)
                if response.status_code == 200:
                    with open(file_path, 'wb') as file:
                        file.write(response.content)
                    Logger.debug(f"Downloaded {file_name} to {file_path}")
                else:
                    Logger.error(f"Failed to download {file_name}: {response.status_code}")
            except requests.exceptions.RequestException as e:
                Logger.error(f"Failed to download {file_name}: {e}")

    def play_media(self):
        if self.playlist:
            media = self.playlist[self.current_index]
            file_name = media.get('file_name', '')
            file_extension = os.path.splitext(file_name)[1].lower()
            duration = media.get('duration', 10)  # Default duration is 10 seconds

            # Define the base directory for media files
            base_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse')  # Update this to the correct path
            file_path = os.path.join(base_dir, file_name)

            if file_extension in ['.mp4', '.avi', '.mov']:
                self.video_player.source = file_path
                self.video_player.play()
                self.image_display.source = ''
            elif file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
                self.image_display.source = file_path
                self.video_player.source = ''
                self.image_display.reload()
                Clock.schedule_once(self.next_media, duration)
            else:
                Logger.error(f"Unsupported media type for file: {file_name}")

    def next_media(self, dt):
        self.current_index = (self.current_index + 1) % len(self.playlist)
        self.play_media()

    def check_playlist_updates(self, dt):
        self.load_playlist()
        self.download_media_files()
        self.play_media()

class MediaPlayerApp(App):
    def build(self):
        Window.fullscreen = True
        sm = ScreenManager()
        sm.add_widget(MediaPlayer(name='media_player'))
        return sm

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