# 使用pip安装pytdlib
pip install pytdlib

mkdir telegram-custom-client && cd telegram-custom-client
# 创建虚拟环境（推荐）
python -m venv venv
# 激活虚拟环境
# Windows: venv\Scripts\activate
# Linux/macOS: source venv/bin/activate

# 创建主要文件
touch main.py config.py utils.py

# config.py
API_ID = 1234567  # 替换为你的 api_id
API_HASH = "your_api_hash_here"  # 替换为你的 api_hash
PHONE_NUMBER = "+8612345678900"  # 你的Telegram账号绑定的手机号（国际格式）

# main.py
import asyncio
import pytdlib
from pytdlib import Client
from config import API_ID, API_HASH, PHONE_NUMBER

class CustomTelegramClient:
    def __init__(self):
        self.client = None
        self.is_authorized = False

    async def start(self):
        """启动客户端并开始事件循环"""
        # 1. 创建客户端实例
        self.client = Client(
            api_id=API_ID,
            api_hash=API_HASH,
            phone_number=PHONE_NUMBER,
            database_encryption_key="you_can_set_any_passphrase_here", # 本地数据库加密密钥
            files_directory="./tdlib_files" # TDLib数据存储目录
        )
        
        # 2. 启动客户端（开始连接）
        await self.client.start()
        
        # 3. 设置更新处理器
        self.client.on_update = self.handle_update
        
        print("客户端已启动，等待授权...")
        
        # 4. 主循环，保持程序运行
        while True:
            await asyncio.sleep(1)
            
    async def handle_update(self, update):
        """处理所有收到的更新"""
        update_type = update["@type"]
        
        # 处理授权状态更新（最重要！）
        if update_type == "updateAuthorizationState":
            auth_state = update["authorization_state"]["@type"]
            await self.handle_auth_state(auth_state)
        
        # 处理新消息
        elif update_type == "updateNewMessage":
            message = update["message"]
            await self.handle_new_message(message)
        
        # 可以在此添加处理其他更新类型，如用户状态、聊天列表变化等
        # else:
        #     print(f"收到更新: {update_type}")
    
    async def handle_auth_state(self, state):
        """根据授权状态采取相应动作"""
        print(f"当前授权状态: {state}")
        
        if state == "authorizationStateWaitPhoneNumber":
            # 状态：等待手机号 -> 发送手机号
            await self.client.send({
                "@type": "setAuthenticationPhoneNumber",
                "phone_number": PHONE_NUMBER
            })
            print("已发送手机号...")
            
        elif state == "authorizationStateWaitCode":
            # 状态：等待验证码 -> 在控制台输入
            code = input("请输入从Telegram应用收到的验证码: ")
            await self.client.send({
                "@type": "checkAuthenticationCode",
                "code": code
            })
            
        elif state == "authorizationStateWaitPassword":
            # 状态：等待两步验证密码（如果有设置）
            password = input("请输入您的两步验证密码: ")
            await self.client.send({
                "@type": "checkAuthenticationPassword",
                "password": password
            })
            
        elif state == "authorizationStateReady":
            # 状态：授权完成！
            print("*** 授权成功！客户端已就绪。 ***")
            self.is_authorized = True
            await self.on_ready() # 授权后执行初始化操作
            
        elif state == "authorizationStateClosed":
            print("授权连接已关闭。")
            
    async def handle_new_message(self, message):
        """处理新收到的消息"""
        chat_id = message["chat_id"]
        content = message["content"]
        
        # 提取发送者信息（可能需要额外请求获取）
        sender_id = message.get("sender_id", {}).get("user_id", 0)
        
        # 判断消息内容类型
        if content["@type"] == "messageText":
            text = content["text"]["text"]
            print(f"\n[新消息] 来自 {sender_id} 在聊天 {chat_id}: {text}")
            
            # 示例：自动回复（可根据需要开启）
            # await self.send_text_message(chat_id, f"已收到您的消息: {text}")
    
    async def on_ready(self):
        """授权成功后执行的初始化操作"""
        print("正在加载最近的聊天列表...")
        # 获取最近的20个聊天
        chats = await self.client.invoke({
            "@type": "getChats",
            "chat_list": {"@type": "chatListMain"},
            "limit": 20
        })
        if chats and "chat_ids" in chats:
            print(f"已加载 {len(chats['chat_ids'])} 个聊天。")
            for cid in chats["chat_ids"]:
                # 获取每个聊天的详细信息
                chat_info = await self.client.invoke({
                    "@type": "getChat",
                    "chat_id": cid
                })
                title = chat_info.get("title", f"ID:{cid}")
                print(f"  - {title} (ID: {cid})")
        
        print("\n自定义客户端初始化完成。开始监听消息...")
    
    async def send_text_message(self, chat_id, text):
        """发送文本消息的辅助方法"""
        if not self.is_authorized:
            print("未授权，无法发送消息。")
            return
            
        try:
            await self.client.invoke({
                "@type": "sendMessage",
                "chat_id": chat_id,
                "input_message_content": {
                    "@type": "inputMessageText",
                    "text": {"@type": "formattedText", "text": text},
                    "disable_web_page_preview": True,
                    "clear_draft": False
                }
            })
            print(f"消息已发送至聊天 {chat_id}。")
        except Exception as e:
            print(f"发送消息失败: {e}")
    
    async def interactive_send(self):
        """一个简单的交互式发送消息循环（可在另一个任务运行）"""
        while not self.is_authorized:
            await asyncio.sleep(1)
            
        print("\n=== 交互式消息发送模式 ===")
        print("格式: `chat_id 消息内容`")
        print("例如: `123456789 你好，世界！`")
        print("输入 'quit' 退出。")
        
        while True:
            try:
                user_input = input("\n发送 > ").strip()
                if user_input.lower() == 'quit':
                    break
                    
                if ' ' not in user_input:
                    print("格式错误。请使用 `chat_id 消息内容` 格式。")
                    continue
                    
                chat_id_str, message_text = user_input.split(' ', 1)
                try:
                    chat_id = int(chat_id_str)
                except ValueError:
                    print("聊天ID必须是数字。")
                    continue
                    
                await self.send_text_message(chat_id, message_text)
                
            except KeyboardInterrupt:
                break
            except Exception as e:
                print(f"出错: {e}")

async def main():
    client = CustomTelegramClient()
    
    # 创建两个并发的任务：一个运行客户端，一个运行交互式发送
    client_task = asyncio.create_task(client.start())
    # 可选：启动交互式发送（根据需要注释或取消注释）
    # sender_task = asyncio.create_task(client.interactive_send())
    
    # 等待客户端任务结束（通常不会，除非出错）
    await client_task
    # 如果启动了sender_task，也需要await
    # await sender_task

if __name__ == "__main__":
    asyncio.run(main())