import glob
from pathlib import Path

paths = glob.glob('**/Downloader_UI.py', recursive=True)
if not paths:
    raise SystemExit('No Downloader_UI.py files found')

new_download_file = '''    def download_file(self, url, filepath):
        temp_filepath = f"{filepath}.part.{os.getpid()}.{threading.get_ident()}"
        try:
            os.makedirs(os.path.dirname(filepath), exist_ok=True)

            try:
                response_head = self.session.head(url, timeout=15, allow_redirects=True)
                file_size = int(response_head.headers.get('content-length', -1))
            except Exception:
                file_size = -1

            if not self.force_download and os.path.exists(filepath):
                local_size = os.path.getsize(filepath)
                if file_size > 0:
                    if local_size == file_size:
                        self.log_message(f"   ⏭️ Already exists ({self.format_bytes(file_size)}), skipping")
                        return True, file_size
                    else:
                        self.log_message(
                            f"   ⚠️ Size mismatch (local: {self.format_bytes(local_size)}, remote: {self.format_bytes(file_size)}), re-downloading"
                        )
                else:
                    self.log_message(
                        f"   ⚠️ Remote size unknown; existing file may be incomplete, re-downloading"
                    )

            self.log_message(f"   ⬇️ Downloading ({self.format_bytes(file_size) if file_size > 0 else 'unknown size'})...")
            response = self.session.get(url, stream=True, timeout=30)
            response.raise_for_status()

            downloaded = 0
            start_time = time.time()

            with open(temp_filepath, 'wb') as f:
                for chunk in response.iter_content(chunk_size=1024 * 512):
                    if not self.is_downloading:
                        if os.path.exists(temp_filepath):
                            try:
                                os.remove(temp_filepath)
                            except Exception:
                                pass
                        return False, downloaded

                    while self.is_paused and self.is_downloading:
                        time.sleep(0.5)

                    if chunk:
                        f.write(chunk)
                        downloaded += len(chunk)

                        if file_size > 0:
                            progress = (downloaded / file_size) * 100
                            self.window['-PROGRESS-'].update(int(progress))
                            self.window['-PERCENT-'].update(f"{progress:.1f}%")

                            elapsed = time.time() - start_time
                            if elapsed > 0:
                                speed = downloaded / elapsed / (1024 * 1024)
                                self.window['-SPEED-'].update(f"{speed:.2f} MB/s")
                                eta_sec = (file_size - downloaded) / (downloaded / elapsed)
                                self.window['-ETA-'].update(
                                    f"{int(eta_sec // 60)}m {int(eta_sec % 60)}s"
                                )

                        self.window['-DOWNLOADED-'].update(self.format_bytes(downloaded))

            if os.path.exists(temp_filepath):
                os.replace(temp_filepath, filepath)

            if os.path.exists(filepath):
                actual_size = os.path.getsize(filepath)
                self.log_message(f"   ✅ Saved: {self.format_bytes(actual_size)}")
                return True, actual_size
            else:
                self.log_message("   ❌ File not created!")
                return False, 0

        except Exception as e:
            if os.path.exists(temp_filepath):
                try:
                    os.remove(temp_filepath)
                except Exception:
                    pass
            self.log_message(f"   ❌ Error: {str(e)}")
            return False, 0
'''

for path_str in paths:
    path = Path(path_str)
    text = path.read_text(encoding='utf-8')
    if 'self.session = requests.Session()' not in text:
        text = text.replace(
            '        self.download_thread = None\n        self.force_download = False\n',
            '        self.download_thread = None\n        self.force_download = False\n        self.session = requests.Session()\n'
        )
    start = text.find('    def download_file(self, url, filepath):')
    end = text.find('    def download_worker(self):', start)
    if start == -1 or end == -1:
        print('skip', path)
        continue
    text = text[:start] + new_download_file + text[end:]
    path.write_text(text, encoding='utf-8')
    print('patched', path)