Papercash

{
  "name": "papercash",
  "version": "1.0.0",
  "description": "PaperCash - 论文全流程辅助 Skill",
  "skill_file": "../SKILL.md",
  "author": "Jesse (@Jesseovo)",
  "repository": "https://github.com/Jesseovo/PaperCash",
  "license": "MIT"
}

__pycache__/
*.py[cod]
*$py.class
*.egg-info/
dist/
build/
.eggs/
*.egg
.env
*.env
.venv/
venv/
ENV/
.cache/
*.db
*.sqlite3
.DS_Store
Thumbs.db
*.log
.idea/
.vscode/
*.swp
*.swo
推文/
article/

name: papercash
description: "Full-stack academic paper assistance: search, review, write, check, humanize, cite"
version: "1.0.0"
skill_file: SKILL.md
triggers:
  - "papercash"
  - "论文"
  - "文献"
  - "查重"
  - "降AI"
  - "参考文献"
  - "paper"
  - "citation"

{
  "name": "papercash",
  "tagline": "论文全流程辅助 — 免费查文献、查重、降AI率、参考文献格式化",
  "description": "PaperCash 聚合 Semantic Scholar、arXiv、CrossRef、百度学术等 8 大学术数据源，提供论文检索、文献综述自动生成、查重预检、降AI率改写、参考文献格式化（GB/T 7714 / APA / BibTeX）、Word 导出等全流程功能，帮助中国大学生省时省钱完成论文。",
  "category": "research",
  "tags": ["academic", "paper", "citation", "literature-review", "plagiarism", "chinese"],
  "version": "1.1.0",
  "license": "MIT",
  "author": "Jesse (@Jesseovo)",
  "repository": "https://github.com/Jesseovo/PaperCash",
  "support": "https://github.com/Jesseovo/PaperCash/issues",
  "skill_file": "SKILL.md",
  "requires": {
    "bins": ["python3"]
  }
}

{
  "description": "示例搜索结果 - 用于测试和演示",
  "query": "深度学习 医学图像",
  "sample_papers": [
    {
      "title": "Deep Learning in Medical Imaging: A Survey",
      "authors": ["Geert Litjens", "Thijs Kooi", "Babak Ehteshami Bejnordi"],
      "year": 2017,
      "doi": "10.1016/j.media.2017.07.005",
      "citation_count": 12500,
      "source": "Semantic Scholar",
      "venue": "Medical Image Analysis"
    },
    {
      "title": "深度学习在医学图像分析中的应用综述",
      "authors": ["张三", "李四", "王五"],
      "year": 2023,
      "doi": null,
      "citation_count": 156,
      "source": "百度学术",
      "venue": "计算机学报"
    }
  ]
}

{
  "name": "papercash",
  "display_name": "PaperCash - Academic Paper Skill",
  "description": "Full-stack academic paper assistance: search, literature review, writing, plagiarism check, AI detection reduction, citation management",
  "version": "1.0.0",
  "entry_point": "SKILL.md",
  "author": "Jesse (@Jesseovo)",
  "repository": "https://github.com/Jesseovo/PaperCash",
  "license": "MIT",
  "keywords": ["paper", "academic", "citation", "literature-review", "plagiarism", "ai-detection"]
}

"""Session 启动钩子 - 验证配置"""

import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "scripts", "lib"))

from env import diagnose
from ui import header, success, warning, info


def on_session_start():
    """Session 启动时自动检查配置"""
    status = diagnose()
    free_sources = [
        "semantic_scholar",
        "arxiv",
        "crossref",
        "baidu_xueshu",
        "pubmed",
    ]
    free_ok = all(status.get(s) is True for s in free_sources)

    if free_ok:
        info("PaperCash: 免费数据源就绪")
    else:
        warning("PaperCash: 部分数据源不可用，运行 'papercash --diagnose' 检查")

    optional = {k: v for k, v in status.items() if k not in free_sources}
    configured = [k for k, v in optional.items() if v is True]
    if configured:
        info(f"PaperCash: 已配置扩展源: {', '.join(configured)}")


if __name__ == "__main__":
    on_session_start()

MIT License

Copyright (c) 2026 Jesse (@Jesseovo)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

jieba>=0.42.1
requests>=2.31.0
beautifulsoup4>=4.12.0
python-docx>=1.1.0

"""PaperCash - 论文全流程辅助引擎"""

__version__ = "1.0.0"

"""简易文件缓存"""

import json
import hashlib
import time
from pathlib import Path
from typing import Any, Optional

_CACHE_DIR = Path.home() / ".cache" / "papercash"
_DEFAULT_TTL = 3600 * 24  # 24 hours


def _ensure_dir():
    _CACHE_DIR.mkdir(parents=True, exist_ok=True)


def _key_path(key: str) -> Path:
    h = hashlib.sha256(key.encode()).hexdigest()[:16]
    return _CACHE_DIR / f"{h}.json"


def get(key: str) -> Optional[Any]:
    path = _key_path(key)
    if not path.exists():
        return None
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
        if time.time() - data.get("_ts", 0) > data.get("_ttl", _DEFAULT_TTL):
            path.unlink(missing_ok=True)
            return None
        return data.get("value")
    except (json.JSONDecodeError, KeyError):
        return None


def put(key: str, value: Any, ttl: int = _DEFAULT_TTL):
    _ensure_dir()
    path = _key_path(key)
    data = {"_ts": time.time(), "_ttl": ttl, "value": value}
    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")


def clear():
    if _CACHE_DIR.exists():
        for f in _CACHE_DIR.glob("*.json"):
            f.unlink(missing_ok=True)

"""日期工具"""

from datetime import datetime, timezone


def current_year() -> int:
    return datetime.now(timezone.utc).year


def years_ago(year: int) -> int:
    return max(0, current_year() - year)


def recency_score(year: int, max_age: int = 10) -> float:
    """计算时效性分数 (0.0 ~ 1.0)，越新越高"""
    age = years_ago(year)
    if age <= 0:
        return 1.0
    if age >= max_age:
        return 0.1
    return 1.0 - (age / max_age) * 0.9


def parse_year(text: str) -> int:
    """从各种日期格式中提取年份"""
    if not text:
        return 0
    text = text.strip()
    if text.isdigit() and len(text) == 4:
        return int(text)
    for fmt in ("%Y-%m-%d", "%Y-%m", "%Y/%m/%d", "%d %b %Y", "%B %Y"):
        try:
            return datetime.strptime(text[:10], fmt).year
        except ValueError:
            continue
    for i in range(len(text) - 3):
        chunk = text[i:i + 4]
        if chunk.isdigit():
            y = int(chunk)
            if 1900 <= y <= 2100:
                return y
    return 0

"""论文去重"""

from __future__ import annotations
import re

from schema import Paper


def _normalize_title(title: str) -> str:
    text = title.lower().strip()
    text = re.sub(r"[^\w\s\u4e00-\u9fff]", "", text)
    text = re.sub(r"\s+", " ", text)
    return text


def _title_fingerprint(title: str) -> str:
    norm = _normalize_title(title)
    words = norm.split()
    return " ".join(words[:8])


def dedupe_papers(papers: list[Paper]) -> list[Paper]:
    """基于标题和 DOI 去重，保留分数最高的"""
    seen_dois: dict[str, int] = {}
    seen_titles: dict[str, int] = {}
    result: list[Paper] = []

    sorted_papers = sorted(papers, key=lambda p: p.final_score, reverse=True)

    for paper in sorted_papers:
        if paper.doi:
            doi_lower = paper.doi.lower()
            if doi_lower in seen_dois:
                existing = result[seen_dois[doi_lower]]
                if paper.abstract and not existing.abstract:
                    existing.abstract = paper.abstract
                if paper.citation_count > existing.citation_count:
                    existing.citation_count = paper.citation_count
                continue
            seen_dois[doi_lower] = len(result)

        fp = _title_fingerprint(paper.title)
        if fp and fp in seen_titles:
            existing = result[seen_titles[fp]]
            if paper.abstract and not existing.abstract:
                existing.abstract = paper.abstract
            if paper.citation_count > existing.citation_count:
                existing.citation_count = paper.citation_count
            continue
        if fp:
            seen_titles[fp] = len(result)

        result.append(paper)

    return result

"""环境配置管理"""

import os
from pathlib import Path

import requests

_CONFIG_DIR = Path.home() / ".config" / "papercash"
_PROJECT_ENV = Path(".papercash.env")

_cache: dict[str, str] = {}

_PROBE_TIMEOUT = 3.0
_PROBE_HEADERS = {"User-Agent": "PaperCash/1.0 (diagnostic)"}


def _load_env_file(path: Path) -> dict[str, str]:
    result: dict[str, str] = {}
    if not path.exists():
        return result
    for line in path.read_text(encoding="utf-8").splitlines():
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        if "=" not in line:
            continue
        key, _, value = line.partition("=")
        result[key.strip()] = value.strip().strip("'\"")
    return result


def _ensure_loaded():
    if _cache:
        return
    global_env = _CONFIG_DIR / ".env"
    _cache.update(_load_env_file(global_env))
    _cache.update(_load_env_file(_PROJECT_ENV))


def get(key: str, default: str = "") -> str:
    _ensure_loaded()
    return os.environ.get(key, _cache.get(key, default))


def _probe_head(url: str) -> bool | str:
    try:
        r = requests.head(
            url,
            timeout=_PROBE_TIMEOUT,
            allow_redirects=True,
            headers=_PROBE_HEADERS,
        )
        if r.status_code == 405:
            r = requests.get(
                url,
                timeout=_PROBE_TIMEOUT,
                allow_redirects=True,
                headers=_PROBE_HEADERS,
                stream=True,
            )
            r.close()
        if 200 <= r.status_code < 400:
            return True
        return f"HTTP {r.status_code}"
    except requests.Timeout:
        return "timeout"
    except requests.ConnectionError:
        return "connection error"
    except OSError as e:
        return str(e)


def diagnose() -> dict[str, bool | str]:
    """诊断各数据源的配置状态；免费源通过轻量请求检验连通性。"""
    _ensure_loaded()
    endpoints = {
        "semantic_scholar": (
            "https://api.semanticscholar.org/graph/v1/paper/search?query=test&limit=1"
        ),
        "arxiv": "https://export.arxiv.org/api/query?search_query=test&max_results=1",
        "crossref": "https://api.crossref.org/works?query=test&rows=1",
        "pubmed": (
            "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
            "?db=pubmed&term=test&retmax=1"
        ),
        "baidu_xueshu": "https://xueshu.baidu.com/s?wd=test",
    }
    result: dict[str, bool | str] = {k: _probe_head(u) for k, u in endpoints.items()}
    result["google_scholar"] = bool(get("GOOGLE_SCHOLAR_PROXY"))
    result["cnki"] = bool(get("CNKI_COOKIE"))
    result["wanfang"] = bool(get("WANFANG_COOKIE"))
    return result


def config_dir() -> Path:
    return _CONFIG_DIR

"""PaperCash 功能模块"""

"""降AI率改写 - 让AI生成内容更像人写的"""

from __future__ import annotations
import re
import random
import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from query import is_chinese

_AI_CLICHES_CN = {
    "综上所述": ["基于上述分析", "通过以上论述可以发现", "回顾前文的讨论"],
    "总而言之": ["概括而言", "从整体来看", "纵观全局"],
    "值得注意的是": ["需要指出的是", "一个关键的发现是", "不容忽视的是"],
    "众所周知": ["学界普遍认为", "已有研究表明", "根据现有文献"],
    "随着社会的发展": ["在当前背景下", "伴随着相关技术的演进", "在新形势下"],
    "随着科技的进步": ["技术变革推动下", "得益于技术突破", "在技术快速迭代的背景下"],
    "本文认为": ["笔者认为", "基于实证分析发现", "从研究结果来看"],
    "在当今社会": ["在现阶段", "当下", "目前"],
    "具有重要意义": ["对该领域具有参考价值", "有助于推动相关研究", "为后续研究提供了启示"],
    "不可或缺": ["至关重要", "扮演着关键角色", "是核心要素之一"],
    "日益重要": ["愈发受到重视", "其重要性不断凸显", "关注度持续上升"],
    "由此可见": ["这进一步说明", "由此推断", "据此分析"],
    "毋庸置疑": ["可以确认的是", "研究证据表明", "数据显示"],
    "显而易见": ["从数据中可以观察到", "分析结果表明", "实证结果显示"],
    "总的来说": ["整体而言", "从全局来看", "综合各方面因素"],
    "具有重要的理论和实践意义": [
        "对理论发展与实践应用均具有一定推动作用",
        "在理论层面与实践层面均具备参考价值",
        "对相关理论的完善与实际问题的解决有所助益",
    ],
    "取得了一定的研究成果": [
        "积累了较为丰富的研究资料与认识",
        "形成了若干可供后续深入的分析结论",
        "在既有基础上获得了阶段性认识",
    ],
    "在此基础上": [
        "以此为基础",
        "在上述分析的前提下",
        "承接上文讨论",
        "结合前述论证",
    ],
    "进一步深入研究": [
        "开展更为系统的后续探讨",
        "在更广样本与更长周期上加以验证",
        "从多维度拓展分析深度",
    ],
    "具有重要的现实意义": [
        "对现实问题具有一定解释与指导价值",
        "可为相关实务提供参考依据",
        "在政策与操作层面具有借鉴意义",
    ],
    "不断推动": [
        "持续促进",
        "逐步带动",
        "稳步助推",
    ],
    "充分发挥作用": [
        "更充分地体现其功能",
        "在相应情境下释放更大效能",
        "得到更为有效的运用",
    ],
    "取得了显著成效": [
        "呈现出较为积极的改善趋势",
        "在关键指标上表现出可观察的提升",
        "获得了与预期大体一致的效果",
    ],
    "深入分析": [
        "展开较为细致的讨论",
        "从多层面加以梳理",
        "结合证据进行系统考察",
    ],
    "全面梳理": [
        "对相关内容作系统整理",
        "分层次归纳既有研究",
        "从主要脉络上加以回顾",
    ],
    "有效提升": [
        "带来可感知的改善",
        "在相当程度上增强",
        "对整体水平产生积极推动",
    ],
    "值得关注": [
        "有必要给予重视",
        "不宜忽视",
        "值得后续跟踪",
    ],
    "在一定程度上": [
        "在相当范围内",
        "就现有条件而言",
        "从可观测层面来看",
    ],
    "充分利用": [
        "更为有效地运用",
        "在合理范围内发挥",
        "结合情境加以使用",
    ],
    "日益完善": [
        "逐步趋于成熟",
        "持续得到补充与修正",
        "在迭代中不断优化",
    ],
    "系统阐述": [
        "分层次加以说明",
        "结合主线展开论述",
        "从整体框架上予以说明",
    ],
}

_AI_CLICHES_EN = {
    "In conclusion": ["Drawing from the analysis above", "Based on the findings presented"],
    "It is worth noting": ["A notable observation is", "One key finding suggests"],
    "plays a crucial role": ["serves as a key factor in", "is central to"],
    "In today's world": ["In the current landscape", "Under present conditions"],
    "It goes without saying": ["The evidence clearly indicates", "As demonstrated"],
    "Furthermore": ["Additionally", "In a related vein", "Moreover"],
    "However": ["Nevertheless", "That said", "On the other hand"],
    "In summary": ["To synthesize the above points", "Reviewing the discussed evidence"],
    "As we all know": ["Existing literature suggests", "Prior research indicates"],
    "In recent years": ["Over the past decade", "In the contemporary period"],
    "more and more": ["an increasing number of", "a growing body of"],
    "a wide range of": ["diverse", "various", "multiple"],
}

_PERSONAL_INJECTIONS_CN = [
    "从笔者的研究经验来看，",
    "结合实际情况分析，",
    "从实践角度而言，",
    "在笔者看来，",
    "根据笔者的观察，",
    "基于本研究的数据分析，",
    "从理论与实践相结合的角度，",
]

_PERSONAL_INJECTIONS_EN = [
    "From our analysis, ",
    "Based on the empirical evidence gathered, ",
    "In our observation, ",
    "Drawing from the data presented, ",
    "Considering the practical implications, ",
]


def humanize_text(text: str) -> str:
    """降AI率改写"""
    is_cn = is_chinese(text)

    lines = ["# PaperCash 降AI率改写结果\n"]
    lines.append("## 原文\n")
    lines.append(f"{text}\n")
    lines.append("---\n")
    lines.append("## 改写后\n")

    result = text

    result = _replace_cliches(result, is_cn)
    result = _restructure_sentences(result, is_cn)
    result = _inject_perspective(result, is_cn)
    result = _vary_sentence_length(result, is_cn)

    lines.append(f"{result}\n")
    lines.append("---\n")

    changes = _diff_summary(text, result, is_cn)
    lines.append("## 修改摘要\n")
    lines.extend(changes)

    lines.append("\n## 降AI率策略说明\n")
    if is_cn:
        lines.extend([
            '1. **替换AI高频套话**: 将"综上所述"等AI常用表达替换为更自然的学术用语',
            '2. **注入个人视角**: 添加"笔者认为"等体现独立思考的表述',
            "3. **调整句式结构**: 长短句交替，被动改主动，增加句式多样性",
            "4. **增加具体性**: 建议在改写基础上补充具体数据、案例或对比",
            "",
            "⚠️ 本工具仅提供改写建议，最终文本需体现学生本人的思考和理解。",
        ])
    else:
        lines.extend([
            "1. **Replace AI clichés**: Swap common AI phrases for more natural academic language",
            "2. **Inject perspective**: Add phrases showing independent thinking",
            "3. **Restructure sentences**: Vary length and voice for diversity",
            "4. **Add specificity**: Supplement with data, examples, or comparisons",
            "",
            "⚠️ This tool provides rewriting suggestions only. Final text should reflect your own understanding.",
        ])

    return "\n".join(lines)


def _replace_cliches(text: str, is_cn: bool) -> str:
    """替换AI高频套话"""
    cliches = _AI_CLICHES_CN if is_cn else _AI_CLICHES_EN
    result = text

    for cliche, alternatives in cliches.items():
        if cliche in result:
            replacement = random.choice(alternatives)
            result = result.replace(cliche, replacement, 1)

    return result


def _restructure_sentences(text: str, is_cn: bool) -> str:
    """调整句式结构"""
    if is_cn:
        sentences = re.split(r"(。)", text)
    else:
        sentences = re.split(r"(\. )", text)

    result_parts: list[str] = []
    for i, part in enumerate(sentences):
        if is_cn and part == "。":
            result_parts.append(part)
            continue
        if not is_cn and part == ". ":
            result_parts.append(part)
            continue

        if is_cn:
            part = _cn_restructure(part)
        else:
            part = _en_restructure(part)

        result_parts.append(part)

    return "".join(result_parts)


def _cn_restructure(sentence: str) -> str:
    """中文句式重构"""
    if "被" in sentence and random.random() > 0.5:
        sentence = sentence.replace("被广泛应用", "在实践中得到了广泛运用")
        sentence = sentence.replace("被认为是", "通常被视为")

    if sentence.startswith("这") and random.random() > 0.5:
        sentence = "该" + sentence[1:]

    if sentence.startswith("可以") and random.random() > 0.5:
        sentence = "能够" + sentence[2:]

    if "不仅" in sentence and "而且" in sentence and random.random() > 0.5:
        sentence = sentence.replace("而且", "亦", 1)

    if sentence.startswith("由于") and random.random() > 0.5 and len(sentence) > 4:
        rest = sentence[2:].lstrip()
        if rest:
            comma = rest.find("，")
            if comma > 0:
                cause, effect = rest[:comma], rest[comma + 1 :]
                if effect.strip():
                    sentence = f"{effect.strip()}，其原因在于{cause.strip()}"

    if "通过" in sentence and "实现" in sentence and random.random() > 0.5:
        sentence = sentence.replace("通过", "借助", 1)

    if sentence.endswith("的问题") and random.random() > 0.5:
        sentence = sentence[: -len("的问题")] + "相关议题"

    return sentence


def _en_restructure(sentence: str) -> str:
    """英文句式重构"""
    passive_patterns = [
        (r"is considered to be", "is generally regarded as"),
        (r"has been widely used", "sees widespread application"),
        (r"can be seen that", "becomes apparent that"),
    ]
    for pattern, replacement in passive_patterns:
        sentence = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)

    return sentence


def _inject_perspective(text: str, is_cn: bool) -> str:
    """在适当位置注入个人视角"""
    if is_cn:
        sentences = text.split("。")
        injections = _PERSONAL_INJECTIONS_CN
    else:
        sentences = re.split(r"\. ", text)
        injections = _PERSONAL_INJECTIONS_EN

    if len(sentences) < 3:
        return text

    inject_pos = len(sentences) // 3
    if inject_pos < len(sentences) and sentences[inject_pos].strip():
        prefix = random.choice(injections)
        s = sentences[inject_pos].strip()
        if is_cn:
            if s:
                sentences[inject_pos] = prefix + s
        else:
            if s:
                sentences[inject_pos] = prefix + s[0].lower() + s[1:]

    separator = "。" if is_cn else ". "
    return separator.join(sentences)


def _vary_sentence_length(text: str, is_cn: bool) -> str:
    """调整句子长度变化"""
    if is_cn:
        sentences = text.split("。")
        result: list[str] = []
        for s in sentences:
            s = s.strip()
            if not s:
                continue
            if len(s) > 60 and "，" in s:
                parts = s.split("，", 1)
                if len(parts[0]) > 15 and len(parts[1]) > 15:
                    result.append(parts[0])
                    result.append(parts[1])
                    continue
            result.append(s)
        return "。".join(result) + ("。" if result else "")

    sentences = text.split(". ")
    result_en: list[str] = []
    for s in sentences:
        s = s.strip()
        if not s:
            continue
        core = s.rstrip(".")
        if len(core) > 85 and ", " in core:
            parts = core.split(", ", 1)
            if len(parts[0]) > 25 and len(parts[1]) > 25:
                result_en.append(parts[0] + ".")
                result_en.append(parts[1])
                continue
        result_en.append(s)
    out = ". ".join(result_en)
    if result_en and not out.endswith("."):
        out += "."
    return out


def _diff_summary(original: str, modified: str, is_cn: bool) -> list[str]:
    """生成修改摘要"""
    lines: list[str] = []
    orig_len = len(original)
    mod_len = len(modified)

    diff_chars = sum(1 for a, b in zip(original, modified) if a != b)
    diff_chars += abs(orig_len - mod_len)
    change_rate = diff_chars / max(orig_len, 1) * 100

    lines.append(f"- 原文长度: {orig_len} 字符")
    lines.append(f"- 改写后长度: {mod_len} 字符")
    lines.append(f"- 预估修改率: {change_rate:.1f}%")

    return lines

"""参考文献格式化 - GB/T 7714 / APA / BibTeX / MLA / Chicago"""

from __future__ import annotations
import html as html_mod
import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from schema import Paper


def _clean_text(text: str) -> str:
    return html_mod.unescape(text) if text else text


_CONF_VENUE_MARKERS = ("conference", "proceedings", "symposium", "workshop")


def _venue_suggests_book(venue_lower: str) -> bool:
    return any(
        k in venue_lower
        for k in ("isbn", "publisher", "press", "monograph", "专著", "出版社")
    )


def _detect_doc_type(paper: Paper) -> str:
    """GB/T 7714 文献类型标识"""
    venue_raw = (paper.venue or "").strip()
    venue_l = venue_raw.lower()
    has_venue = bool(venue_raw)
    has_doi = bool(paper.doi and str(paper.doi).strip())
    has_url = bool(paper.url and str(paper.url).strip())
    ptype = (getattr(paper, "paper_type", None) or "").strip().lower()

    if has_url and not has_doi and not has_venue:
        return "EB/OL"

    if has_venue and any(m in venue_l for m in _CONF_VENUE_MARKERS):
        return "C"

    if has_venue and ("thesis" in venue_l or "dissertation" in venue_l):
        return "D"

    if ptype == "book" or (has_venue and _venue_suggests_book(venue_l)):
        return "M"

    if has_venue:
        return "J/OL" if has_doi else "J"

    if has_doi:
        return "J/OL"

    return "M"


def _get_paper_from_doi(doi: str) -> Paper | None:
    """通过 DOI 获取论文信息（先 CrossRef 再 Semantic Scholar）"""
    from sources.crossref import get_by_doi as cr_get
    paper = cr_get(doi)
    if paper:
        return paper

    from sources.semantic_scholar import get_paper_by_doi as ss_get
    return ss_get(doi)


def format_gb7714(paper: Paper) -> str:
    """GB/T 7714-2015 格式"""
    authors = ", ".join(paper.authors[:3])
    if len(paper.authors) > 3:
        authors += ", 等"

    year = paper.year or "n.d."
    title = _clean_text(paper.title)
    doc = _detect_doc_type(paper)
    marker = f"[{doc}]"

    if paper.venue:
        venue = _clean_text(paper.venue)
        tail = f"{venue}, {year}."
        if paper.doi:
            tail += f" DOI: {paper.doi}."
        result = f"[{paper.citation_key}] {authors}. {title}{marker}. {tail}"
    elif paper.doi:
        result = f"[{paper.citation_key}] {authors}. {title}{marker}. {year}. DOI: {paper.doi}."
    elif paper.url:
        result = f"[{paper.citation_key}] {authors}. {title}{marker}. {year}. {paper.url}."
    else:
        result = f"[{paper.citation_key}] {authors}. {title}{marker}. {year}."

    return result


def format_apa(paper: Paper) -> str:
    """APA 7th Edition 格式"""
    if not paper.authors:
        author_str = "Unknown"
    elif len(paper.authors) == 1:
        parts = paper.authors[0].split()
        if len(parts) >= 2:
            author_str = f"{parts[-1]}, {'. '.join(p[0] for p in parts[:-1])}."
        else:
            author_str = paper.authors[0]
    else:
        formatted = []
        for a in paper.authors[:20]:
            parts = a.split()
            if len(parts) >= 2:
                formatted.append(f"{parts[-1]}, {'. '.join(p[0] for p in parts[:-1])}.")
            else:
                formatted.append(a)

        if len(formatted) <= 2:
            author_str = " & ".join(formatted)
        else:
            author_str = ", ".join(formatted[:-1]) + ", & " + formatted[-1]

    year = f"({paper.year})" if paper.year else "(n.d.)"
    title = paper.title

    parts = [f"{author_str} {year}. {title}."]
    if paper.venue:
        parts.append(f" *{paper.venue}*.")
    if paper.doi:
        parts.append(f" https://doi.org/{paper.doi}")

    return "".join(parts)


def format_mla(paper: Paper) -> str:
    """MLA 9th Edition 格式"""
    if not paper.authors:
        author_str = "Unknown"
    elif len(paper.authors) == 1:
        parts = paper.authors[0].split()
        if len(parts) >= 2:
            author_str = f"{parts[-1]}, {' '.join(parts[:-1])}"
        else:
            author_str = paper.authors[0]
    elif len(paper.authors) == 2:
        p1 = paper.authors[0].split()
        author_str = f"{p1[-1]}, {' '.join(p1[:-1])}, and {paper.authors[1]}"
    else:
        p1 = paper.authors[0].split()
        author_str = f"{p1[-1]}, {' '.join(p1[:-1])}, et al."

    parts = [f'{author_str}. "{paper.title}."']
    if paper.venue:
        parts.append(f" *{paper.venue}*,")
    if paper.year:
        parts.append(f" {paper.year}.")
    if paper.doi:
        parts.append(f" https://doi.org/{paper.doi}.")

    return "".join(parts)


def format_chicago(paper: Paper) -> str:
    """Chicago 格式"""
    if not paper.authors:
        author_str = "Unknown"
    elif len(paper.authors) == 1:
        parts = paper.authors[0].split()
        if len(parts) >= 2:
            author_str = f"{parts[-1]}, {' '.join(parts[:-1])}"
        else:
            author_str = paper.authors[0]
    else:
        formatted_first = paper.authors[0].split()
        if len(formatted_first) >= 2:
            first = f"{formatted_first[-1]}, {' '.join(formatted_first[:-1])}"
        else:
            first = paper.authors[0]

        if len(paper.authors) == 2:
            author_str = f"{first} and {paper.authors[1]}"
        else:
            others = ", ".join(paper.authors[1:-1])
            author_str = f"{first}, {others}, and {paper.authors[-1]}"

    parts = [f'{author_str}. "{paper.title}."']
    if paper.venue:
        parts.append(f" *{paper.venue}*")
    if paper.year:
        parts.append(f" ({paper.year}).")
    if paper.doi:
        parts.append(f" https://doi.org/{paper.doi}.")

    return "".join(parts)


def format_bibtex(paper: Paper) -> str:
    """BibTeX 格式"""
    key = paper.citation_key
    authors_bibtex = " and ".join(paper.authors) if paper.authors else "Unknown"

    lines = [f"@article{{{key},"]
    lines.append(f'  title = {{{paper.title}}},')
    lines.append(f'  author = {{{authors_bibtex}}},')
    if paper.year:
        lines.append(f'  year = {{{paper.year}}},')
    if paper.venue:
        lines.append(f'  journal = {{{paper.venue}}},')
    if paper.doi:
        lines.append(f'  doi = {{{paper.doi}}},')
    if paper.url:
        lines.append(f'  url = {{{paper.url}}},')
    lines.append("}")

    return "\n".join(lines)


_FORMATTERS = {
    "gb7714": format_gb7714,
    "apa": format_apa,
    "mla": format_mla,
    "chicago": format_chicago,
    "bibtex": format_bibtex,
}


def format_citation(doi: str, style: str = "gb7714") -> str:
    """格式化单个 DOI 的引用"""
    paper = _get_paper_from_doi(doi)
    if not paper:
        return f"[错误] 无法通过 DOI '{doi}' 获取文献信息。请检查 DOI 是否正确。"

    formatter = _FORMATTERS.get(style, format_gb7714)
    return formatter(paper)


def format_citations_batch(dois: list[str], style: str = "gb7714") -> str:
    """批量格式化多个 DOI"""
    results: list[str] = []
    formatter = _FORMATTERS.get(style, format_gb7714)

    for i, doi in enumerate(dois, 1):
        doi = doi.strip()
        if not doi:
            continue
        paper = _get_paper_from_doi(doi)
        if paper:
            citation = formatter(paper)
            results.append(f"[{i}] {citation}")
        else:
            results.append(f"[{i}] [错误] 无法解析 DOI: {doi}")

    return "\n\n".join(results)


def format_paper_citation(paper: Paper, style: str = "gb7714") -> str:
    """直接格式化 Paper 对象"""
    formatter = _FORMATTERS.get(style, format_gb7714)
    return formatter(paper)

"""Word 文档导出"""

from __future__ import annotations
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from schema import SearchResult, Paper


def export_review_to_docx(review_text: str, output_path: str,
                          title: str = "文献综述") -> str:
    """将文献综述导出为 Word 文档"""
    try:
        from docx import Document
        from docx.shared import Pt, Cm, RGBColor
        from docx.enum.text import WD_ALIGN_PARAGRAPH
    except ImportError:
        return "[错误] 需要安装 python-docx: pip install python-docx"

    doc = Document()

    for section in doc.sections:
        section.top_margin = Cm(2.54)
        section.bottom_margin = Cm(2.54)
        section.left_margin = Cm(3.17)
        section.right_margin = Cm(3.17)

    title_para = doc.add_heading(title, level=0)
    title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
    for run in title_para.runs:
        run.font.size = Pt(16)

    lines = review_text.split("\n")
    for line in lines:
        line = line.strip()
        if not line:
            continue

        if line.startswith("# "):
            continue
        elif line.startswith("## "):
            heading_text = line[3:].strip()
            h = doc.add_heading(heading_text, level=1)
            for run in h.runs:
                run.font.size = Pt(15)
        elif line.startswith("### "):
            heading_text = line[4:].strip()
            h = doc.add_heading(heading_text, level=2)
            for run in h.runs:
                run.font.size = Pt(14)
        elif line.startswith("- **") and "**" in line[4:]:
            p = doc.add_paragraph(style="List Bullet")
            bold_end = line.index("**", 4)
            bold_text = line[4:bold_end]
            rest = line[bold_end + 2:].lstrip(": ：")
            run_bold = p.add_run(bold_text)
            run_bold.bold = True
            run_bold.font.size = Pt(12)
            if rest:
                run_rest = p.add_run(f": {rest}")
                run_rest.font.size = Pt(12)
        elif line.startswith("- "):
            p = doc.add_paragraph(line[2:], style="List Bullet")
            for run in p.runs:
                run.font.size = Pt(12)
        elif line.startswith("[") and "]" in line:
            p = doc.add_paragraph(line)
            for run in p.runs:
                run.font.size = Pt(10.5)
        elif line.startswith("**") and line.endswith("**"):
            p = doc.add_paragraph()
            run = p.add_run(line.strip("*"))
            run.bold = True
            run.font.size = Pt(12)
        else:
            p = doc.add_paragraph(line)
            pf = p.paragraph_format
            pf.line_spacing = 1.5
            for run in p.runs:
                run.font.size = Pt(12)
                run.font.name = "宋体"

    doc.save(output_path)
    return f"已导出到: {output_path}"


def export_search_to_docx(result: SearchResult, output_path: str) -> str:
    """将搜索结果导出为 Word 文档"""
    try:
        from docx import Document
        from docx.shared import Pt, Cm
        from docx.enum.text import WD_ALIGN_PARAGRAPH
    except ImportError:
        return "[错误] 需要安装 python-docx: pip install python-docx"

    doc = Document()

    for section in doc.sections:
        section.top_margin = Cm(2.54)
        section.bottom_margin = Cm(2.54)
        section.left_margin = Cm(3.17)
        section.right_margin = Cm(3.17)

    title = doc.add_heading(f"论文检索报告: {result.query}", level=0)
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER

    info = doc.add_paragraph()
    info.add_run(f"查询: {result.query}\n").bold = True
    info.add_run(f"结果: {result.total_found} 篇\n")
    info.add_run(f"数据源: {', '.join(result.sources_used)}\n")

    doc.add_heading("检索结果", level=1)

    for i, paper in enumerate(result.papers, 1):
        doc.add_heading(f"{i}. {paper.title}", level=2)

        meta = doc.add_paragraph()
        meta.add_run(f"作者: ").bold = True
        meta.add_run(f"{paper.authors_str}\n")

        if paper.year:
            meta.add_run(f"年份: ").bold = True
            meta.add_run(f"{paper.year}\n")

        if paper.venue:
            meta.add_run(f"期刊: ").bold = True
            meta.add_run(f"{paper.venue}\n")

        if paper.citation_count:
            meta.add_run(f"引用: ").bold = True
            meta.add_run(f"{paper.citation_count} 次\n")

        if paper.doi:
            meta.add_run(f"DOI: ").bold = True
            meta.add_run(f"{paper.doi}\n")

        if paper.abstract:
            abs_para = doc.add_paragraph()
            abs_para.add_run("摘要: ").bold = True
            abstract_short = paper.abstract[:500]
            abs_para.add_run(abstract_short)

        for run in meta.runs:
            run.font.size = Pt(12)

    doc.save(output_path)
    return f"已导出到: {output_path}"

"""格式检查 - 检查 Word 文档是否符合高校论文格式要求"""

from __future__ import annotations
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from schema import FormatIssue

STANDARD_FORMAT = {
    "title_font": "黑体",
    "title_size_pt": 16,
    "heading1_font": "黑体",
    "heading1_size_pt": 15,
    "heading2_font": "黑体",
    "heading2_size_pt": 14,
    "body_font": "宋体",
    "body_font_en": "Times New Roman",
    "body_size_pt": 12,
    "line_spacing": 1.5,
    "margin_top_cm": 2.54,
    "margin_bottom_cm": 2.54,
    "margin_left_cm": 3.17,
    "margin_right_cm": 3.17,
    "page_size": "A4",
    "abstract_title": "摘要",
    "keywords_title": "关键词",
    "references_title": "参考文献",
}


def check_format(file_path: str) -> str:
    """检查 Word 文档格式"""
    if not os.path.isfile(file_path):
        return f"[错误] 文件不存在: {file_path}"

    if not file_path.lower().endswith((".docx", ".doc")):
        return "[错误] 仅支持 .docx 格式文件"

    try:
        from docx import Document
    except ImportError:
        return _format_guide_only()

    try:
        doc = Document(file_path)
    except Exception as e:
        return f"[错误] 无法打开文件: {e}"

    issues: list[FormatIssue] = []

    issues.extend(_check_margins(doc))
    issues.extend(_check_fonts_and_sizes(doc))
    issues.extend(_check_line_spacing(doc))
    issues.extend(_check_structure(doc))

    return _render_report(issues, file_path)


def _check_margins(doc) -> list[FormatIssue]:
    issues: list[FormatIssue] = []
    for i, section in enumerate(doc.sections):
        margin_checks = [
            ("上边距", section.top_margin, STANDARD_FORMAT["margin_top_cm"]),
            ("下边距", section.bottom_margin, STANDARD_FORMAT["margin_bottom_cm"]),
            ("左边距", section.left_margin, STANDARD_FORMAT["margin_left_cm"]),
            ("右边距", section.right_margin, STANDARD_FORMAT["margin_right_cm"]),
        ]
        for name, actual_emu, expected_cm in margin_checks:
            if actual_emu is None:
                continue
            actual_cm = round(actual_emu / 360000, 2)
            if abs(actual_cm - expected_cm) > 0.1:
                issues.append(FormatIssue(
                    location=f"节 {i + 1}",
                    issue_type=name,
                    expected=f"{expected_cm} cm",
                    actual=f"{actual_cm} cm",
                    severity="warning",
                ))
    return issues


def _check_fonts_and_sizes(doc) -> list[FormatIssue]:
    issues: list[FormatIssue] = []

    for i, para in enumerate(doc.paragraphs[:50]):
        if not para.text.strip():
            continue

        style_name = para.style.name if para.style else ""
        is_heading = "Heading" in style_name or "标题" in style_name

        for run in para.runs:
            if not run.text.strip():
                continue

            font_name = run.font.name
            font_size = run.font.size

            if font_size:
                size_pt = round(font_size / 12700, 1)
                if is_heading:
                    if size_pt < 14:
                        issues.append(FormatIssue(
                            location=f"段落 {i + 1} (标题)",
                            issue_type="字号",
                            expected="≥ 14pt (三号或小三号)",
                            actual=f"{size_pt}pt",
                            severity="warning",
                        ))
                else:
                    expected_size = STANDARD_FORMAT["body_size_pt"]
                    if abs(size_pt - expected_size) > 0.5:
                        issues.append(FormatIssue(
                            location=f"段落 {i + 1}",
                            issue_type="字号",
                            expected=f"{expected_size}pt (小四号)",
                            actual=f"{size_pt}pt",
                            severity="info",
                        ))

            if font_name and not is_heading:
                has_cn = any("\u4e00" <= c <= "\u9fff" for c in run.text)
                if has_cn and font_name not in ("宋体", "SimSun", "NSimSun"):
                    issues.append(FormatIssue(
                        location=f"段落 {i + 1}",
                        issue_type="中文字体",
                        expected="宋体",
                        actual=font_name,
                        severity="info",
                    ))

            if len(issues) > 20:
                break
        if len(issues) > 20:
            break

    return issues


def _check_line_spacing(doc) -> list[FormatIssue]:
    issues: list[FormatIssue] = []
    checked = 0

    for i, para in enumerate(doc.paragraphs[:30]):
        if not para.text.strip():
            continue

        pf = para.paragraph_format
        if pf.line_spacing is not None:
            spacing = pf.line_spacing
            if isinstance(spacing, (int, float)):
                if spacing < 1.0:
                    actual_val = round(spacing / 12700 / 12, 2)
                else:
                    actual_val = spacing

                expected = STANDARD_FORMAT["line_spacing"]
                if abs(actual_val - expected) > 0.1:
                    issues.append(FormatIssue(
                        location=f"段落 {i + 1}",
                        issue_type="行距",
                        expected=f"{expected} 倍行距",
                        actual=f"{actual_val}",
                        severity="warning",
                    ))
                    checked += 1

        if checked >= 5:
            break

    return issues


def _check_structure(doc) -> list[FormatIssue]:
    issues: list[FormatIssue] = []
    full_text = "\n".join(p.text for p in doc.paragraphs)

    required_sections = [
        ("摘要", ["摘要", "摘 要", "Abstract"]),
        ("关键词", ["关键词", "关键字", "Keywords"]),
        ("参考文献", ["参考文献", "参 考 文 献", "References"]),
    ]

    for name, keywords in required_sections:
        found = any(kw in full_text for kw in keywords)
        if not found:
            issues.append(FormatIssue(
                location="全文",
                issue_type="缺少必要章节",
                expected=name,
                actual="未找到",
                severity="error",
            ))

    return issues


def _render_report(issues: list[FormatIssue], file_path: str) -> str:
    lines: list[str] = []
    lines.append(f"\n{'=' * 60}")
    lines.append(f"  PaperCash 格式检查报告")
    lines.append(f"{'=' * 60}")
    lines.append(f"  文件: {file_path}")
    lines.append(f"  标准: 常见高校毕业论文格式要求")
    lines.append(f"{'=' * 60}\n")

    errors = [i for i in issues if i.severity == "error"]
    warnings = [i for i in issues if i.severity == "warning"]
    infos = [i for i in issues if i.severity == "info"]

    lines.append(f"  总计: {len(issues)} 个问题 "
                 f"(严重: {len(errors)} | 警告: {len(warnings)} | 提示: {len(infos)})\n")

    if not issues:
        lines.append("  ✅ 未发现格式问题，格式基本符合要求！\n")
        return "\n".join(lines)

    if errors:
        lines.append("  --- 严重问题 ---\n")
        for issue in errors:
            lines.append(f"  [ERROR] {issue.location}: {issue.issue_type}")
            lines.append(f"          期望: {issue.expected} | 实际: {issue.actual}\n")

    if warnings:
        lines.append("  --- 警告 ---\n")
        for issue in warnings:
            lines.append(f"  [WARN] {issue.location}: {issue.issue_type}")
            lines.append(f"         期望: {issue.expected} | 实际: {issue.actual}\n")

    if infos:
        lines.append("  --- 提示 ---\n")
        for issue in infos[:10]:
            lines.append(f"  [INFO] {issue.location}: {issue.issue_type}")
            lines.append(f"         期望: {issue.expected} | 实际: {issue.actual}\n")
        if len(infos) > 10:
            lines.append(f"  ... 及其他 {len(infos) - 10} 个提示\n")

    lines.append("  --- 格式参考标准 ---\n")
    lines.append(f"  正文字体: {STANDARD_FORMAT['body_font']} / {STANDARD_FORMAT['body_font_en']}")
    lines.append(f"  正文字号: {STANDARD_FORMAT['body_size_pt']}pt (小四号)")
    lines.append(f"  行距: {STANDARD_FORMAT['line_spacing']} 倍")
    lines.append(f"  页边距: 上下 {STANDARD_FORMAT['margin_top_cm']}cm, "
                 f"左 {STANDARD_FORMAT['margin_left_cm']}cm, 右 {STANDARD_FORMAT['margin_right_cm']}cm")
    lines.append(f"  纸张: {STANDARD_FORMAT['page_size']}")
    lines.append("")

    return "\n".join(lines)


def _format_guide_only() -> str:
    """无 python-docx 时返回格式指南"""
    return """
PaperCash 格式检查

⚠️  未安装 python-docx，无法检查 Word 文件。
    请运行: pip install python-docx

以下是常见高校毕业论文格式要求（供手动检查）：

--- 字体与字号 ---
  论文标题: 黑体, 16pt (二号)
  一级标题: 黑体, 15pt (小二号)
  二级标题: 黑体, 14pt (三号)
  正文中文: 宋体, 12pt (小四号)
  正文英文: Times New Roman, 12pt

--- 页面设置 ---
  纸张: A4
  上边距: 2.54 cm
  下边距: 2.54 cm
  左边距: 3.17 cm
  右边距: 3.17 cm

--- 行距 ---
  正文: 1.5 倍行距
  摘要/参考文献: 1.5 倍行距

--- 必需章节 ---
  1. 摘要（中文 + 英文）
  2. 关键词
  3. 目录
  4. 正文（绪论/文献综述/方法/结果/讨论/结论）
  5. 参考文献
  6. 致谢

--- 参考文献格式 ---
  推荐: GB/T 7714-2015
  使用 PaperCash: python scripts/papercash.py cite <DOI> --style gb7714
"""