#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Edge TTS (Text-to-Speech) ユーティリティスクリプト。

Edge TTS (Text-to-Speech) を利用してテキストを読み上げたり、
利用可能な音声リストを表示したりするコマンドラインユーティリティです。

コマンドライン引数 ``input`` でテキストまたはファイルパスを指定し、
``--mode read`` (デフォルト) で読み上げを行います。
``--mode list`` を指定すると、利用可能な音声の一覧を表示します。
``--voices`` と ``--lang`` オプションで音声リストをフィルタリングできます。

:doc:`sample_edge_tts_usage`
"""

import argparse
import asyncio
import os
import subprocess
import sys
import tempfile
from typing import List, Dict, Any, Optional

import edge_tts


DEFAULT_VOICE = "Nanami"


def parse_args() -> argparse.Namespace:
    """
    コマンドライン引数をパースする。

    `argparse` モジュールを使用して、入力テキスト/ファイル、動作モード（`read`または`list`）、
    音声フィルター、言語フィルターなどのコマンドライン引数を定義し、パースします。

    :returns: `argparse.Namespace` -- パースされた引数を含むオブジェクト。
    """
    parser = argparse.ArgumentParser(
        description="Edge TTS Utility"
    )

    parser.add_argument(
        "input",
        nargs="?",
        help="Text or filename"
    )

    parser.add_argument(
        "--mode",
        default="read",
        choices=["read", "list"],
        help="Operation mode"
    )

    parser.add_argument(
        "--voices",
        help="Voice filter or voice name"
    )

    parser.add_argument(
        "--lang",
        help="Language filter (ja, en, en-gb, fr-CH, ch ...)"
    )

    return parser.parse_args()


async def get_voice_list() -> List[Dict[str, Any]]:
    """
    Edge TTSで利用可能な音声のリストを取得する。

    `edge_tts.list_voices()` を非同期で呼び出し、
    利用可能な全ての音声の詳細情報を含むリストを返します。
    各音声は、`ShortName`, `Locale`, `Gender` などの情報を持つ辞書として表現されます。

    :returns: `list[dict]` -- 各要素が音声の詳細情報を持つ辞書であるリスト。
    """
    return await edge_tts.list_voices()


def match_lang(locale: str, lang_filter: Optional[str]) -> bool:
    """
    指定されたロケールが言語フィルターに一致するかを判定する。

    ロケール文字列を小文字に変換し、言語フィルターを `-` または `_` で分割したトークンが
    ロケールに含まれるかをチェックします。フィルターが指定されていない場合は常に `True` を返します。
    例えば、`locale="ja-JP"`, `lang_filter="ja"` の場合、`True` を返します。

    :param locale: `str` -- 比較対象のロケール文字列（例: "ja-JP"）。
    :param lang_filter: `Optional[str]` -- 適用する言語フィルター文字列（例: "ja", "en-us"）。`None` の場合はフィルターなし。
    :returns: `bool` -- ロケールがフィルターに一致すれば `True`、そうでなければ `False`。
    """
    if not lang_filter:
        return True

    locale = locale.lower()

    tokens = [
        token.strip().lower()
        for token in lang_filter.replace("_", "-").split("-")
        if token.strip()
    ]

    return all(token in locale for token in tokens)


def match_voice(short_name: str, voice_filter: Optional[str]) -> bool:
    """
    指定された音声の短い名前が音声フィルターに一致するかを判定する。

    音声の短い名前と音声フィルターを小文字に変換し、フィルターが短い名前に含まれるかをチェックします。
    フィルターが指定されていない場合は常に `True` を返します。
    例えば、`short_name="ja-JP-NanamiNeural"`, `voice_filter="nanami"` の場合、`True` を返します。

    :param short_name: `str` -- 比較対象の音声の短い名前（例: "ja-JP-NanamiNeural"）。
    :param voice_filter: `Optional[str]` -- 適用する音声フィルター文字列（例: "nanami"）。`None` の場合はフィルターなし。
    :returns: `bool` -- 音声がフィルターに一致すれば `True`、そうでなければ `False`。
    """
    if not voice_filter:
        return True

    return voice_filter.lower() in short_name.lower()


async def list_mode(lang_filter: Optional[str] = None, voice_filter: Optional[str] = None) -> None:
    """
    利用可能な音声のリストを表示する。

    `get_voice_list` で取得した音声リストを、言語フィルターと音声フィルターで絞り込み、
    整形してコンソールに出力します。各音声の`ShortName`、`Locale`、`Gender`が表示され、
    最終的に結果の音声数も表示されます。

    :param lang_filter: `Optional[str]` -- 音声リストを絞り込むための言語フィルター。
    :param voice_filter: `Optional[str]` -- 音声リストを絞り込むための音声フィルター。
    :returns: `None`
    """
    voices = await get_voice_list()

    count = 0

    for voice in sorted(
        voices,
        key=lambda x: x["ShortName"]
    ):

        short_name = voice["ShortName"]
        locale = voice["Locale"]
        gender = voice.get("Gender", "")

        if not match_lang(locale, lang_filter):
            continue

        if not match_voice(short_name, voice_filter):
            continue

        print(
            f"{short_name:40s} "
            f"{locale:10s} "
            f"{gender}"
        )

        count += 1

    print(f"\n{count} voice(s).")


async def find_voice(keyword: str) -> str:
    """
    キーワードに基づいて最適な音声を見つける。

    指定されたキーワードを使って、利用可能な音声の中から最適なものを検索し、その `ShortName` を返します。
    検索は以下の優先順位で行われます。

    1.  キーワードに完全に一致する音声。
    2.  キーワードが部分的に含まれる音声。
    3.  `"Nanami"` を含む音声（デフォルトの候補）。
    4.  日本語の女性音声。
    5.  利用可能な音声リストの最初の音声（最終保険）。

    :param keyword: `str` -- 検索する音声のキーワード。
    :returns: `str` -- 見つかった音声の `ShortName`。
    """
    voices = await get_voice_list()

    #
    # 完全一致
    #
    for voice in voices:

        if keyword.lower() == voice["ShortName"].lower():
            return voice["ShortName"]

    #
    # 部分一致
    #
    for voice in voices:

        if keyword.lower() in voice["ShortName"].lower():
            return voice["ShortName"]

    #
    # Nanami
    #
    for voice in voices:

        if "nanami" in voice["ShortName"].lower():
            return voice["ShortName"]

    #
    # 日本語女性音声
    #
    for voice in voices:

        if (
            voice["Locale"].lower().startswith("ja")
            and voice.get("Gender") == "Female"
        ):
            return voice["ShortName"]

    #
    # 最終保険
    #
    return voices[0]["ShortName"]


def load_text(arg: Optional[str]) -> str:
    """
    引数からテキストコンテンツを読み込む。

    引数がファイルパスであれば、そのファイルをUTF-8エンコーディングで読み込み、内容を返します。
    引数がファイルパスでなければ、それをそのままテキストとして返します。
    引数が `None` の場合は `ValueError` を発生させます。

    :param arg: `Optional[str]` -- テキスト内容、またはテキストファイルのパス。
    :returns: `str` -- 読み込まれたテキストコンテンツ。
    :raises ValueError: `arg` が `None` の場合。
    """
    if arg is None:

        raise ValueError(
            "Text or filename must be specified."
        )

    if os.path.isfile(arg):

        with open(
            arg,
            "r",
            encoding="utf-8"
        ) as f:

            return f.read()

    return arg


async def read_mode(text: str, voice_keyword: str) -> None:
    """
    指定されたテキストを読み上げ、オーディオファイルとして保存・再生する。

    `find_voice` を使って最適な音声を選択します。
    `edge_tts.Communicate` を使用してテキストを音声合成し、一時ファイルにMP3として保存します。
    生成されたオーディオファイルは、実行環境のOSに応じて適切なコマンド
    (`os.startfile` (Windows), `open` (macOS), `xdg-open` (Linux)) で自動的に再生されます。

    :param text: `str` -- 読み上げるテキストコンテンツ。
    :param voice_keyword: `str` -- 音声を選択するためのキーワード。
    :returns: `None`
    """
    voice = await find_voice(voice_keyword)

    print(f"Voice : {voice}")

    output_file = os.path.join(
        tempfile.gettempdir(),
        "edge_tts_output.mp3"
    )

    communicate = edge_tts.Communicate(
        text=text,
        voice=voice
    )

    await communicate.save(output_file)

    print(f"Output: {output_file}")

    if sys.platform.startswith("win"):

        os.startfile(output_file)

    elif sys.platform == "darwin":

        subprocess.run(
            ["open", output_file],
            check=False
        )

    else:

        subprocess.run(
            ["xdg-open", output_file],
            check=False
        )


async def main() -> None:
    """
    スクリプトのメインエントリポイント。

    `parse_args` を呼び出してコマンドライン引数を処理します。
    引数の `mode` に応じて `list_mode` (音声リスト表示) または `read_mode` (テキスト読み上げ) を呼び出します。
    `read` モードの場合、入力テキストの読み込みと音声選択のロジックも実行します。

    :returns: `None`
    """
    args = parse_args()

    #
    # list
    #
    if args.mode == "list":

        await list_mode(
            lang_filter=args.lang,
            voice_filter=args.voices
        )

        return

    #
    # read
    #
    voice_keyword = (
        args.voices
        if args.voices
        else DEFAULT_VOICE
    )

    text = load_text(args.input)

    await read_mode(
        text=text,
        voice_keyword=voice_keyword
    )


if __name__ == "__main__":

    asyncio.run(main())