# 反模式检测脚本

def detect_over_prompting(prompt: str) -> dict:
    """检测过度限定问题"""

    indicators = {
        "冗余词语重复": 0,
        "过度礼貌": 0,
        "不必要的背景故事": 0,
    }

    # 检测重复的强调词
    emphasis_words = [
        "务必", "必须", "一定", "千万", "重要",
        "请", "拜托", "麻烦", "谢谢"
    ]

    for word in emphasis_words:
        count = prompt.count(word)
        if count > 1:
            indicators["冗余词语重复"] += count - 1

    # 检测长度和复杂性
    sentences = prompt.split("。")
    if len(sentences) > 3 and "但" not in prompt:
        indicators["不必要的背景故事"] += len(sentences) - 3

    # 检查是否过度礼貌
    if prompt.count("请") > 2 or prompt.count("谢谢") > 0:
        indicators["过度礼貌"] += 1

    return {
        "score": sum(indicators.values()),
        "details": indicators,
        "suggestion": "建议精简冗余词汇，直接陈述核心需求"
    }


# 使用示例

bad_prompt = """尊敬的 AI 助手，我今天遇到了一个问题，
希望你能帮我。请务必、一定、千万记住...写一个 Python 函数..."""

result = detect_over_prompting(bad_prompt)
print(f"冗余度计数: {result['score']}")
print(f"建议: {result['suggestion']}")

import json

# 实验：对比两种提示词的结果

prompts = {
    "negative_instruction": """
    不要使用 markdown 格式，不要使用 # 标题，
    不要使用 ** 加粗，不要使用列表。
    请写一个关于 Python 的简介。
    """,

    "positive_instruction": """
    用纯文本格式写一个关于 Python 的简介。
    使用段落，用行号分隔不同的要点。
    """
}

def test_formatting_compliance(prompt, llm):
    """测试格式遵循率"""
    response = llm.generate(prompt)

    has_markdown = any([
        "# " in response,
        "**" in response,
        "- " in response.split("\n")[0],
        "[" in response and "](" in response
    ])

    return {
        "prompt_type": prompt,
        "has_markdown": has_markdown,
        "response_snippet": response[:100]
    }

# 结果通常显示：

# negative_instruction: has_markdown = True (40% 概率)

# positive_instruction: has_markdown = True (5% 概率)

class InstructionFormatter:
    """指令格式优化器"""

    @staticmethod
    def convert_negative_to_positive(instruction: str) -> str:
        """将负向指令转换为正向指令"""

        conversions = {
            "不要使用": "使用",
            "避免": "确保",
            "不能": "应该",
            "千万别": "务必",
            "绝对不要": "必须"
        }

        result = instruction
        for negative, positive in conversions.items():
            if negative in instruction:
                # 找到负向指令的具体内容
                result = result.replace(
                    f"{negative} X",
                    f"{positive} 不使用 X"
                )

        return result

    @staticmethod
    def reframe_restriction(restriction: str) -> str:
        """重新表述限制条件为正向目标"""

        examples = {
            "不要太长": "控制在 100 字以内",
            "不要不清楚": "确保表达清晰",
            "不要离题": "保持话题相关",
            "不要重复": "每个点只提一次",
        }

        for restrict, positive in examples.items():
            restriction = restriction.replace(restrict, positive)

        return restriction

# 修复前后对比

before = """不要用第一人称，不要用长句子，
不要带有感情色彩，不要输出任何 markdown"""

formatter = InstructionFormatter()
after = formatter.convert_negative_to_positive(before)

print("修复前:")
print(before)
print("\n修复后:")
print(after)

class TaskComplexityAnalyzer:
    """任务复杂度分析器"""

    def analyze_prompt(self, prompt: str) -> dict:
        """分析提示词的任务复杂度"""

        # 统计任务数量
        task_indicators = [
            "请",
            "然后",
            "接着",
            "随后",
            "最后",
            "同时",
            "并且"
        ]

        task_count = sum(1 for indicator in task_indicators
                        if indicator in prompt)

        # 统计格式要求数量
        format_keywords = [
            "json",
            "csv",
            "表格",
            "列表",
            "段落",
            "要点",
            "代码"
        ]

        format_count = sum(1 for keyword in format_keywords
                          if keyword in prompt)

        # 计算复杂度分数
        complexity_score = task_count + format_count * 1.5

        recommendation = self._get_recommendation(complexity_score)

        return {
            "task_count": task_count,
            "format_requirements": format_count,
            "complexity_score": complexity_score,
            "recommendation": recommendation
        }

    def _get_recommendation(self, score: float) -> str:
        if score <= 2:
            return "✓ 可以单次处理"
        elif score <= 5:
            return "⚠️ 可能需要分解"
        else:
            return "❌ 强烈建议使用提示词链"

    def suggest_decomposition(self, prompt: str) -> list:
        """建议如何分解任务"""

        # 识别任务边界
        tasks = []

        task_keywords = ["请", "然后", "接着", "最后"]
        parts = prompt.split("。")

        for i, part in enumerate(parts):
            for keyword in task_keywords:
                if keyword in part:
                    tasks.append({
                        "step": i + 1,
                        "content": part.strip(),
                        "type": self._classify_task(part)
                    })
                    break

        return tasks

    def _classify_task(self, task_text: str) -> str:
        """分类任务类型"""
        if any(w in task_text for w in ["翻译", "转换", "改写"]):
            return "转换"
        elif any(w in task_text for w in ["摘要", "总结", "概括"]):
            return "摘要"
        elif any(w in task_text for w in ["分析", "评价", "评分"]):
            return "分析"
        else:
            return "其他"


# 使用示例

analyzer = TaskComplexityAnalyzer()

god_prompt = """请阅读这 10 份财报。
然后将它们翻译成中文。
接着对每一份写个 200 字摘要。
同时评估其情感倾向并打分。
最后将这些汇总成一个带柱状图的 HTML 网页。"""

analysis = analyzer.analyze_prompt(god_prompt)
print(f"复杂度: {analysis['complexity_score']}")
print(f"建议: {analysis['recommendation']}")

decomposition = analyzer.suggest_decomposition(god_prompt)
print("\n建议的分解步骤:")
for task in decomposition:
    print(f"步骤 {task['step']} ({task['type']}): {task['content'][:50]}...")

# 修复：使用提示词链

class FinancialReportProcessor:
    """财务报告处理器（使用链式处理）"""

    def __init__(self, llm_client):
        self.llm = llm_client
        self.results = {}

    def process_report(self, report_text: str) -> dict:
        """处理单个报告"""

        # 步骤 1: 翻译
        translation = self._translate(report_text)
        self.results["translation"] = translation

        # 步骤 2: 摘要
        summary = self._summarize(translation)
        self.results["summary"] = summary

        # 步骤 3: 分析情感和评分
        analysis = self._analyze(summary)
        self.results["analysis"] = analysis

        return self.results

    def _translate(self, text: str) -> str:
        """单独的翻译步骤"""
        prompt = f"""请将以下财务报告翻译成中文。
保持专业术语和格式。

原文：
{text}"""

        return self.llm.generate(prompt)

    def _summarize(self, text: str) -> str:
        """单独的摘要步骤"""
        prompt = f"""请用 200 字总结以下财务报告的关键要点：

{text}"""

        return self.llm.generate(prompt)

    def _analyze(self, text: str) -> dict:
        """单独的分析步骤"""
        prompt = f"""分析以下财务报告摘要：
1. 情感倾向（正面/中立/负面）
2. 风险评级（1-5 分，5 分风险最高）

摘要：
{text}

请返回 JSON 格式：
{{"sentiment": "...", "risk_score": ...}}"""

        response = self.llm.generate(prompt)
        return json.loads(response)

    def batch_process(self, reports: list) -> dict:
        """批量处理多个报告"""
        results = {}
        for i, report in enumerate(reports):
            results[f"report_{i+1}"] = self.process_report(report)

        return results


# 使用

processor = FinancialReportProcessor(llm_client)
all_results = processor.batch_process(reports)

def check_rigid_formatting(prompt: str) -> bool:
    """检测是否有过于严格的格式要求"""

    rigid_patterns = [
        r"缩进.*个空格",
        r"must.*align",
        r"空格.*对齐",
        r"固定.*格式",
    ]

    return any(re.search(p, prompt) for p in rigid_patterns)

def check_escape_hatch(prompt: str) -> bool:
    """检查是否提供了逃生通路"""

    escape_keywords = [
        "如果找不到",
        "如果不知道",
        "如果无法",
        "返回 null",
        "return None",
        "not found",
        "unclear"
    ]

    has_escape = any(kw in prompt for kw in escape_keywords)
    return has_escape

class AntiPatternDiagnostics:
    """反模式诊断工具"""

    def diagnose_all(self, prompt: str) -> dict:
        """全面诊断提示词中的反模式"""

        results = {
            "over_prompting": self._check_over_prompting(prompt),
            "negative_first": self._check_negative_first(prompt),
            "god_prompt": self._check_god_prompt(prompt),
            "rigid_formatting": self._check_rigid_formatting(prompt),
            "no_escape": self._check_no_escape(prompt),
            "context_pollution": self._check_context_pollution(prompt),
        }

        # 计算总体健康分数
        results["health_score"] = self._calculate_health_score(results)
        results["recommendations"] = self._generate_recommendations(results)

        return results

    def _calculate_health_score(self, results: dict) -> float:
        """计算提示词的健康分数（0-100）"""
        issues = sum(1 for k, v in results.items()
                    if k != "health_score" and v.get("severity", 0) > 0)
        return max(0, 100 - issues * 10)

    def _generate_recommendations(self, results: dict) -> list:
        """基于诊断结果生成改进建议"""
        recommendations = []

        for issue_type, issue_data in results.items():
            if issue_type == "health_score":  # 已在上一行写入，是 float 而非诊断字典
                continue
            if issue_data.get("severity", 0) > 0:
                recommendations.append({
                    "issue": issue_type,
                    "severity": issue_data["severity"],
                    "suggestion": issue_data.get("suggestion", "")
                })

        return sorted(recommendations, key=lambda x: x["severity"], reverse=True)

    def _check_over_prompting(self, prompt: str) -> dict:
        # 实现检测逻辑；返回值必须含 severity（0 表示未命中）与 suggestion，
        # 否则 _calculate_health_score / _generate_recommendations 会在 None 上取值
        return {"severity": 0, "suggestion": ""}

    def _check_negative_first(self, prompt: str) -> dict:
        # 实现检测逻辑
        return {"severity": 0, "suggestion": ""}

    # ... 其他检测方法（_check_god_prompt、_check_rigid_formatting、
    # _check_no_escape、_check_context_pollution，返回结构同上）