gui.py

from PyQt5 import QtWidgets, QtCore, QtWebEngineWidgets
from PyQt5.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
                              QPushButton, QLabel, QSlider, QCheckBox, QLineEdit,
                              QListWidget, QListWidgetItem, QDialog, QDialogButtonBox,
                              QInputDialog, QMessageBox)
from PyQt5.QtCore import Qt, QUrl, QTimer, QSettings
from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
import sys
import os
from chatops import processing_requests, ready_requests, chat, channel_url, firebase_sync

class AddSongDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Add Song Request")
        self.setModal(True)

        layout = QVBoxLayout()

        label = QLabel("Enter search term:")
        layout.addWidget(label)

        self.search_input = QLineEdit()
        layout.addWidget(self.search_input)

        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)

        self.setLayout(layout)

    def get_search_term(self):
        return self.search_input.text().strip()


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Drum Stream Chat Queue")
        self.setGeometry(100, 100, 1400, 800)

        # Load settings
        self.settings = QSettings("DrumStreamQueue", "MainApp")

        # Media player
        self.player = QMediaPlayer()
        self.player.stateChanged.connect(self.on_player_state_changed)
        self.player.positionChanged.connect(self.on_position_changed)
        self.player.durationChanged.connect(self.on_duration_changed)
        self.player.error.connect(self.on_player_error)

        self.current_song = None
        self.delete_after_play = True

        # Central widget
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # Main layout: 3 columns
        main_layout = QHBoxLayout(central_widget)

        # Left pane: Processing queue
        left_pane = self.create_left_pane()
        main_layout.addWidget(left_pane, 1)

        # Middle pane: Controls and ready queue
        middle_pane = self.create_middle_pane()
        main_layout.addWidget(middle_pane, 2)

        # Right pane: YouTube chat
        right_pane = self.create_right_pane()
        main_layout.addWidget(right_pane, 1)

        # Timer to update queues
        self.update_timer = QTimer()
        self.update_timer.timeout.connect(self.update_queues)
        self.update_timer.start(500)  # Update every 500ms

        # Load saved settings
        self.load_settings()

    def create_left_pane(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)

        label = QLabel("Processing Queue")
        label.setStyleSheet("font-weight: bold; font-size: 14px;")
        layout.addWidget(label)

        self.processing_list = QListWidget()
        layout.addWidget(self.processing_list)

        return widget

    def create_middle_pane(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # Channel input
        channel_layout = QHBoxLayout()
        channel_label = QLabel("Channel:")
        self.channel_input = QLineEdit()
        self.channel_input.setPlaceholderText("https://www.youtube.com/@channelname")
        self.channel_input.textChanged.connect(self.save_settings)
        channel_layout.addWidget(channel_label)
        channel_layout.addWidget(self.channel_input)
        layout.addLayout(channel_layout)

        # Current song display
        self.current_song_label = QLabel("No song playing")
        self.current_song_label.setStyleSheet("font-size: 16px; padding: 10px;")
        layout.addWidget(self.current_song_label)

        # Playback position slider
        self.position_slider = QSlider(Qt.Horizontal)
        self.position_slider.sliderMoved.connect(self.set_position)
        layout.addWidget(self.position_slider)

        # Time labels
        time_layout = QHBoxLayout()
        self.time_label = QLabel("0:00")
        self.duration_label = QLabel("0:00")
        time_layout.addWidget(self.time_label)
        time_layout.addStretch()
        time_layout.addWidget(self.duration_label)
        layout.addLayout(time_layout)

        # Media controls
        controls_layout = QHBoxLayout()

        self.play_pause_btn = QPushButton("Play")
        self.play_pause_btn.clicked.connect(self.toggle_play_pause)
        controls_layout.addWidget(self.play_pause_btn)

        self.next_btn = QPushButton("Next")
        self.next_btn.clicked.connect(self.play_next_song)
        controls_layout.addWidget(self.next_btn)

        controls_layout.addWidget(QLabel("Volume:"))
        self.volume_slider = QSlider(Qt.Horizontal)
        self.volume_slider.setMaximum(100)
        self.volume_slider.setValue(50)
        self.volume_slider.valueChanged.connect(self.change_volume)
        controls_layout.addWidget(self.volume_slider)

        layout.addLayout(controls_layout)

        # Keep file checkbox
        self.keep_file_checkbox = QCheckBox("Keep file after playing")
        layout.addWidget(self.keep_file_checkbox)

        # Add manual request button
        self.add_request_btn = QPushButton("Add Manual Request")
        self.add_request_btn.clicked.connect(self.show_add_song_dialog)
        layout.addWidget(self.add_request_btn)

        # Ready queue
        queue_label = QLabel("Ready Queue")
        queue_label.setStyleSheet("font-weight: bold; font-size: 14px; margin-top: 20px;")
        layout.addWidget(queue_label)

        self.ready_list = QListWidget()
        layout.addWidget(self.ready_list)

        # Queue reorder buttons
        reorder_layout = QHBoxLayout()
        self.move_up_btn = QPushButton("Move Up")
        self.move_up_btn.clicked.connect(self.move_song_up)
        self.move_down_btn = QPushButton("Move Down")
        self.move_down_btn.clicked.connect(self.move_song_down)
        reorder_layout.addWidget(self.move_up_btn)
        reorder_layout.addWidget(self.move_down_btn)
        layout.addLayout(reorder_layout)

        return widget

    def create_right_pane(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)

        label = QLabel("YouTube Live Chat")
        label.setStyleSheet("font-weight: bold; font-size: 14px;")
        layout.addWidget(label)

        # Web view for YouTube chat
        self.chat_view = QtWebEngineWidgets.QWebEngineView()

        # Get video ID from chat and create popout URL
        if hasattr(chat, 'video_id'):
            video_id = chat.video_id
        else:
            # Try to extract from channel_url if available
            video_id = None

        if video_id:
            chat_url = f"https://www.youtube.com/live_chat?v={video_id}&embed_domain=localhost"
            self.chat_view.setUrl(QUrl(chat_url))
        else:
            self.chat_view.setHtml("<html><body><h3>Chat not available</h3></body></html>")

        layout.addWidget(self.chat_view)

        return widget

    def show_add_song_dialog(self):
        dialog = AddSongDialog(self)
        if dialog.exec_() == QDialog.Accepted:
            search_term = dialog.get_search_term()
            if search_term:
                processing_requests.append({"user": "Manual Request", "search": search_term})
                # Update Firebase when manual request added
                if firebase_sync:
                    firebase_sync.update_queue(processing_requests, ready_requests)

    def update_queues(self):
        # Update processing queue only if count changed
        if self.processing_list.count() != len(processing_requests):
            self.processing_list.clear()
            for item in processing_requests:
                search = item.get('search', '')
                user = item.get('user', 'Unknown')
                list_item = QListWidgetItem()
                list_item.setSizeHint(QtCore.QSize(0, 35))

                # Add delete button
                widget = QWidget()
                layout = QHBoxLayout(widget)
                layout.setContentsMargins(5, 2, 5, 2)
                label = QLabel(f"{search} (by {user})")
                delete_btn = QPushButton("Delete")
                delete_btn.clicked.connect(lambda checked, i=item: self.delete_processing_item(i))
                layout.addWidget(label)
                layout.addWidget(delete_btn)

                self.processing_list.addItem(list_item)
                self.processing_list.setItemWidget(list_item, widget)

        # Update ready queue only if count changed
        if self.ready_list.count() != len(ready_requests):
            self.ready_list.clear()
            for item in ready_requests:
                user = item.get('user', 'Unknown')
                location = item.get('location', '')
                song_name = os.path.basename(location) if location else 'Unknown'
                list_item = QListWidgetItem()
                list_item.setSizeHint(QtCore.QSize(0, 35))

                # Add delete button
                widget = QWidget()
                layout = QHBoxLayout(widget)
                layout.setContentsMargins(5, 2, 5, 2)
                label = QLabel(f"{song_name} (by {user})")
                delete_btn = QPushButton("Delete")
                delete_btn.clicked.connect(lambda checked, i=item: self.delete_ready_item(i))
                layout.addWidget(label)
                layout.addWidget(delete_btn)

                self.ready_list.addItem(list_item)
                self.ready_list.setItemWidget(list_item, widget)

        # Load next song into player if ready and nothing loaded (but don't auto-play)
        if ready_requests and not self.current_song:
            self.load_next_song()

    def delete_processing_item(self, item):
        if item in processing_requests:
            processing_requests.remove(item)
            # Update Firebase when item deleted
            if firebase_sync:
                firebase_sync.update_queue(processing_requests, ready_requests)

    def delete_ready_item(self, item):
        if item in ready_requests:
            ready_requests.remove(item)
            # Delete file if it exists
            location = item.get('location')
            if location and os.path.exists(location):
                try:
                    os.remove(location)
                except:
                    pass
            # Update Firebase when item deleted
            if firebase_sync:
                firebase_sync.update_queue(processing_requests, ready_requests)

    def move_song_up(self):
        current_row = self.ready_list.currentRow()
        if current_row > 0 and current_row < len(ready_requests):
            ready_requests[current_row], ready_requests[current_row - 1] = ready_requests[current_row - 1], ready_requests[current_row]
            self.ready_list.setCurrentRow(current_row - 1)
            # Update Firebase when queue reordered
            if firebase_sync:
                firebase_sync.update_queue(processing_requests, ready_requests)

    def move_song_down(self):
        current_row = self.ready_list.currentRow()
        if current_row >= 0 and current_row < len(ready_requests) - 1:
            ready_requests[current_row], ready_requests[current_row + 1] = ready_requests[current_row + 1], ready_requests[current_row]
            self.ready_list.setCurrentRow(current_row + 1)
            # Update Firebase when queue reordered
            if firebase_sync:
                firebase_sync.update_queue(processing_requests, ready_requests)

    def toggle_play_pause(self):
        if self.player.state() == QMediaPlayer.PlayingState:
            self.player.pause()
        else:
            # If nothing loaded, load the next song first
            if not self.current_song and ready_requests:
                self.load_next_song()
            self.player.play()

    def load_next_song(self):
        """Load next song without playing"""
        if ready_requests:
            self.current_song = ready_requests.pop(0)
            location = self.current_song.get('location')
            user = self.current_song.get('user', 'Unknown')

            if location and os.path.exists(location):
                print(f"Loading media: {location}")
                file_url = QUrl.fromLocalFile(os.path.abspath(location))
                print(f"File URL: {file_url.toString()}")
                self.player.setMedia(QMediaContent(file_url))
                self.current_song_label.setText(f"Ready: {os.path.basename(location)} (requested by {user})")
            else:
                self.current_song_label.setText("Error: File not found")
                self.current_song = None

    def play_next_song(self):
        # Delete current file if needed
        if self.current_song and not self.keep_file_checkbox.isChecked():
            location = self.current_song.get('location')
            if location and os.path.exists(location):
                try:
                    os.remove(location)
                except:
                    pass

        # Clear current song
        self.current_song = None
        self.player.stop()

        # Load and play next song
        if ready_requests:
            self.load_next_song()
            self.player.play()
        else:
            self.current_song_label.setText("No songs in queue")

    def on_player_state_changed(self, state):
        if state == QMediaPlayer.PlayingState:
            self.play_pause_btn.setText("Pause")
            if self.current_song:
                location = self.current_song.get('location')
                user = self.current_song.get('user', 'Unknown')
                song_name = os.path.basename(location)
                self.current_song_label.setText(f"Now playing: {song_name} (requested by {user})")
                # Update Firebase with now playing
                if firebase_sync:
                    firebase_sync.update_now_playing({"song": song_name, "user": user})
        else:
            self.play_pause_btn.setText("Play")
            # Clear now playing when stopped
            if state == QMediaPlayer.StoppedState and firebase_sync:
                firebase_sync.update_now_playing(None)

        # Auto-play next song when current finishes
        if state == QMediaPlayer.StoppedState and self.current_song:
            self.play_next_song()

    def on_position_changed(self, position):
        self.position_slider.setValue(position)
        self.time_label.setText(self.format_time(position))

    def on_duration_changed(self, duration):
        self.position_slider.setMaximum(duration)
        self.duration_label.setText(self.format_time(duration))

    def on_player_error(self):
        error = self.player.errorString()
        print(f"Media player error: {error}")
        self.current_song_label.setText(f"Playback error: {error}")

    def set_position(self, position):
        self.player.setPosition(position)

    def change_volume(self, value):
        self.player.setVolume(value)
        self.save_settings()

    def format_time(self, ms):
        seconds = ms // 1000
        minutes = seconds // 60
        seconds = seconds % 60
        return f"{minutes}:{seconds:02d}"

    def load_settings(self):
        channel = self.settings.value("channel", "https://www.youtube.com/@bbcearth")
        volume = self.settings.value("volume", 50, type=int)

        self.channel_input.setText(channel)
        self.volume_slider.setValue(volume)
        self.player.setVolume(volume)

    def save_settings(self):
        self.settings.setValue("channel", self.channel_input.text())
        self.settings.setValue("volume", self.volume_slider.value())


if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())