TikTok 智能自动回复系统 v3.0

class SentimentAnalyzer:
    """基于词典的情感分析器"""

    def __init__(self):
        self.positive_words = [
            '喜欢', '爱', '开心', '棒', '漂亮',
            'love', 'nice', 'good', 'great', 'amazing'
        ]
        self.negative_words = [
            '讨厌', '生气', '垃圾', '差',
            'hate', 'bad', 'terrible'
        ]
        self.intensifiers = [
            '非常', '超级', '太', '特别',
            'very', 'so', 'extremely'
        ]

    def analyze(self, text: str) -> Dict:
        """分析文本情感，返回情感得分和极性"""
        words = re.findall(r'[\u4e00-\u9fff\w]+', text.lower())

        pos_score, neg_score = 0, 0
        for i, word in enumerate(words):
            if word in self.positive_words:
                multiplier = 1.5 if i > 0 and words[i-1] in self.intensifiers else 1.0
                pos_score += 1.0 * multiplier

        total = pos_score + neg_score
        if total == 0:
            polarity = 'neutral'
        else:
            score = (pos_score - neg_score) / total
            polarity = 'positive' if score > 0.3 else (
                'negative' if score < -0.3 else 'neutral')

        return {
            'polarity': polarity,
            'is_question': text.endswith('?') or '什么' in text,
            'is_thanks': '谢谢' in text.lower()
        }

class ConversationMemory:
    """基于 Redis-style 的对话记忆管理"""

    def __init__(self, max_users: int = 1000, max_history: int = 20):
        self.max_users = max_users
        self.max_history = max_history
        self.sessions: Dict[str, Dict] = {}

    def add_message(self, username: str, message: str, is_bot: bool = False):
        uid = hashlib.md5(username.encode()).hexdigest()[:12]
        if uid not in self.sessions:
            self.sessions[uid] = {
                'username': username,
                'history': [],
                'extracted_info': {},
                'last_seen': time.time(),
                'message_count': 0
            }

        self.sessions[uid]['last_seen'] = time.time()
        self.sessions[uid]['message_count'] += 1
        self.sessions[uid]['history'].append({
            'role': 'bot' if is_bot else 'user',
            'text': message,
            'time': time.time()
        })

        # 自动抽取用户信息
        if not is_bot:
            self._extract_info(uid, message)

    def get_context(self, username: str) -> Dict:
        """获取用户的对话上下文（最后6条消息）"""
        uid = hashlib.md5(username.encode()).hexdigest()[:12]
        session = self.sessions.get(uid)
        return {
            'history': session['history'][-6:] if session else [],
            'info': session.get('extracted_info', {}) if session else {},
            'message_count': session.get('message_count', 0) if session else 0
        }

class AntiDetectionEngine:
    """TikTok 反机器人检测机制"""

    def __init__(self):
        # 各时段响应概率（0-23时）
        self.hour_probability = {
            0: 0.05, 3: 0.01, 6: 0.05,
            9: 0.40, 12: 0.60, 15: 0.40,
            18: 0.60, 20: 0.80, 22: 0.70
        }
        # 回复延迟范围
        self.delay_ranges = {
            'first_message': (5.0, 15.0),  # 首次慢回
            'normal': (1.0, 5.0),
            'slow': (8.0, 25.0),          # 深夜
        }
        # 打字错误映射
        self.typo_patterns = [
            ('的', '滴'), ('了', '啦'),
            ('吗', '嘛'), ('好', '嗷'),
            ('是', '系'), ('我', '偶'),
        ]

    def get_delay(self, message_count: int, hour=None) -> float:
        """计算类人回复延迟"""
        if message_count <= 1:
            delay_range = self.delay_ranges['first_message']
        elif hour is not None and hour < 7:
            delay_range = self.delay_ranges['slow']
        else:
            delay_range = self.delay_ranges['normal']
        return round(random.uniform(*delay_range), 2)

    def apply_typo(self, text: str, prob=0.08) -> str:
        """模拟打字错误（8%概率）"""
        if random.random() > prob:
            return text
        for correct, typo in self.typo_patterns:
            if correct in text:
                return text.replace(correct, typo, 1)
        return text

    def apply_correction(self, text: str, prob=0.05) -> str:
        """模拟发现打错字纠正（5%概率）"""
        if random.random() > prob:
            return text
        corrections = ['啊打错了', '手滑了…', '哎呀打错了']
        return text.rstrip() + '\n' + random.choice(corrections)

class HumanLikeReplyGenerator:
    """自然语言回复生成器 - 多种风格"""

    def __init__(self):
        self.kaomoji = [
            '(｡>ㅅ<｡)', '(´•ω•\`)', '(≧▽≦)',
            '(◕‿◕✿)', '(｡♥‿♥｡)', '(人´∀\`)♪',
            '(●´ω｀●)', '(✧ω✧)', '(๑˃ᴗ˂)ﻭ'
        ]
        self.reply_templates = {
            'greeting': {
                'warm': [
                    '哈喽~ 你来啦！{kaomoji}',
                    '你好呀！等你好久了～{kaomoji}',
                    'hello hello！好久不见呀～'
                ],
                'cute': [
                    '呜哇！来人了！欢迎欢迎～{kaomoji}',
                    '叮！捕捉到一只活的小可爱！{kaomoji}'
                ]
            },
            'compliment': {
                'shy': [
                    '真的吗？好害羞～不要这样夸人家啦～{kaomoji}',
                    '哪有你说的那么好啦～不过还是谢谢！'
                ],
                'playful': [
                    '那必须的！每天照镜子都被自己美醒～',
                    '嘻嘻～给你个特权，以后多夸夸我！'
                ]
            }
        }

    def generate(self, text, sentiment, matched_intents, context, style='warm'):
        """根据情感、意图和上下文生成回复"""
        polarity = sentiment.get('polarity', 'neutral')

        # 根据情感调整风格
        if polarity == 'negative':
            style = 'warm'
        elif polarity == 'positive' and random.random() < 0.3:
            style = 'cute'

        # 选择模板并填充
        primary_intent = matched_intents[0]['category'] if matched_intents else 'default'
        templates = self.reply_templates.get(primary_intent, {})
        template_list = templates.get(style, templates.get('warm', []))
        reply = random.choice(template_list) if template_list else ''

        # 添加自然语言元素
        if random.random() < 0.15:
            filler = random.choice(['嗯…', '那个…', '就是说…'])
            reply = filler + reply

        return reply.replace('{kaomoji}', random.choice(self.kaomoji))

class TikTokAutoReplySystem:
    """TikTok 智能自动回复系统主控制器"""

    def __init__(self):
        self.sentiment = SentimentAnalyzer()
        self.keyword_matcher = KeywordMatcher()
        self.memory = ConversationMemory()
        self.reply_gen = HumanLikeReplyGenerator()
        self.anti_detection = AntiDetectionEngine()
        self.stats = {
            'start_time': time.time(),
            'total_responses': 0,
            'responded_users': set()
        }

    def process_message(self, username: str, text: str) -> Optional[str]:
        """处理单条消息的完整流水线"""
        now = datetime.now()

        # 1. 反检测 - 判断是否回复
        if not self.anti_detection.should_respond(now.hour):
            return None

        # 2. 情感分析
        sentiment = self.sentiment.analyze(text)

        # 3. 关键词匹配
        matched_intents = self.keyword_matcher.match(text)

        # 4. 获取对话上下文
        context = self.memory.get_context(username)

        # 5. 存储消息
        self.memory.add_message(username, text, is_bot=False)

        # 6. 计算延迟
        delay = self.anti_detection.get_delay(
            context['message_count'], now.hour)
        time.sleep(delay)

        # 7. 生成回复
        reply = self.reply_gen.generate(
            text, sentiment, matched_intents, context)

        # 8-9. 打字错误 + 纠正
        reply = self.anti_detection.apply_typo(reply)
        reply = self.anti_detection.apply_correction(reply)

        # 10. 存储回复
        self.memory.add_message(username, reply, is_bot=True)
        self.stats['total_responses'] += 1
        self.stats['responded_users'].add(username)

        return reply

    def chat(self, username='guest'):
        """交互式聊天模式"""
        print(f'\n🎀 欢迎 {username}！开始聊天吧！\n')
        while True:
            text = input('你: ').strip()
            if text.lower() in ('q', 'quit', 'exit'):
                break
            reply = self.process_message(username, text)
            print(f'Bot: {reply}' if reply else '(已读不回模式)')