import threading
import subprocess

def yt(url, then_callback):
	filename = subprocess.getoutput(f'yt-dlp --print filename "{url}"')
	def run_in_thread():
		proc = subprocess.run(["yt-dlp","-o",'data/%(title)s.%(ext)s',url])
		then_callback(filename)
	thread = threading.Thread(target=run_in_thread)
	thread.start()
	return filename # thread

from flask import Flask, render_template, send_from_directory
from flask_socketio import SocketIO

app = Flask(__name__)
socketio = SocketIO(app)

player = None

@app.route('/')
def ws_index(): return render_template('index.html')

from urllib.parse import unquote
@app.route('/data/<path:filename>')
def ws_data(filename):
	print(unquote(filename))
	return send_from_directory('data',unquote(filename))
#     range_header = request.headers.get('Range', None)
#     byte1, byte2 = 0, None
#     if range_header:
#         match = re.search(r'(\d+)-(\d*)', range_header)
#         groups = match.groups()
#         if groups[0]: byte1 = int(groups[0])
#         if groups[1]: byte2 = int(groups[1])
#     chunk, start, length, file_size = get_chunk(byte1, byte2)
#     resp = Response(chunk, 206, mimetype='video/mp4', content_type='video/mp4', direct_passthrough=True)
#     resp.headers.add('Content-Range', 'bytes {0}-{1}/{2}'.format(start, start + length - 1, file_size))
#     return resp

@socketio.on('request_state')
def ws_request_state(): player.emit_full()

@socketio.on('request_url')
def ws_request_url(url): player.open_url(url)

@socketio.on('request_time')
def ws_request_time(time): player.set_time(time)

@socketio.on('request_play')
def ws_request_play(): player.play()

@socketio.on('request_pause')
def ws_request_pause(): player.pause()

### video-player stuff
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QSizePolicy
from PyQt5.QtCore import Qt, QUrl
from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer
from PyQt5.QtMultimediaWidgets import QVideoWidget

class VideoWindow(QMainWindow):
	def __init__(self, parent=None):
		super(VideoWindow, self).__init__(parent)
		self.setWindowTitle("piplayer") 

		videoWidget = QVideoWidget()
		videoWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
		self.setCentralWidget(videoWidget)

		self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
		self.mediaPlayer.setVideoOutput(videoWidget)
		self.mediaPlayer.stateChanged.connect(self.emit_state)
		self.mediaPlayer.positionChanged.connect(self.emit_time)
		self.mediaPlayer.durationChanged.connect(self.emit_duration)
		self.mediaPlayer.error.connect(self.handleError)

		# this looks utterly stupid.
		self.showFullScreen()
		size = app.primaryScreen().size()
		self.resize(size.width(), size.height())

		self.current_file = ""
		self.history = [] # TODO

	def open_file(self, path):
		self.history.append(path)
		self.current_file=path
		import pathlib
		current_path = pathlib.Path(__file__).parent.resolve()
		abs_path = f"{current_path}/data/{path}"
		self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(abs_path)))
		self.play()

	def emit_duration(self,duration): socketio.emit('duration'    ,duration/1000,broadcast=True)
	def emit_time(self,time):         socketio.emit('time'        ,time    /1000,broadcast=True)
	def emit_state(self,state):       socketio.emit('state'       ,state == QMediaPlayer.PlayingState,broadcast=True)
	def emit_current_file(self):      socketio.emit('current_file',self.current_file,broadcast=True)

	def emit_full(self):
		socketio.emit('current_file',self.current_file)
		socketio.emit('duration'    ,self.mediaPlayer.duration()/1000)
		socketio.emit('time'        ,self.mediaPlayer.position()/1000)
		socketio.emit('state'       ,self.mediaPlayer.state() == QMediaPlayer.PlayingState)

	def open_url(self, url):
		pass
		print(f"requested {url}")
		def post_dl(filename):
			self.open_file(filename)
			self.emit_full()
		filename = yt(url, post_dl)
		self.history.append(url)
		self.open_file(filename)
		self.emit_full()
		# TODO self.open_file(downloaded_file)

	def play(self):
		self.mediaPlayer.play()
		self.emit_state(self.mediaPlayer.state())

	def pause(self):
		self.mediaPlayer.pause()
		self.emit_state(self.mediaPlayer.state())

	def set_time(self, time):
		self.mediaPlayer.setPosition(int(1000*time))
		self.emit_time(self.mediaPlayer.position())

	def handleError(self):
		print("Error: " + self.mediaPlayer.errorString())

threading.Thread(target=lambda: socketio.run(app,host="0.0.0.0",port=5000)).start()

app = QApplication(sys.argv)
player = VideoWindow()
sys.exit(app.exec_())