import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import threading
import os
import requests
import m3u8
from urllib.parse import urljoin, urlparse
from pathlib import Path
import concurrent.futures
import time
import re

class M3U8Downloader:
    def __init__(self, root):
        self.root = root
        self.root.title("M3U8 视频下载器")
        self.root.geometry("700x550")
        self.root.resizable(True, True)
        
        # 设置主题
        self.style = ttk.Style()
        self.style.theme_use('clam')
        
        # 初始化变量
        self.downloading = False
        self.total_segments = 0
        self.downloaded_segments = 0
        self.start_time = None
        
        self.setup_ui()
        
    def setup_ui(self):
        # 主框架
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # URL输入部分
        url_frame = ttk.LabelFrame(main_frame, text="M3U8 URL", padding="10")
        url_frame.grid(row=0, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
        
        ttk.Label(url_frame, text="M3U8 URL:").grid(row=0, column=0, sticky=tk.W)
        
        self.url_var = tk.StringVar()
        self.url_entry = ttk.Entry(url_frame, textvariable=self.url_var, width=60)
        self.url_entry.grid(row=0, column=1, padx=(5, 5), sticky=(tk.W, tk.E))
        
        # 文件选择部分
        file_frame = ttk.LabelFrame(main_frame, text="文件保存", padding="10")
        file_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
        
        ttk.Label(file_frame, text="保存路径:").grid(row=0, column=0, sticky=tk.W)
        
        self.path_var = tk.StringVar()
        self.path_entry = ttk.Entry(file_frame, textvariable=self.path_var, width=50)
        self.path_entry.grid(row=0, column=1, padx=(5, 5), sticky=(tk.W, tk.E))
        
        self.browse_btn = ttk.Button(file_frame, text="浏览", command=self.browse_path)
        self.browse_btn.grid(row=0, column=2, padx=(5, 0))
        
        # 文件名部分
        ttk.Label(file_frame, text="文件名:").grid(row=1, column=0, sticky=tk.W, pady=(10, 0))
        
        self.filename_var = tk.StringVar(value="video")
        self.filename_entry = ttk.Entry(file_frame, textvariable=self.filename_var, width=30)
        self.filename_entry.grid(row=1, column=1, padx=(5, 5), sticky=tk.W, pady=(10, 0))
        
        ttk.Label(file_frame, text=".mp4").grid(row=1, column=1, sticky=tk.E, pady=(10, 0))
        
        # 下载选项部分
        options_frame = ttk.LabelFrame(main_frame, text="下载选项", padding="10")
        options_frame.grid(row=2, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
        
        ttk.Label(options_frame, text="并发线程数:").grid(row=0, column=0, sticky=tk.W)
        
        self.threads_var = tk.IntVar(value=10)
        self.threads_spinbox = ttk.Spinbox(options_frame, from_=1, to=50, textvariable=self.threads_var, width=10)
        self.threads_spinbox.grid(row=0, column=1, sticky=tk.W, padx=(5, 0))
        
        ttk.Label(options_frame, text="重试次数:").grid(row=0, column=2, sticky=tk.W, padx=(20, 0))
        
        self.retry_var = tk.IntVar(value=3)
        self.retry_spinbox = ttk.Spinbox(options_frame, from_=1, to=10, textvariable=self.retry_var, width=10)
        self.retry_spinbox.grid(row=0, column=3, sticky=tk.W, padx=(5, 0))
        
        # 进度部分
        progress_frame = ttk.LabelFrame(main_frame, text="下载进度", padding="10")
        progress_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
        
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(progress_frame, variable=self.progress_var, maximum=100)
        self.progress_bar.grid(row=0, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 5))
        
        # 进度标签
        self.status_var = tk.StringVar(value="等待下载...")
        self.status_label = ttk.Label(progress_frame, textvariable=self.status_var)
        self.status_label.grid(row=1, column=0, columnspan=2, sticky=tk.W)
        
        # 详细信息
        self.details_var = tk.StringVar(value="")
        self.details_label = ttk.Label(progress_frame, textvariable=self.details_var)
        self.details_label.grid(row=2, column=0, columnspan=2, sticky=tk.W, pady=(5, 0))
        
        # 按钮部分
        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=4, column=0, columnspan=2, pady=(10, 0))
        
        self.download_btn = ttk.Button(button_frame, text="开始下载", command=self.toggle_download)
        self.download_btn.grid(row=0, column=0, padx=(0, 10))
        
        self.clear_btn = ttk.Button(button_frame, text="清除", command=self.clear_fields)
        self.clear_btn.grid(row=0, column=1, padx=(0, 10))
        
        # 日志部分
        log_frame = ttk.LabelFrame(main_frame, text="日志", padding="10")
        log_frame.grid(row=5, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(10, 0))
        
        # 添加滚动条
        log_scrollbar = ttk.Scrollbar(log_frame)
        log_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.log_text = tk.Text(log_frame, height=8, yscrollcommand=log_scrollbar.set)
        self.log_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        log_scrollbar.config(command=self.log_text.yview)
        
        # 配置网格权重
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        log_frame.columnconfigure(0, weight=1)
        log_frame.rowconfigure(0, weight=1)
        
        # 设置默认保存路径
        default_path = os.path.join(os.path.expanduser("~"), "Downloads")
        self.path_var.set(default_path)
        
    def browse_path(self):
        """选择保存路径"""
        path = filedialog.askdirectory(title="选择保存路径")
        if path:
            self.path_var.set(path)
    
    def clear_fields(self):
        """清除所有字段"""
        self.url_var.set("")
        self.filename_var.set("video")
        self.status_var.set("等待下载...")
        self.details_var.set("")
        self.progress_var.set(0)
        self.log_text.delete(1.0, tk.END)
    
    def toggle_download(self):
        """开始或取消下载"""
        if not self.downloading:
            self.start_download()
        else:
            self.cancel_download()
    
    def start_download(self):
        """开始下载"""
        url = self.url_var.get().strip()
        if not url:
            messagebox.showerror("错误", "请输入M3U8 URL")
            return
        
        save_path = self.path_var.get().strip()
        if not save_path:
            messagebox.showerror("错误", "请选择保存路径")
            return
        
        filename = self.filename_var.get().strip()
        if not filename:
            messagebox.showerror("错误", "请输入文件名")
            return
        
        # 检查URL是否有效
        if not re.match(r'^https?://', url, re.I):
            messagebox.showerror("错误", "URL格式不正确，请使用http://或https://开头")
            return
        
        # 更新状态
        self.downloading = True
        self.download_btn.config(text="取消下载")
        self.browse_btn.config(state=tk.DISABLED)
        self.clear_btn.config(state=tk.DISABLED)
        
        # 清空日志
        self.log_text.delete(1.0, tk.END)
        
        # 在后台线程中开始下载
        self.download_thread = threading.Thread(
            target=self.download_m3u8,
            args=(url, save_path, filename)
        )
        self.download_thread.daemon = True
        self.download_thread.start()
    
    def cancel_download(self):
        """取消下载"""
        self.downloading = False
        self.status_var.set("下载已取消")
        self.log_message("下载已取消")
    
    def log_message(self, message):
        """添加日志消息"""
        timestamp = time.strftime("%H:%M:%S")
        log_entry = f"[{timestamp}] {message}\n"
        self.log_text.insert(tk.END, log_entry)
        self.log_text.see(tk.END)
        self.root.update_idletasks()
    
    def update_progress(self, downloaded, total):
        """更新进度条"""
        self.downloaded_segments = downloaded
        self.total_segments = total
        
        if total > 0:
            percentage = (downloaded / total) * 100
            self.progress_var.set(percentage)
            
            elapsed_time = time.time() - self.start_time if self.start_time else 0
            if downloaded > 0 and elapsed_time > 0:
                # 计算剩余时间
                remaining = (elapsed_time / downloaded) * (total - downloaded)
                self.details_var.set(f"已下载: {downloaded}/{total} 片段 | 剩余时间: {remaining:.1f}秒")
            else:
                self.details_var.set(f"已下载: {downloaded}/{total} 片段")
    
    def download_segment(self, segment_url, output_path, retry_count=3):
        """下载单个片段"""
        for attempt in range(retry_count):
            try:
                response = requests.get(segment_url, timeout=30)
                response.raise_for_status()
                
                with open(output_path, 'wb') as f:
                    f.write(response.content)
                return True
            except Exception as e:
                if attempt < retry_count - 1:
                    time.sleep(1)  # 重试前等待
                else:
                    self.log_message(f"下载失败: {segment_url} - {str(e)}")
                    return False
        return False
    
    def download_m3u8(self, url, save_path, filename):
        """下载M3U8流"""
        try:
            self.start_time = time.time()
            self.status_var.set("正在解析M3U8文件...")
            self.log_message(f"开始解析: {url}")
            
            # 解析M3U8文件
            try:
                m3u8_obj = m3u8.load(url)
            except Exception as e:
                self.log_message(f"M3U8解析失败: {str(e)}")
                self.status_var.set("M3U8解析失败")
                self.reset_ui()
                return
            
            # 检查是否为直播流
            if m3u8_obj.is_variant:
                self.log_message("检测到主播放列表，正在选择最高质量流...")
                # 选择最高带宽的流
                playlists = m3u8_obj.playlists
                if playlists:
                    # 按带宽排序
                    playlists.sort(key=lambda x: x.stream_info.bandwidth if x.stream_info.bandwidth else 0, reverse=True)
                    selected_playlist = playlists[0]
                    m3u8_url = urljoin(url, selected_playlist.uri)
                    self.log_message(f"选择流: {selected_playlist.stream_info.resolution if hasattr(selected_playlist.stream_info, 'resolution') else '未知分辨率'} - 带宽: {selected_playlist.stream_info.bandwidth}")
                    m3u8_obj = m3u8.load(m3u8_url)
                else:
                    self.log_message("错误: 未找到可用流")
                    self.status_var.set("未找到可用流")
                    self.reset_ui()
                    return
            
            # 获取所有片段
            segments = m3u8_obj.segments
            if not segments:
                self.log_message("错误: 未找到视频片段")
                self.status_var.set("未找到视频片段")
                self.reset_ui()
                return
            
            self.total_segments = len(segments)
            self.downloaded_segments = 0
            
            self.status_var.set(f"开始下载 {self.total_segments} 个片段...")
            self.log_message(f"找到 {self.total_segments} 个片段")
            
            # 创建临时目录
            temp_dir = os.path.join(save_path, f"{filename}_temp")
            os.makedirs(temp_dir, exist_ok=True)
            
            # 下载所有片段
            segment_urls = []
            segment_files = []
            
            for i, segment in enumerate(segments):
                if not self.downloading:
                    break
                    
                segment_url = urljoin(url, segment.uri)
                segment_filename = f"segment_{i:05d}.ts"
                segment_path = os.path.join(temp_dir, segment_filename)
                
                segment_urls.append(segment_url)
                segment_files.append(segment_path)
            
            # 使用线程池并发下载
            self.status_var.set(f"下载中... (0/{self.total_segments})")
            
            with concurrent.futures.ThreadPoolExecutor(max_workers=self.threads_var.get()) as executor:
                futures = []
                for i, (segment_url, segment_path) in enumerate(zip(segment_urls, segment_files)):
                    if not self.downloading:
                        break
                    
                    future = executor.submit(
                        self.download_segment, 
                        segment_url, 
                        segment_path, 
                        self.retry_var.get()
                    )
                    futures.append((i, future))
                
                # 监控下载进度
                for i, future in futures:
                    if not self.downloading:
                        break
                    
                    success = future.result()
                    if success:
                        self.downloaded_segments += 1
                        self.update_progress(self.downloaded_segments, self.total_segments)
                        self.status_var.set(f"下载中... ({self.downloaded_segments}/{self.total_segments})")
            
            if not self.downloading:
                self.log_message("下载已取消")
                self.cleanup_temp_files(temp_dir)
                self.reset_ui()
                return
            
            # 合并片段
            self.status_var.set("正在合并片段...")
            self.log_message(f"开始合并 {self.downloaded_segments} 个片段")
            
            output_file = os.path.join(save_path, f"{filename}.mp4")
            
            # 使用FFmpeg合并（如果可用）或直接合并
            try:
                # 尝试使用FFmpeg
                import subprocess
                
                # 创建文件列表
                list_file = os.path.join(temp_dir, "file_list.txt")
                with open(list_file, 'w') as f:
                    for segment_file in segment_files:
                        if os.path.exists(segment_file):
                            f.write(f"file '{segment_file}'\n")
                
                # 使用FFmpeg合并
                cmd = [
                    'ffmpeg', '-f', 'concat', '-safe', '0',
                    '-i', list_file, '-c', 'copy',
                    '-y', output_file
                ]
                
                result = subprocess.run(cmd, capture_output=True, text=True)
                
                if result.returncode == 0:
                    self.log_message("使用FFmpeg合并成功")
                else:
                    self.log_message("FFmpeg合并失败，尝试直接合并...")
                    # 直接合并
                    self.merge_segments_directly(segment_files, output_file)
                    
            except Exception as e:
                self.log_message(f"FFmpeg不可用: {str(e)}，尝试直接合并...")
                # 直接合并
                self.merge_segments_directly(segment_files, output_file)
            
            # 清理临时文件
            self.cleanup_temp_files(temp_dir)
            
            if os.path.exists(output_file):
                file_size = os.path.getsize(output_file) / (1024 * 1024)  # MB
                elapsed_time = time.time() - self.start_time
                self.log_message(f"下载完成: {output_file} ({file_size:.2f} MB)")
                self.log_message(f"总耗时: {elapsed_time:.1f} 秒")
                self.status_var.set(f"下载完成! ({file_size:.2f} MB)")
                messagebox.showinfo("完成", f"视频下载完成!\n保存位置: {output_file}\n文件大小: {file_size:.2f} MB")
            else:
                self.log_message("错误: 合并文件失败")
                self.status_var.set("合并文件失败")
            
        except Exception as e:
            self.log_message(f"下载过程中发生错误: {str(e)}")
            self.status_var.set("下载失败")
        finally:
            self.reset_ui()
    
    def merge_segments_directly(self, segment_files, output_file):
        """直接合并TS片段为MP4文件"""
        try:
            with open(output_file, 'wb') as outfile:
                for segment_file in segment_files:
                    if os.path.exists(segment_file):
                        with open(segment_file, 'rb') as infile:
                            outfile.write(infile.read())
            self.log_message("直接合并完成")
        except Exception as e:
            self.log_message(f"直接合并失败: {str(e)}")
    
    def cleanup_temp_files(self, temp_dir):
        """清理临时文件"""
        try:
            import shutil
            if os.path.exists(temp_dir):
                shutil.rmtree(temp_dir)
                self.log_message(f"已清理临时目录: {temp_dir}")
        except Exception as e:
            self.log_message(f"清理临时文件时出错: {str(e)}")
    
    def reset_ui(self):
        """重置UI状态"""
        self.downloading = False
        self.download_btn.config(text="开始下载")
        self.browse_btn.config(state=tk.NORMAL)
        self.clear_btn.config(state=tk.NORMAL)
        self.root.update_idletasks()

def main():
    root = tk.Tk()
    app = M3U8Downloader(root)
    root.mainloop()

if __name__ == "__main__":
    main()