"""
このモジュールは、学術論文のPDFファイルからメタデータ（著者、タイトル、発行年、DOIなど）を抽出し、
その情報をExcelファイルに保存したり、推奨されるファイル名に基づいてPDFファイルをリネームしたりするツールです。
様々なAIモデル（OpenAI, Gemini, LM Studioなど）をLiteLLMを通じて利用してテキストから情報を解析します。

このスクリプトは、PDFからテキストを抽出し、そのテキストをLLM（Large Language Model）に送信して、
構造化されたメタデータ（JSON形式）を抽出します。抽出されたメタデータはExcelに記録され、
オプションでファイルのリネームにも利用されます。

.. seealso::
   :doc:`get_paper_inf5_usage` (もし対応するドキュメントがあれば、ここにリンクを追加します)
"""
import argparse
import os
import shutil
import glob
import io
import json
try:
    from openpyxl import Workbook, load_workbook
except ImportError:
    print("Error: Failed to import openpyxl")
    input("Install: pip install openpyxl")
try:
    import PyPDF2
except ImportError:
    print("Error: Failed to import PyPDF2")
    input("Install: pip install pypdf2")

from tkai_lib_litellm import extract_text, query_ai, read_ai_config


#=========================================================
# Global configuration
#=========================================================
config_path = "ai.env"

DEFAULT_GEMINI_MODEL = "gemini-3.1-pro-preview"
DEFAULT_OPENAI_MODEL4 = "gpt-4o"
DEFAULT_OPENAI_MODEL5 = "gpt-5.4"
DEFAULT_LMSTUDIO_MODEL = "qwen/qwen3.8-27b"


#=========================================================
# Read configuration
#=========================================================
read_ai_config(config_path)

max_tokens     = int(os.getenv("max_tokens", "2000"))

openai_api_key = os.getenv("OPENAI_API_KEY")
openai_model   = os.getenv("openai_model", DEFAULT_OPENAI_MODEL4)
temperature    = float(os.getenv("temperature", "0.3"))

openai_model5  = os.getenv("openai_model5", DEFAULT_OPENAI_MODEL5)
reasoning_effort = os.getenv("reasoning_effort", "low")

google_api_key = os.getenv("GOOGLE_API_KEY")
google_model   = os.getenv("gemini_model", DEFAULT_GEMINI_MODEL)
lmstudio_model = os.getenv("lmstudio_model", DEFAULT_LMSTUDIO_MODEL)


#=========================================================
# Parameters
#=========================================================
DEFAULT_TEMPLATE = "(author_first)_(author_last)_(short_title)_(shortest_name)_(year).pdf"

xlsx_labels = [
    "directory", "filename_original", "filename_rename", 
    "authors", "author_first", "author_last", 
    "title", "short_title", "journal", "short_name", "shortest_name", 
    "date_received", "date_accepted", "date_published_online", "date_published",
    "year", "volume", "issue", "pages", "doi",
    ]

# Prompt template: start
prompt_template = """
以下の学術論文のテキストから、指定された情報をJSON形式で抽出してください。
また、first author、last author、短縮したtitle (short_title)、shortest_name、発行年から
推奨ファイル名 {{template}} を作ってください。
short_titleの単語はCaptalFirstにして、空白、.、,などの文字は削除してください。

推奨ファイル名（filename_rename）:
著者リスト（authors）   ：
第一著者（author_first）：
最終著者（author_last） ：
論文題目（title）           :
論文題目略称（short_title） :
発行雑誌名（journal）       ：
発行雑誌名略称（short_name）：
発行雑誌名の最短の略称（shortest_name）：
投稿受理日（date_received） :
採択日（date_accepted） :
オンライン発行日（date_published_online）:
発行日（date_published）:
発行年（year）   :
巻番号（volume）：
号番号（issue） ：
ページ（pages ）：
DOI（doi）：

情報が不明な場合は、空文字列 "" を使用してください。

--- 論文テキスト ---
{{text}}
"""
# Prompt template: end


def initialize() -> argparse.ArgumentParser:
    """
    コマンドライン引数を解析するためのArgumentParserオブジェクトを初期化します。

    処理するPDFファイルのパス、使用するAPI、モデル、推論強度、出力Excelファイルのパス、
    再帰検索の有無、ファイルリネームの有無、元のファイルの削除オプション、最大バイト数、
    ファイル名テンプレートなどの引数を定義します。

    :returns: argparse.ArgumentParser - コマンドライン引数パーサーオブジェクト。
    """
    parser = argparse.ArgumentParser(description="学術論文のPDFからメタデータを抽出します。")
    parser.add_argument("--api", type=str, default='openai5',
        choices = ["openai", "openai5", "google", "lmstudio"],
        help="使用する API を指定（openai5|openai|google|lmstudio: デフォルト: openai5）")
    parser.add_argument("--model", type=str, default=None,
        help="使用するモデル名。未指定時は ai.env の各 API 用モデル設定を使用する")
    parser.add_argument("--reasoning-effort", "--reasoning_effort",
        dest="reasoning_effort", choices=["low", "medium", "xhigh"], default=None,
        help="推論強度（LM Studio/OpenAI5 用）。未指定時は ai.env の reasoning_effort")
    parser.add_argument("input_file", type=str, help="処理するPDFファイルのパス")
    parser.add_argument("--summary_path", type=str, default = "summary.xlsx", 
                        help="summary.xlsxのパス")
    parser.add_argument("--recursive", type=int, default=0, 
                        help="1の場合、サブディレクトリまで処理する")
    parser.add_argument("--rename", type=int, default=0, 
                        help="1の場合、生成AIで推薦ファイル名を取得できた場合、リネームする")
#    parser.add_argument("--rename", action="store_true", 
#                        help="生成AIで推薦ファイル名を取得できた場合、リネームする")
    parser.add_argument("--delete_original", type=int, default=1, 
                        help="1の場合、renameしたら元のファイルを削除する")
    parser.add_argument("--max_bytes", type=int, default=10000,
                        help="APIに送る最大テキストバイト数。論文全体を送る必要がない場合に指定。")
    parser.add_argument("--template", type=str, default=DEFAULT_TEMPLATE,
                        help=f"ファイル名を変える際のテンプレート {DEFAULT_TEMPLATE}")
    return parser

def extract_text_from_pdf(pdf_path: str, max_bytes: int) -> str:
    """
    PDFファイルからテキストを抽出し、指定された最大バイト数に制限します。

    PyPDF2ライブラリを使用してPDFの各ページからテキストを読み込みます。
    抽出中に指定された `max_bytes` を超えた場合、その時点でテキストの抽出を停止し、
    バイト数で切り詰めます。

    :param pdf_path: str - 処理するPDFファイルのパス。
    :param max_bytes: int - APIに送信するテキストの最大バイト数。
    :returns: str - 抽出されたテキスト。エラーが発生した場合は空文字列。
    """
    text_buffer = io.StringIO()
    try:
        with open(pdf_path, 'rb') as f:
            pdf_reader = PyPDF2.PdfReader(f)
            num_pages = len(pdf_reader.pages)
            
            for page_num in range(num_pages):
                page = pdf_reader.pages[page_num]
                text_buffer.write(page.extract_text() or '')
                
                # バイト数チェック
                # StringIO.tell() は文字数ではなく、内部バッファのバイト数を近似的に返すため、
                # 正確なバイト数チェックはエンコード後に行う。ここでは大まかな目安として利用。
                if text_buffer.tell() * 2 > max_bytes: # UTF-8で最大2バイト/文字を想定
                    break
    except Exception as e:
        print(f"PDFファイルの読み込み中にエラーが発生しました: {e}")
        return ""

    full_text = text_buffer.getvalue()
    
    # バイト数でテキストを切り詰める
    encoded_text = full_text.encode('utf-8', 'ignore')
    if len(encoded_text) > max_bytes:
        truncated_text = encoded_text[:max_bytes].decode('utf-8', 'ignore')
        return truncated_text
    
    return full_text

def response_to_metadata(response: object) -> dict:
    """
    LiteLLMのAI応答からJSON形式のメタデータを取り出します。

    AIからの応答が文字列として返された場合、その文字列からJSONオブジェクトをパースします。
    応答がJSONラッパー（例: ```json ... ```）で囲まれている場合も適切に処理します。

    :param response: Any - LiteLLM (tkai_lib_litellm) からのAI応答オブジェクト。
    :returns: dict - 抽出されたメタデータを含む辞書。JSONパースに失敗した場合は空の辞書。
    """
    text = extract_text(response)
    if not text:
        return {}

    text = text.strip()
    if text.startswith("```"):
        text = text.split("\n", 1)[-1]
        if text.rstrip().endswith("```"):
            text = text.rstrip()[:-3].rstrip()

    try:
        value = json.loads(text)
    except json.JSONDecodeError:
        # ローカルモデルが JSON の前後に短い説明を付けた場合にも対応する。
        start, end = text.find("{"), text.rfind("}")
        if start < 0 or end < start:
            print("Error: AI response is not JSON.")
            print(text)
            return {}
        try:
            value = json.loads(text[start:end + 1])
        except json.JSONDecodeError as exc:
            print(f"Error: Failed to parse AI response as JSON: {exc}")
            return {}

    return value if isinstance(value, dict) else {}


def get_metadata_from_ai(text: str, template: str, api: str) -> dict:
    """
    指定されたテキストからAIモデルを使用して学術論文のメタデータを抽出します。

    事前定義されたプロンプトテンプレートに論文テキストを埋め込み、選択されたAPI
    （OpenAI, Google Gemini, LM Studioなど）を介してAIにクエリを送信します。
    各APIの特性（モデル名、推論強度、温度など）に応じてパラメータを調整します。

    :param text: str - 抽出元となる論文のテキスト。
    :param template: str - 推奨ファイル名を生成するためのテンプレート文字列。
    :param api: str - 使用するAI APIの指定（"openai", "openai5", "google", "lmstudio"）。
    :returns: dict - AIによって抽出されたメタデータを含む辞書。
    """
    prompt = prompt_template.replace("{{text}}", text).replace("{{template}}", template)
    kwargs = {
        "max_tokens": max_tokens,
        "response_format": {"type": "json_object"},
    }

    if api == "lmstudio":
        # Qwen など LM Studio の reasoning モデルは OpenAI 互換 API の
        # extra_body で推論強度を受け取る。
        kwargs["extra_body"] = {"reasoning_effort": reasoning_effort}
        kwargs["drop_params"] = True
        model, provider = lmstudio_model, "lmstudio"
    elif api == "openai5":
        kwargs["reasoning_effort"] = reasoning_effort
        model, provider = openai_model5, "openai5"
    elif api == "openai":
        kwargs["temperature"] = temperature
        model, provider = openai_model, "openai"
    elif api == "google":
        model, provider = google_model, "google"
    else:
        raise ValueError(f"未対応の API: {api}")

    response = query_ai(prompt, model=model, role=None, provider=provider, **kwargs)
    return response_to_metadata(response)

def append_xlsx(path: str, mode: str, labels: list, data_list: list[list]) -> None:
    """
    指定されたExcelファイルにデータを追記します。

    ファイルが存在しない場合やモードが"w"の場合、新しいワークブックを作成し、
    ヘッダー行 (`labels`) を書き込みます。それ以外の場合は既存のワークブックをロードし、
    指定された `data_list` の各行をシートの末尾に追加します。

    :param path: str - 処理するExcelファイルのパス。
    :param mode: str - ファイルのオープンモード（"w"で新規作成、それ以外は追記）。
    :param labels: list - Excelシートのヘッダー行として使用される文字列のリスト。
    :param data_list: list[list] - Excelシートに追加するデータのリスト。各内部リストが1行に対応します。
    :returns: None
    """
    if mode == "w" or not os.path.exists(path):
        wb = Workbook()
        ws = wb.active
        ws.append(labels)
    else:
        wb = load_workbook(filename = path)
        ws = wb.active

    for row in data_list:
        ws.append(row)

    wb.save(path)

def rename_file(input_file: str, new_filename: str, delete_original: bool = False) -> bool:
    """
    ファイルを新しい名前にリネームまたはコピーします。

    指定された `input_file` を `new_filename` に変更します。
    `delete_original` がTrueの場合、元のファイルを削除しリネームを行います。
    Falseの場合は、元のファイルを残したまま新しいファイル名でコピーを作成します。
    新しいファイル名が既に存在する場合は処理をスキップします。

    :param input_file: str - 元のファイルパス。
    :param new_filename: str - 新しいファイル名。
    :param delete_original: bool - Trueの場合、元のファイルを削除してリネームします。Falseの場合、コピーを作成します。
    :returns: bool - リネームまたはコピーが成功した場合はTrue、失敗した場合はFalse。
    """
    if os.path.exists(new_filename):
        print(f"Error in rename_file(): File [{new_filename}] already exists. Skip.")
        return False

    try:
        directory = os.path.dirname(input_file)
        # 現在の作業ディレクトリを一時的に変更する。
        # これは shutil.copy や os.rename が相対パスで動作する場合に予期せぬ挙動を避けるため。
        # ただし、input_file と new_filename が絶対パスの場合、chdirは不要だが、
        # ここでは元々の実装の意図を尊重する。
        original_cwd = os.getcwd()
        os.chdir(directory)

        # new_filename が basename のみの場合、現在のディレクトリに作成される。
        # input_file も basename のみの場合、現在のディレクトリのファイルを指す。
        # ここでは input_file と new_filename が完全なパスとして扱われることを想定する。
        full_input_path = os.path.join(original_cwd, input_file) if not os.path.isabs(input_file) else input_file
        full_new_path = os.path.join(original_cwd, new_filename) if not os.path.isabs(new_filename) else new_filename

        if delete_original:
            os.rename(full_input_path, full_new_path)
            print(f"Changed file name from [{full_input_path}] to [{full_new_path}]")
        else:
            shutil.copy(full_input_path, full_new_path)
            print(f"Copied [{full_input_path}] to [{full_new_path}]")
    except Exception as e:
        print(f"Error in rename_file(): Could not change file name to [{new_filename}] due to: {e}")
        return False
    finally:
        os.chdir(original_cwd) # 元の作業ディレクトリに戻す

    return True

def get_inf(input_file: str, summary_path: str, api: str = "openai", max_bytes: int = 10000, 
            rename: bool = False, delete_original: bool = True, template: str = DEFAULT_TEMPLATE) -> bool:
    """
    単一のPDFファイルからメタデータを抽出し、Excelに保存し、必要に応じてファイルをリネームします。

    この関数は以下のステップを実行します:
    1.  PDFからテキストを抽出します。
    2.  抽出したテキストを指定されたAPIとモデルに送信し、AIからメタデータを取得します。
    3.  取得したメタデータをExcelファイル (`summary_path`) に追記します。
    4.  `rename` オプションがTrueで、AIが推奨ファイル名を返した場合、PDFファイルを推奨ファイル名に
        リネーム（またはコピー）します。
    5.  `delete_original` オプションにより、リネーム時の元のファイルの扱いを制御します。

    :param input_file: str - 処理するPDFファイルのパス。
    :param summary_path: str - メタデータを保存するExcelファイルのパス。
    :param api: str - 使用するAI APIの指定（デフォルト: "openai"）。
    :param max_bytes: int - APIに送信するテキストの最大バイト数（デフォルト: 10000）。
    :param rename: bool - Trueの場合、AIが推奨するファイル名でPDFファイルをリネームします。
    :param delete_original: bool - Trueの場合、リネーム後に元のファイルを削除します（renameがTrueの場合のみ有効）。
    :param template: str - ファイル名生成に使用するテンプレート文字列。
    :returns: bool - 処理が成功した場合はTrue、失敗した場合はFalse。
    """
    directory = os.path.dirname(input_file)
    filename  = os.path.basename(input_file)
    print(f"Input PDF file: [{input_file}]")
    print(f"  Directory: [{directory}]")
    print(f"  File name: [{filename}]")

    extracted_text = extract_text_from_pdf(input_file, max_bytes)
    if not extracted_text:
        print("テキストの抽出に失敗したか、ファイルが空です。処理を終了します。")
        print("PyCryptodomeが必要というメッセージが出たら、以下のようにinstallしてください。")
        print("Install: pip install pycryptodome ")
        return False

    print(f"  API: {api.upper()}")
    if api == 'lmstudio':
        print(f"  lmstudio_model: {lmstudio_model}")
        print(f"  effort         : {reasoning_effort}")
        print(f"  max_tokens     : {max_tokens}")
    elif 'openai5' in api:
        print(f"  openai_model: {openai_model5}")
        print(f"  effort      : {reasoning_effort}")
        print(f"  max_tokens  : {max_tokens}")
    elif 'openai' in api:
        print(f"  openai_model: {openai_model}")
        print(f"  temperature : {temperature}")
        print(f"  max_tokens  : {max_tokens}")
    else: # google
        print(f"  google_model: {google_model}")
        print(f"  max_tokens: {max_tokens}")

    print(f"  max bytes: {max_bytes}")
    print(f"  抽出したテキストを送信中...")
    try:
        metadata = get_metadata_from_ai(extracted_text[:max_bytes], template, api)
    except Exception as exc:
        print(f"Error: AI からのメタデータ抽出に失敗しました: {exc}")
        return False

    if metadata:
        print("\n--- 論文メタデータ ---")
        # xlsx_labelsの順序に合わせてデータを追加
        # filename_rename は metadata にあるが、directory, filename_original は引数から取得
        # metadataから抽出した情報がxlsx_labelsの順序と一致するように調整
        
        # まずxlsx_labelsに対応する辞書を作成し、欠落しているキーは空文字列で埋める
        row_data_dict = {label: "" for label in xlsx_labels}
        row_data_dict["directory"] = directory
        row_data_dict["filename_original"] = filename

        for key, value in metadata.items():
            print(f"{key}: {value}")
            if key in row_data_dict: # xlsx_labels に含まれるキーのみを対象
                if isinstance(value, (list, tuple)):
                    row_data_dict[key] = ", ".join(map(str, value)) # リスト/タプルはカンマ区切り文字列に
                else:
                    row_data_dict[key] = str(value) # その他の型は文字列に変換
            
        # xlsx_labelsの順序でデータリストを作成
        data = [row_data_dict[label] for label in xlsx_labels]

    else:
        # メタデータが取得できなかった場合、空のデータで埋める
        print("AIからメタデータを取得できませんでした。")
        data = [directory, filename, "", "", "", "", "", 
                "", "", "", "", "", 
                "", "", "", "", "", "", "", "", ""]
    
    append_xlsx(summary_path, mode = "a", labels = xlsx_labels, data_list = [data])

    if rename and metadata.get("filename_rename", None):
        new_filename = metadata["filename_rename"]
        if not new_filename.lower().endswith('.pdf'): # 小文字に変換してチェック
            new_filename += '.pdf'
        
        # rename_file には絶対パスを渡すか、os.chdir() の影響を考慮したパスを渡す
        # ここでは get_inf に渡された input_file が既に適切なパスであると仮定
        ret = rename_file(input_file, os.path.join(directory, new_filename), delete_original=delete_original)
        if not ret: 
            return False
    
    return True

def main() -> None:
    """
    メインのエントリーポイントとして、コマンドライン引数を処理し、指定されたPDFファイル群からメタデータを抽出します。

    1.  `initialize()` を呼び出してコマンドライン引数を解析します。
    2.  `--model` オプションが指定された場合、使用するAIモデルを更新します。
    3.  `--recursive` オプションに応じて、指定されたファイルパターンに合致するPDFファイルを検索します。
    4.  見つかった各PDFファイルに対し `get_inf` 関数を呼び出し、メタデータ抽出、
        Excel保存、リネーム処理を実行します。
    5.  処理の最後にユーザー入力を待ち、プログラムを終了します。

    :returns: None
    """
    global openai_model, openai_model5, google_model, lmstudio_model, reasoning_effort

    parser = initialize()
    args = parser.parse_args()

    if args.model:
        if args.api == "openai":
            openai_model = args.model
        elif args.api == "openai5":
            openai_model5 = args.model
        elif args.api == "google":
            google_model = args.model
        else: # lmstudio
            lmstudio_model = args.model
    if args.reasoning_effort:
        reasoning_effort = args.reasoning_effort
    
    fmask = args.input_file
    if args.recursive:
        directory = os.path.dirname(fmask)
        base_name = os.path.basename(fmask)
        if '*' not in directory:
            # 再帰検索の場合、ディレクトリとファイル名の間に '**' を挿入して glob がサブディレクトリを検索するようにする
            # ただし、input_fileが既に特定のディレクトリ内のファイルの場合、
            # そのディレクトリのサブディレクトリも対象とするために '**' を追加する。
            # input_fileがワイルドカードを含まない単一ファイル名の場合（例: paper.pdf）、
            # カレントディレクトリとサブディレクトリのpaper.pdfを検索する。
            fmask = os.path.join(directory if directory else '.', '**', base_name)
        else:
            # input_file が既にワイルドカードを含むパスの場合、そのまま使用
            pass
            
    print()
    print(f"Search files for [{fmask}]")
    print(f"Recursive search? {bool(args.recursive)}") # intをboolとして表示
    files = sorted(glob.glob(fmask, recursive = bool(args.recursive)))
    print()
    if len(files) == 0:
        print(f"Error: No file found.")
    else:
        print(f"Files found for [{args.input_file}]")
        for f in files:
            print(f"  {f}")

        for f in files:
            print()
            # intの引数をboolとして渡す
            get_inf(f, args.summary_path, args.api, args.max_bytes, 
                    bool(args.rename), bool(args.delete_original), args.template)

    input("\nPress ENTER to terminate>>\n")


if __name__ == "__main__":
    main()