import asyncio #异步编程库，用于处理异步操作
# 导入Playwright的异步API，用于模拟浏览器操作
from playwright.async_api import async_playwright, Page
# 导入随机数库，用于生成随机延时、随机坐标等模拟人类行为
import random
# 导入操作系统库，用于文件路径、目录操作
import os
# 导入正则表达式库，用于文本匹配、清洗
import re
# 导入日期时间库，用于时间处理、格式转换
from datetime import datetime
# 导入警告处理库，用于忽略指定类型的警告
import warnings
# 导入系统库，用于程序退出、系统相关操作
import sys
# 导入HTTP请求库，用于调用dd机器人、DS API
import requests
# 导入时间库，用于同步延时（与asyncio.sleep区分）
import time
# 导入JSON库，用于构造请求体、解析响应
import json

# 1. 预设随机语料库（用于dd推送的前置消息随机化）
# 可自定义增减，提升推送内容的随机性
RANDOM_PREFIXES = [
    "🔔 发现一篇新文章：",
    "📖 今日份深度阅读已送达：",
    "🚀 抓取到一条新动态：",
    "✨ 发现宝藏内容，请查收：",
    "🤖 机器人小助提醒，新文更新：",
    "📺 你订阅的频道有更新啦：",
    "💡 这里的思考值得一看："
]

# dd推送的随机表情库
RANDOM_EMOJIS = ["🌟", "✅", "🔥", "📢", "👀", "☕", "🍀"]

# 忽略未检索的future异常（避免Playwright异步操作触发无关警告）
warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*Future exception was never retrieved.*")

# 全局退出信号标志：用于标记是否接收到退出指令（如Ctrl+C）
SHUTDOWN_REQUESTED = False

# 全局记录上一个处理的WOA：用于本地摘要文件的分组排版
LAST_PROCESSED_MP = None

# ========== 配置项 ==========
# dd机器人Webhook地址：用于推送摘要内容
DING_WEBHOOK_URL = "xxxxxaccess_token=xxxx"
# 调试模式：True=弹出浏览器可视化操作，False=无头模式静默运行
DEBUG_MODE = True
# 每WOA最多抓取最新文章数
MAX_ARTICLE_PER_ACCOUNT = 5
# 最多处理的WOA数量
MAX_ACCOUNT_TO_PROCESS = 8
# 仅抓取当天发布的文章（北京时间）
ONLY_TODAY_ARTICLE = True
# WOA书架地址
SHELF_URL = "xxxxx"
# 项目根目录（基于当前文件路径向上两级）
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 浏览器持久化登录数据目录：用于保存WOA登录状态，避免重复扫码
USER_DATA_DIR = os.path.join(PROJECT_ROOT, "xxxxx")

# 导入time模块~~冗余导入,历史包袱~~
import time

async def random_sleep(min_s=2.0, max_s=5.0, reason=""):
    """
    随机延时函数（异步）：模拟人类操作的无规律停顿
    :param min_s: 最小延时秒数，默认2.0秒
    :param max_s: 最大延时秒数，默认5.0秒
    :param reason: 延时原因描述，用于日志打印
    """
    # 生成指定范围内的随机延时值
    delay = random.uniform(min_s, max_s)
    if reason:
        # 打印延时原因和具体时长（保留1位小数）
        print(f"⏳ {reason}，随机等待 {delay:.1f} 秒...")
    # 异步休眠（不阻塞事件循环）
    await asyncio.sleep(delay)

async def simulate_human_behavior(page):
    """
    模拟真实用户行为：随机鼠标移动 + 随机小滚动
    :param page: Playwright的Page对象，代表浏览器标签页
    """
    try:
        # 1. 随机鼠标移动：获取当前视口尺寸
        vp = page.viewport_size
        if vp:
            width = vp['width']
            height = vp['height']
            # 随机移动1-3次
            for _ in range(random.randint(1, 3)):
                # 生成视口内（100px偏移）的随机坐标
                x = random.randint(100, width - 100)
                y = random.randint(100, height - 100)
                # 模拟鼠标移动（steps越大，移动越慢，更贴近人类）
                await page.mouse.move(x, y, steps=random.randint(5, 15))
                # 每次移动后短暂停顿
                await asyncio.sleep(random.uniform(0.1, 0.4))
        
        # 2. 随机轻微滚动：50%概率触发，模拟人类浏览时的犹豫/无效滚动
        if random.random() > 0.5:
             await page.mouse.wheel(0, random.randint(-50, 150))
    except Exception:
        # 忽略操作异常（如页面未加载完成导致的鼠标移动失败）
        pass

#接收time_text字符串参数（时间信息）
#返回bool值
def is_today_article(time_text: str) -> bool:
    """判断是否是当天发布的文章"""
    if not time_text:
        return False #防御性编程
    # 匹配WOA的时间格式：今天、X小时前、分钟前、刚刚
    if "今天" in time_text or "小时前" in time_text or "分钟前" in time_text or "刚刚" in time_text:
        return True
    return False

def save_article(title, content, mp_name):
    """
    保存原始文章内容到本地Markdown文件
    :param title: 文章标题
    :param content: 文章正文
    :param mp_name: WOA名称
    :return: 保存成功返回True，失败返回False
    """
    try:
        # 构造原始文章存储目录
        base_dir = os.path.join(PROJECT_ROOT, "data/raw_articles")
        # 目录不存在时创建
        if not os.path.exists(base_dir):
            os.makedirs(base_dir)
        
        #清洗标题：移除文件名非法字符
        safe_title=re.sub(r'[\\/:*?"<>|]','_', title).strip()
        # 生成当前日期字符串（YYYYMMDD）
        date_str = datetime.now().strftime("%Y%m%d")
        
        #构造文件名：WOA_日期_标题简写.md
        filename=f"{mp_name}_{date_str}_{safe_title[:15]}.md" 
        #取前15个字防止文件名太长报错
        file_path=os.path.join(base_dir,filename) 
        #把文件夹和文件名拼接成完整路径
        
        #写入markdown
        #以写入模式'w'打开，指定encoDING=‘utf-8’防止中文乱码
        with open(file_path,'w',encoDING='utf-8') as f:
            f.write(f"---\ntitle: \"{title}\"\nmp: \"{mp_name}\"\ndate: {datetime.now()}\n---\n\n")
            f.write(content)
            
        print(f"📁 已保存至: {file_path}")
        return True
    except Exception as e:
        print(f"❌ 存储失败: {e}")
        return False

def clean_user_data_locks():
    """
    清理Chrome用户数据目录下的崩溃锁文件：避免浏览器启动时因锁文件导致的异常
    递归查找，精准匹配常见Chromium锁文件名
    """
    # 目录不存在时直接返回
    if not os.path.exists(USER_DATA_DIR):
        return
    
    # 常见的Chromium锁文件名（精准匹配）
    lock_filenames = {"SingletonLock", "SingletonSocket", "SingletonCookie", "Lock", ".com.google.Chrome.*.lock"}
    
    # 递归遍历目录下的所有文件
    for root, dirs, files in os.walk(USER_DATA_DIR):
        for filename in files:
            # 匹配锁文件名（支持通配符）
            if any(lock_name in filename for lock_name in lock_filenames):
                filepath = os.path.join(root, filename)
                try:
                    # 仅删除文件/软链接，不删除目录
                    if os.path.islink(filepath) or os.path.isfile(filepath):
                        os.remove(filepath)
                        print(f"🧹 已清除浏览器异常锁文件: {filepath}")
                except Exception as e:
                    # 捕获删除失败异常
                    print(f"⚠️ 清理锁文件失败 {filepath}: {e}")

async def handle_captcha(page):
    """
    检测并等待用户手动处理验证码
    :param page: Playwright的Page对象
    :return: 验证通过返回True，超时/失败返回False
    """
    # 引用全局退出标志：验证码处理超时后标记退出
    global SHUTDOWN_REQUESTED
    try:
        # 验证码遮罩层常见选择器（覆盖主流验证码样式）
        captcha_mask = page.locator("xxxxx")
        
        # 快速检测（2秒超时），不拖慢正常流程
        if await captcha_mask.count() > 0 and await captcha_mask.first.is_visible(timeout=2000):
            print("\n🚨🚨🚨 触发人机验证！程序已自动暂停 🚨🚨🚨")
            print("👉 请在弹出的浏览器窗口中手动完成滑块/点选验证...")
            
            try:
                # 5分钟（300000毫秒）超时，等待验证码隐藏（验证完成）
                await captcha_mask.first.wait_for(state="hidden", timeout=300000)
                print("✅ 验证通过！恢复自动执行...")
                await asyncio.sleep(2) # 缓冲，模拟人类验证后的停顿
                return True
            except TimeoutError:
                # 验证码处理超时，标记退出
                print("\n⏰ 验证码处理超时（5分钟），程序将退出！")
                SHUTDOWN_REQUESTED = True
                return False
            
    except Exception:
        # 绝大多数时候无验证码，忽略异常
        pass
    return False

def _request_DING(payload: dict, retry_times=3):
    """
    底层dd推送请求逻辑：负责实际HTTP请求，包含指数退避重试
    :param payload: dd推送的JSON请求体
    :param retry_times: 重试次数，默认3次
    :return: ddAPI响应（JSON格式）或None
    """
    # 未配置Webhook时跳过推送
    if not DING_WEBHOOK_URL:
        print("❌ dd Webhook未配置，跳过推送")
        return None
    
    # 构造请求头（JSON格式）
    headers = {'Content-Type': 'application/json'}
    # 重试逻辑：指数退避（1s→2s→4s）
    for retry in range(retry_times):
        try:
            # 发送POST请求（同步）
            response = requests.post(DING_WEBHOOK_URL, json=payload, headers=headers, timeout=10)
            # 触发HTTP错误（如404/500）
            response.raise_for_status()
            # 返回解析后的JSON响应
            return response.json()
        except Exception as e:
            # 非最后一次重试时，等待后重试
            if retry < retry_times - 1:
                wait_time = 2 ** retry  # 指数退避时间
                print(f"❌ dd推送失败（第{retry+1}次）: {e}，{wait_time}秒后重试...")
                time.sleep(wait_time)
            # 最后一次重试失败，打印错误
            else:
                print(f"❌ dd推送重试{retry_times}次均失败: {e}")
    return None

def send_to_DING(title: str, summary: str, mp_name: str, time_text: str):
    """
    发送摘要到dd机器人：分两步（前置消息+Markdown主体）
    :param title: 文章标题
    :param summary: AI生成的摘要
    :param mp_name: WOA名称
    :param time_text: 文章发布时间
    """
    # 未配置Webhook时直接返回
    if not DING_WEBHOOK_URL:
        return
    # 1. 发送独立的前置消息（Text类型）：随机化提升真实性
    # 随机选择前缀语料和表情
    prefix_text = random.choice(RANDOM_PREFIXES)
    emoji = random.choice(RANDOM_EMOJIS)
    # 拼接前置消息内容
    prefix_content = f"{emoji} {prefix_text}【{mp_name}】"

    # 构造前置消息请求体
    prefix_payload = {
        "msgtype": "text",
        "text": {
            "content": prefix_content
        }
    }
    # 发送前置消息
    print(f"📡 正在推送前置提醒: {prefix_content}")
    _request_DING(prefix_payload)

    # 2. 发送主体的Markdown摘要
    # 构造Markdown格式文本
    markdown_text = f"### {title}\n**来源**：{mp_name}  \n**时间**：{time_text}  \n---\n{summary}"
    # 构造Markdown请求体
    main_payload = {
        "msgtype": "markdown",
        "markdown": {
            "title": f"【摘要】{title}",
            "text": markdown_text
        }
    }

    # 发送Markdown主体消息
    print(f"📡 正在推送文章摘要...")
    result = _request_DING(main_payload)
    
    # 校验推送结果
    if result and result.get('errcode') == 0:
        print("✅ dd全部推送成功")
    else:
        print(f"❌ dd摘要推送失败: {result}")

async def summarize_with_ai(title: str, content: str, mp_name: str, time_text: str):
    """
    DS AI总结逻辑：调用API生成固定格式摘要，写入本地文件并推送dd
    :param title: 文章标题
    :param content: 文章正文
    :param mp_name: WOA名称
    :param time_text: 文章发布时间
    :return: AI生成的摘要或None
    """
    # 引用全局变量：记录上一个处理的WOA（用于文件分组）
    global LAST_PROCESSED_MP
    print(f"\n🤖 正在调用 DS 生成摘要：{title}...")

    # DS API密钥
    api_key = "xxxx"
    # DS API地址
    url = "xxxx"

    # 提示词：强制固定格式，要求客观不浮夸
    prompt = f"""
请阅读以下WOA文章，并生成一段客观、冷静、不浮夸的摘要。
只输出摘要内容，不要任何开场白。

格式严格如下（请替换内容）：
事件：xx公司的xx模型/xxAPP/xx+突破xx领域/实现了xx功能+昭示当前xx领域处于xx态势

文章内容：
{content[:4000]}
"""

    # 构造API请求体
    payload = {
        "model": "deepseek-chat",  # 使用的模型名称
        "messages": [
            {"role": "user", "content": prompt}  # 用户提示词
        ],
        "temperature": 0.5  # 随机性参数（0-1，越低越固定）
    }

    # 构造请求头（携带API密钥）
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        # 异步调用同步的requests.post：避免阻塞Playwright事件循环
        response = await asyncio.to_thread(requests.post, url, json=payload, headers=headers)
        # 触发HTTP错误
        response.raise_for_status()
        # 解析响应JSON
        result = response.json()
        # 提取AI生成的摘要（去除首尾空格）
        ai_summary = result['choices'][0]['message']['content'].strip()

        # 构造写入本地文件的内容：按WOA分组
        summary_content = ""
        # 新WOA时，先写入WOA名称（分组）
        if mp_name != LAST_PROCESSED_MP:
            summary_content += f"\n{mp_name}：\n"
            LAST_PROCESSED_MP = mp_name
        # 追加文章信息和摘要
        summary_content += f"文章标题：{title}\n"
        summary_content += f"时间：{time_text}\n"
        summary_content += f"{ai_summary}\n"

        # 追加写入本地摘要文件（UTF-8编码避免中文乱码）
        summary_file = os.path.join(PROJECT_ROOT, "AI_Daily_Summary.txt")
        with open(summary_file, "a", encoDING="utf-8") as f:
            f.write(summary_content)
            
        print(f"📝 摘要已写入 {summary_file}")
        
        # 异步调用dd推送（避免阻塞）
        await asyncio.to_thread(send_to_DING, title, ai_summary, mp_name, time_text)
        
        return ai_summary
    except Exception as e:
        # 捕获API调用异常
        print(f"❌ DS 调用失败: {e}")
        return None

async def run_summarizer():
    async with async_playwright() as p: #p：遥控器
        #1.启动浏览器，拿浏览器的上下文和标签
        context,page=await launch_browser(p) #🌟launch_browser()实现见后文
        try:
            #2.访问书架，等待页面加载完成
            ##访问书架网址
            await page.goto(SHELF_URL,wait_until="domcontentloaded")
            ##检查登录，未登录提供登录渠道
            await wait_for_shelf_login(page) #🌟wait_for_shelf_login()实现见后文
            ##遍历所有WOA
            await process_all_accounts(page,context) #🌟process_all_accounts()实现参见后文
        
        ##容错模板try...except...finally
        except Exception as e:
            print(f"❌程序运行出错:{str(e)}")
        finally: #无论如何都会做
            await context.close()
            print("程序运行结束，浏览器关闭")

async def launch_browser(p): #传进来的playwright遥控器
    # 启动前清理锁文件：避免浏览器启动异常
    clean_user_data_locks()
    # 启动带持久化数据的浏览器上下文（保留登录状态）
    context = await p.chromium.launch_persistent_context(
        user_data_dir=USER_DATA_DIR,  # 持久化登录数据目录
        headless="new" if not DEBUG_MODE else False,  # 调试模式下显示浏览器
        args=[
            '--no-sandbox',  # 禁用沙箱（Linux环境必要）
            '--disable-blink-features=AutomationControlled',  # 禁用自动化特征
            '--disable-infobars',  # 禁用信息栏（如“Chrome正被自动化软件控制”）
            '--window-size=1440,900',  # 设置窗口尺寸
            # 自定义UA：模拟真实Chrome浏览器（需与实测一致）
            '--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36'
        ],
        ignore_https_errors=True,  # 忽略HTTPS错误（如自签名证书）
        viewport={"width": 1440, "height": 900},  # 设置视口尺寸
        locale='zh-CN',  # 设置语言为中文
        timezone_id='Asia/Shanghai'  # 设置时区为上海（北京时间）
    )
    
    # 抹除webdriver属性（避免被检测为自动化），保留真实window.chrome
    await context.add_init_script("""
        Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
    """)
    
    # 获取默认页面：优先使用已存在的页面，无则新建
    page = context.pages[0] if context.pages else await context.new_page()
    
    print("🚀 浏览器已以真实指纹启动，正在访问WOA书架...")
    return context, page

async def wait_for_shelf_login(page):
    """
    等待书架加载并处理登录逻辑：检测登录状态，未登录则等待用户扫码
    :param page: Playwright的Page对象
    """
    # 等待WOA卡片加载完成
    print("正在检查登录状态...")
    try:
        # 5秒内等待书架元素出现（已登录状态）
        await page.wait_for_selector("xxxxx", timeout=5000)
    except:
        # 未检测到书架元素，提示用户扫码登录
        print("⚠️ 未检测到书架元素，请在弹出的浏览器中手动扫码登录...")
        # 扫码前检查验证码
        await handle_captcha(page)

        # 给用户60秒扫码时间
        await page.wait_for_selector("xxxxx", timeout=60000)
    print("书架加载完成，正在获取WOA列表...")

async def process_all_accounts(page,context):
        #1.定义书架上的元素选择器
    account_selector="xxxxx"

    #2.第一次获取：统计多少WOA元素
    accounts_initial=await page.query_selector_all(account_selector)
    total_account=len(accounts_initial)
    print(f"共找到{total_account}个元素")

    #3.逐一处理每一个WOA
    for account_idx in range(total_account):
        #3.1 跳转回书架页面（防卡顿）
        goto_success=await navigate_to_shelf(page) #🌙参见后文详解
        if not goto_success:
            print("false")
            break

        #3.2强制刷新，获取最新列表（感觉似乎没什么必要）
        # await page.goto(SHELF_URL)
        # await page.wait_for_selector(account_selector)

        # 3.3 重新获取WOA元素（每次循环都刷新，防止报错）
        accounts = await page.query_selector_all(account_selector)
        if account_idx >= len(accounts):
            break

                #3.4 拿到当前要处理的WOA
        current_account = accounts[account_idx]

        # 3.5 获取WOA名称（清理换行、空格）
        account_name = await current_account.inner_text()
        account_name = account_name.replace("\n", "").strip()
        print(f"---------- 正在处理WOA：{account_name} ----------")

        # 3.6 点击进入WOA
        await current_account.click()

        # 3.7 检查：是否符合需求内容，如是否WOA
        try:
            await page.wait_for_selector("xxxxx", timeout=10000)
        except:
            print(f"⚠️ {account_name} 不是，跳过")
            # 不是就退回书架，继续下一个
            await page.goto(SHELF_URL)
            await page.wait_for_selector(account_selector, timeout=5000)
            continue #跳过当前循环的剩余代码，直接下一个WOA

        # 3.8 进入文章列表页（处理新标签页）
        article_list_page = await enter_article_list_page(page, context) #🌙详见后文

        # 3.9 【交给下级】获取并处理该WOA所有文章
        await process_account_articles(article_list_page, account_name) #🌙详见后文（主要处理方法）

async def navigate_to_shelf(page):
    """导航回书架并确保元素加载，自重试防网络波动"""
    account_selector = "xxxxx"
    retry_count = 0
    goto_success = False
    # 最多重试3次
    while retry_count < 3 and not goto_success:
        try:
            # 跳转到书架，只等待DOM加载完成（不等图片）
            await page.goto(SHELF_URL, wait_until="domcontentloaded", timeout=10000)
            # 确认书架元素加载出来
            await page.wait_for_selector(account_selector, timeout=5000)
            goto_success = True
        except Exception as e:
            print(f"跳转书架失败，重试第{retry_count+1}次")
            retry_count += 1
            await asyncio.sleep(1)  # 歇1秒再试，防被强制fh
    return goto_success

async def enter_article_list_page(page, context):
    try:
        # 监听：点击后是否弹出【新标签页】
        async with context.expect_page(timeout=5000) as new_page_info:
            # 点击WOA标题，展开文章列表
            await page.click("xxxxx")
        # 获取新打开的标签页
        article_list_page = await new_page_info.value
    except:
        # 如果没有新标签页，就用当前页
        article_list_page = page
    # 等待文章列表元素出现（5秒超时）
    await article_list_page.wait_for_selector("xxxxx", state="visible", timeout=5000)
    return article_list_page

async def process_account_articles(article_list_page, account_name):
    # 循环：最多的篇数
    for idx in range(min(MAX_ARTICLE_PER_ACCOUNT, 20)):
        should_continue = await process_single_article(article_list_page, account_name, idx) # 调用最底层函数：抓【单篇】☀️详见后文
        # 如果返回False，说明文章抓完了，直接结束循环
        if not should_continue:
            break

async def process_single_article(article_list_page,account_name,idx):
    #1.定义元素定位符
    catalog_toggle_selector = "xxxxx" # 展开列表按钮
    catalog_container_selector = "xxxxx"     # 文章列表容器

    #item_selector = "li.xxxxx"           # 单篇文章条目，但这个是错误的，因为这只是一个包含三篇文章的大框
    # 因此重新定义选择器：同时选中头条和副条
    # 逗号在 CSS 选择器里代表“或”
    target_selector = "xxxxx, xxxxx"


    #2.保证文章列表展开
    try:
        # 检查列表是否隐藏
        is_list_visible = await article_list_page.is_visible(catalog_container_selector)
        if not is_list_visible:
            # 隐藏就点击展开
            await article_list_page.click(catalog_toggle_selector)
            # 等待列表渲染完成
            await article_list_page.wait_for_selector(catalog_container_selector, state="visible", timeout=5000)
    except Exception as e:
        print(f"⚠️ 列表呼出失败，跳过当前WOA | 错误: {e}")
        return False  # 返回False=停止抓此WOA

    #3.直接获取所有文章列表
    current_items = await article_list_page.query_selector_all(target_selector)
    # 如果序号超过文章总数，说明抓完了
    if idx >= len(current_items):
        print("✅ 已遍历完所有可抓取的文章")
        return False

    # 定位到当前要抓的文章
    current_item = current_items[idx]

    # 滚动到元素位置，防止点击不到
    await current_item.scroll_into_view_if_needed()

    title_el = await current_item.query_selector("xxxxx, xxxxx")
    if not title_el:
        return True # 还是没找到就跳过

    preview_title = (await title_el.inner_text()).strip()


    #4.时间过滤逻辑（优化版）
    if ONLY_TODAY_ARTICLE:
        # 1. 先尝试在当前文章块里找时间（适用于头条）
        time_el = await current_item.query_selector("xxxxx")

        # 2. 如果没找到（说明是副条），则向上找父级 li 容器里的时间
        if not time_el:
            # 使用 evaluate 并在 JS 层级向上找最近的 .xxxxx 里的时间
            time_text = await current_item.evaluate("""(node) => {
                const parentLi = node.closest('xxxxx');
                const timeNode = parentLi ? parentLi.querySelector('xxxxx') : null;
                return timeNode ? timeNode.innerText : "";
            }""")
        else:
            time_text = await time_el.inner_text()
                #兜底代码
        if not time_text:
                print(f"⚠️ 无法获取时间，跳过: {preview_title}")
                return True
        # 3. 判断并过滤
        if not is_today_article(time_text):
            print(f"⏭️ 跳过旧文: {preview_title} ({time_text})")
            return True


        #5.点击切换正文（优化版：点击整个文章块，更稳定）
    print(f"🚀 正在加载文章: {preview_title}")
    try:
        await current_item.click()
    except Exception as e:
        print(f"⚠️ 文章点击失败，跳过 | 标题: {preview_title} | 错误: {e}")
        return True

    #5.5验证登录文章内部
    try:
    # 等待文章正文加载
    await article_list_page.wait_for_selector("xxxxx", timeout=10000)
    print("✅ 文章加载成功，开始提取正文")
except Exception as e:
    print(f"❌ 文章加载超时，跳过: {preview_title}")
    return True