#!/usr/bin/env python3
"""
Live HLS Broadcast Server v3 with SCTE-35 markers
Port 9003 - 60 segments × 6s = 360s loop (no lag)
SCTE-35 config same as v1 (DURATION=243.0)
"""

import http.server
import socketserver
import ssl
import time
from datetime import datetime

PORT = 9003
SSL_CERT = '/etc/letsencrypt/live/cdn-srt.smartbit.co/fullchain.pem'
SSL_KEY = '/etc/letsencrypt/live/cdn-srt.smartbit.co/privkey.pem'
SEGMENT_DURATION = 6  # seconds
TOTAL_SEGMENTS = 60
TOTAL_DURATION = 360  # seconds (60 × 6)
WINDOW_SIZE = 12  # segments in live window

# SCTE-35 marker positions (same as v1)
SCTE35_CUE_OUT_SEGMENT = 19  # ~1:54 - ad break starts
SCTE35_CUE_IN_SEGMENT = 59   # ~5:54 - ad break ends (last segment)
SCTE35_DURATION = 243.0      # Same as v1

class LivePlaylistGenerator:
    def __init__(self):
        self.start_time = time.time()

    def get_current_segment(self):
        elapsed = time.time() - self.start_time
        position_in_loop = elapsed % TOTAL_DURATION
        segment_num = int(position_in_loop / SEGMENT_DURATION)
        return min(segment_num, TOTAL_SEGMENTS - 1)

    def get_media_sequence(self):
        elapsed = time.time() - self.start_time
        return int(elapsed / SEGMENT_DURATION)

    def generate_playlist(self, variant):
        current_seg = self.get_current_segment()
        media_seq = self.get_media_sequence()
        window_start = max(0, current_seg - WINDOW_SIZE + 1)

        lines = [
            '#EXTM3U',
            '#EXT-X-VERSION:6',
            '#EXT-X-TARGETDURATION:6',
            f'#EXT-X-MEDIA-SEQUENCE:{media_seq - (current_seg - window_start)}',
            '#EXT-X-INDEPENDENT-SEGMENTS',
        ]

        for seg_num in range(window_start, current_seg + 1):
            actual_seg = seg_num % TOTAL_SEGMENTS
            
            if actual_seg == SCTE35_CUE_OUT_SEGMENT:
                lines.append(f'#EXT-X-CUE-OUT:DURATION={SCTE35_DURATION}')
            
            if actual_seg == SCTE35_CUE_IN_SEGMENT:
                lines.append('#EXT-X-CUE-IN')

            lines.append(f'#EXTINF:{SEGMENT_DURATION:.6f},')
            lines.append(f'segment_{variant}_{actual_seg:03d}.ts')

        return '\n'.join(lines) + '\n'

    def generate_master_playlist(self):
        return '''#EXTM3U
#EXT-X-VERSION:3
#EXT-X-STREAM-INF:BANDWIDTH=3700000,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2"
playlist_1080p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2700000,RESOLUTION=1280x720,CODECS="avc1.640028,mp4a.40.2"
playlist_720p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1200000,RESOLUTION=854x480,CODECS="avc1.4d401f,mp4a.40.2"
playlist_480p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=800000,RESOLUTION=640x360,CODECS="avc1.4d401e,mp4a.40.2"
playlist_360p.m3u8
'''

playlist_gen = LivePlaylistGenerator()

class LiveBroadcastHandler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/master.m3u8':
            content = playlist_gen.generate_master_playlist()
        elif self.path == '/playlist_1080p.m3u8':
            content = playlist_gen.generate_playlist('1080p')
        elif self.path == '/playlist_720p.m3u8':
            content = playlist_gen.generate_playlist('720p')
        elif self.path == '/playlist_480p.m3u8':
            content = playlist_gen.generate_playlist('480p')
        elif self.path == '/playlist_360p.m3u8':
            content = playlist_gen.generate_playlist('360p')
        else:
            super().do_GET()
            return
        
        self.send_response(200)
        self.send_header('Content-Type', 'application/vnd.apple.mpegurl')
        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
        self.send_header('Access-Control-Allow-Origin', '*')
        self.end_headers()
        self.wfile.write(content.encode())

    def log_message(self, format, *args):
        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {format % args}")

if __name__ == '__main__':
    with socketserver.TCPServer(("", PORT), LiveBroadcastHandler) as httpd:
        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        context.load_cert_chain(SSL_CERT, SSL_KEY)
        httpd.socket = context.wrap_socket(httpd.socket, server_side=True)

        print(f"{'=' * 60}")
        print(f"Live HLS Broadcast Server v3 (HTTPS)")
        print(f"{'=' * 60}")
        print(f"Port: {PORT}")
        print(f"Resolutions: 1080p, 720p, 480p, 360p")
        print(f"Looping: {TOTAL_DURATION}s ({TOTAL_SEGMENTS} segments × {SEGMENT_DURATION}s)")
        print(f"SCTE-35: CUE-OUT at seg {SCTE35_CUE_OUT_SEGMENT}, CUE-IN at seg {SCTE35_CUE_IN_SEGMENT}")
        print(f"SCTE-35 Duration: {SCTE35_DURATION}s (same as v1)")
        print(f"{'=' * 60}")
        httpd.serve_forever()