Update app.py

app.py

@@ -1,495 +1,918 @@
 from flask import Flask, request, jsonify, render_template, send_from_directory
 import base64
-from pydub import AudioSegment
+# from pydub import AudioSegment # pydubは直接使われていないようなのでコメントアウトしても良いかも
 import os
 import shutil
 import requests
 import tempfile
 import json
-from process import AudioProcessor
-from transcription import TranscriptionMaker
-from analyze import TextAnalyzer
+# --- 必要に応じて実際のクラス/モジュールをインポート ---
+try:
+    from process import AudioProcessor
+    from transcription import TranscriptionMaker
+    from analyze import TextAnalyzer
+except ImportError:
+    print("警告: process, transcription, analyze モジュールが見つかりません。ダミークラスを使用します。")
+    # --- ダミークラス (実際のクラスがない場合のエラー回避用) ---
+    class AudioProcessor:
+        def delete_files_in_directory(self, path):
+            print(f"Dummy: Deleting files in {path}")
+            if os.path.isdir(path):
+                # ダミー実装: フォルダ内のファイルを削除するふり
+                for item in os.listdir(path):
+                    item_path = os.path.join(path, item)
+                    if os.path.isfile(item_path):
+                        print(f"Dummy: Removing file {item_path}")
+                        # os.remove(item_path) # 実際には削除しない
+                    elif os.path.isdir(item_path):
+                         print(f"Dummy: Removing directory {item_path}")
+                         # shutil.rmtree(item_path) # 実際には削除しない
+
+        def process_multi_audio(self, *args, **kwargs):
+            print("Dummy: Processing multi audio")
+            return [10, 5], {} # ダミーの戻り値
+        def process_audio(self, *args, **kwargs):
+            print("Dummy: Processing single audio")
+            return 10, 5, {} # ダミーの戻り値
+    class TranscriptionMaker:
+        def create_transcription(self, path):
+            print(f"Dummy: Creating transcription for {path}")
+            dummy_path = os.path.join(tempfile.gettempdir(), "dummy_transcription.txt")
+            try:
+                with open(dummy_path, "w", encoding='utf-8') as f:
+                    f.write("これはダミーの書き起こしです。")
+            except Exception as e:
+                 print(f"Dummy transcription file write error: {e}")
+                 # エラーが発生してもダミーパスを返す
+            return dummy_path
+        def save_marged_segments(self, segments):
+            print("Dummy: Saving merged segments")
+            dummy_path = os.path.join(tempfile.gettempdir(), "dummy_merged_audio.wav")
+            try:
+                 # ダミーファイルを作成（空でも良い）
+                with open(dummy_path, 'w') as f: pass
+            except Exception as e:
+                print(f"Dummy merged audio file create error: {e}")
+            return dummy_path
+    class TextAnalyzer:
+        def __init__(self, text_path, keywords):
+            print(f"Dummy: Initializing analyzer for {text_path}")
+            self.text_path = text_path
+            self.keywords = keywords
+        def analyze(self, api_key):
+            print("Dummy: Analyzing text")
+            # 環境変数チェックのダミー
+            if not api_key:
+                 print("Warning: Dummy DEEPSEEK API key not provided.")
+            return {"dummy_analysis": "ok", "deepseek_analysis": {"conversationLevel": 5, "harassmentPresent": False}} # ダミーの戻り値
+# ------------------------------------------------------------
+
 from flask_cors import CORS
+
+# --- グローバル変数と初期化 ---
+# 注意: グローバル変数はリクエスト間で共有されるため、同時アクセス時に問題が発生する可能性があります。
+# 本番環境では、データベースやセッション管理などのより堅牢な状態管理を検討してください。
 process = AudioProcessor()
 transcripter = TranscriptionMaker()
 app = Flask(__name__)
 
 # CORS設定: すべてのオリジンからのリクエストを許可
-# 必要であれば、特定のオリジンやメソッド、ヘッダーをより厳密に指定できます
-# 例: CORS(app, resources={r"/api/*": {"origins": "http://localhost:3000"}}, supports_credentials=True)
-CORS(app, origins="*", methods=["GET", "POST", "DELETE", "OPTIONS"], headers=["Content-Type", "Authorization"])
+# DELETEメソッドや特定のヘッダー（Content-Typeなど）も許可する
+CORS(app, origins="*", methods=["GET", "POST", "DELETE", "PUT", "OPTIONS"], headers=["Content-Type", "Authorization"])
 
-# GASのエンドポイントURL
+# GASのエンドポイントURL (実際のURLに置き換えてください)
 GAS_URL = "https://script.google.com/macros/s/AKfycbwR2cnMKVU1AxoT9NDaeZaNUaTiwRX64Ul0sH0AU4ccP49Byph-TpxtM_Lwm4G9zLnuYA/exec"
 
-users = []  # 選択されたユーザーの��スト
-all_users = []  # 利用可能なすべてのユーザーのリスト
-transcription_text = ""
+users = []  # 現在選択されているユーザー名のリスト
+all_users = []  # 利用可能なすべてのユーザー名のリスト (ファイル名から拡張子を除いたもの)
+transcription_text = "" # 書き起こしファイルのパス
+total_audio = "" # マージされた音声ファイルのパス
+
 harassment_keywords = [
     "バカ", "馬鹿", "アホ", "死ね", "クソ", "うざい",
     "きもい", "キモい", "ブス", "デブ", "ハゲ",
     "セクハラ", "パワハラ", "モラハラ"
 ]
-total_audio = ""
+# --- ここまでグローバル変数と初期化 ---
+
+
+# === ヘルパー関数 ===
+
+def _make_gas_request(payload, timeout=30):
+    """GASエンドポイントへのPOSTリクエストを送信し、レスポンスJSONを返す"""
+    try:
+        print(f"GAS Request Payload: {payload}")
+        response = requests.post(GAS_URL, json=payload, timeout=timeout)
+        response.raise_for_status() # HTTPエラー (4xx, 5xx) があれば例外を発生させる
+        res_json = response.json()
+        print(f"GAS Response: {res_json}")
+        if res_json.get("status") != "success":
+            # GAS側でエラーが報告された場合
+            raise Exception(f"GAS Error: {res_json.get('message', 'Unknown error from GAS')}")
+        return res_json
+    except requests.exceptions.Timeout:
+        print(f"Error: GAS request timed out after {timeout} seconds.")
+        raise TimeoutError(f"GAS request timed out ({timeout}s)")
+    except requests.exceptions.RequestException as e:
+        print(f"Error: Failed to connect to GAS: {e}")
+        raise ConnectionError(f"Failed to connect to GAS: {e}")
+    except json.JSONDecodeError as e:
+         print(f"Error: Failed to decode JSON response from GAS: {e}")
+         print(f"GAS Raw Response Text: {response.text[:500]}...") # レスポンス内容の一部を表示
+         raise ValueError(f"Invalid JSON response from GAS: {e}")
+    except Exception as e:
+        # _make_gas_request 内で発生したその他の予期せぬエラー
+        print(f"Error during GAS request processing: {e}")
+        raise # 元のエラーを再発生させる
+
+
+def download_from_cloud(filename_with_ext, local_path):
+    """クラウド(GAS)から指定されたファイルをダウンロードし、ローカルパスに保存する"""
+    payload = {"action": "download", "fileName": filename_with_ext}
+    try:
+        print(f"Downloading {filename_with_ext} from cloud...")
+        res_json = _make_gas_request(payload, timeout=60) # ダウンロードは時間がかかる可能性があるため長めのタイムアウト
+
+        base64_data = res_json.get("base64Data")
+        if not base64_data:
+            raise ValueError("No base64Data found in the download response.")
+
+        audio_binary = base64.b64decode(base64_data)
+        if not audio_binary:
+            raise ValueError("Failed to decode base64 data.")
+
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        with open(local_path, 'wb') as f:
+            f.write(audio_binary)
+
+        print(f"Successfully downloaded and saved to {local_path}")
+        if os.path.getsize(local_path) <= 0:
+            # ダウンロードしたがファイルサイズが0の場合
+            os.remove(local_path) # 不完全なファイルを削除
+            raise ValueError(f"Downloaded file {local_path} is empty.")
+
+        return local_path
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        print(f"Error downloading {filename_with_ext}: {str(e)}")
+        # エラーが発生したら上位に伝播させる
+        raise
+
+
+def delete_from_cloud(filename_with_ext):
+    """クラウド(GAS)から指定されたファイルを削除する"""
+    payload = {"action": "delete", "fileName": filename_with_ext}
+    try:
+        print(f"Deleting {filename_with_ext} from cloud...")
+        _make_gas_request(payload, timeout=30)
+        print(f"Successfully deleted {filename_with_ext} from cloud.")
+        return True
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        print(f"Error deleting {filename_with_ext}: {str(e)}")
+        # エラーが発生したら上位に伝播させる
+        raise
+
+
+def update_all_users():
+    """GASから最新のファイルリストを取得し、グローバル変数 all_users を更新する"""
+    global all_users
+    payload = {"action": "list"}
+    try:
+        print("Fetching user list from cloud...")
+        res_json = _make_gas_request(payload, timeout=30)
+        # ファイル名から拡張子を除去してリストを作成 (空のファイル名を除外)
+        current_users = [os.path.splitext(name)[0] for name in res_json.get("fileNames", []) if name and '.' in name]
+        all_users = sorted(list(set(current_users))) # 重複除去とソート
+        print(f"Updated all_users list: {all_users}")
+        return all_users # 更新後のリストを返す
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        print(f"Error updating all_users list: {str(e)}")
+        # エラーが発生しても、既存の all_users は変更せず、エラーを上位に伝播
+        raise
+
+# === Flask ルート定義 ===
 
+# React用: ユーザーリスト取得エンドポイント (JSON構造は変更しない)
+@app.route('/list_base_audio', methods=['GET'])
+def list_base_audio():
+    """現在の all_users リストを返す (React側で処理が必要)"""
+    global all_users
+    try:
+        # 関数を呼び出して最新の状態を取得・更新
+        update_all_users()
+        # 元の形式で返す
+        return jsonify({"status": "success", "fileNames": all_users}), 200
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        # GASとの通信エラーなどでリスト取得に失敗した場合
+        print(f"Error in /list_base_audio: {str(e)}")
+        # エラー発生時は空リストまたはエラーメッセージを返す
+        # return jsonify({"status": "error", "message": "Failed to retrieve user list", "details": str(e)}), 500
+        # または、現状保持しているリストがあればそれを返し、エラーをログに残すだけでも良いかもしれない
+        print("Returning potentially stale user list due to update error.")
+        return jsonify({"status": "warning", "message": "Could not refresh list, returning cached data.", "fileNames": all_users}), 200 # 警告付きで成功扱いにするか、5xxエラーにするかは要件次第
+
+# React用: ユーザー削除エンドポイント
+@app.route('/api/users/<user_name>', methods=['DELETE'])
+def delete_user_api(user_name):
+    """指定されたユーザー名のファイルをクラウドから削除し、ローカルリストも更新"""
+    global users
+    global all_users
+
+    if not user_name:
+        return jsonify({"status": "error", "message": "User name cannot be empty"}), 400
 
-@app.route('/index', methods=['GET', 'POST'])
+    filename_to_delete = f"{user_name}.wav" # GAS側で想定されるファイル名
+
+    try:
+        print(f"API delete request for user: {user_name}")
+        # 1. クラウドから削除
+        delete_from_cloud(filename_to_delete)
+
+        # 2. ローカルリストから削除 (成功した場合のみ)
+        deleted_from_local = False
+        if user_name in all_users:
+            all_users.remove(user_name)
+            print(f"Removed '{user_name}' from all_users list.")
+            deleted_from_local = True
+        if user_name in users:
+            users.remove(user_name)
+            print(f"Removed '{user_name}' from selected users (users) list.")
+            deleted_from_local = True
+
+        if not deleted_from_local:
+             print(f"Warning: User '{user_name}' was not found in local lists (all_users, users) but deletion from cloud was attempted/successful.")
+
+        # 成功レスポンス
+        return jsonify({"status": "success", "message": f"User '{user_name}' deleted successfully."}), 200
+
+    except FileNotFoundError:
+         # delete_from_cloud 内で発生した場合（GASがファイルなしと応答した場合など）
+         # または、ローカルリストにそもそも存在しなかった場合
+         print(f"User '{user_name}' not found for deletion (either on cloud or locally).")
+         # 念のためローカルリストからも削除試行（既になくてもエラーにはならない）
+         if user_name in all_users: all_users.remove(user_name)
+         if user_name in users: users.remove(user_name)
+         return jsonify({"status": "error", "message": f"User '{user_name}' not found."}), 404 # Not Found
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        # GAS通信エラーやその他の予期せぬエラー
+        error_message = f"Failed to delete user '{user_name}'."
+        print(f"{error_message} Details: {str(e)}")
+        # クライアントには詳細なエラー原因を伏せる場合もある
+        return jsonify({"status": "error", "message": error_message, "details": str(e)}), 500 # Internal Server Error
+
+# --- 既存のテンプレートレンダリング用ルート (変更なし) ---
+@app.route('/index', methods=['GET']) # POST不要なら削除
 def index():
     return render_template('index.html', users=users)
 
-# フィードバック画面（テンプレート: feedback.html）
-@app.route('/feedback', methods=['GET', 'POST'])
+@app.route('/feedback', methods=['GET'])
 def feedback():
     return render_template('feedback.html')
 
-# 会話詳細画面（テンプレート: talkDetail.html）
-@app.route('/talk_detail', methods=['GET', 'POST'])
+@app.route('/talk_detail', methods=['GET'])
 def talk_detail():
     return render_template('talkDetail.html')
 
-# 音声登録画面（テンプレート: userRegister.html）
-@app.route('/userregister', methods=['GET', 'POST'])
+@app.route('/userregister', methods=['GET'])
 def userregister():
     return render_template('userRegister.html')
 
-# 人数確認
+@app.route('/reset_html', methods=['GET'])
+def reset_html():
+    return render_template('reset.html')
+
+@app.route('/', methods=['GET']) # ルートパス
+@app.route('/userselect', methods=['GET'])
+def userselect():
+    # ユーザー選択画面表示時に最新リストを取得・表示するならここで update_all_users() を呼ぶ
+    # try:
+    #     update_all_users()
+    # except Exception as e:
+    #     print(f"Failed to update users on loading userselect page: {e}")
+    # return render_template('userSelect.html', available_users=all_users) # テンプレートに渡す場合
+    return render_template('userSelect.html') # テンプレート側でAPIを叩く場合
+# --- ここまでテンプレートレンダリング用ルート ---
+
+
+# --- 既存のAPIエンドポイント (一部見直し) ---
+
+# 人数確認 (最新リストを返すように修正)
 @app.route('/confirm', methods=['GET'])
 def confirm():
+    global users
     global all_users
-    # 最新のユーザーリストを取得
     try:
-        update_all_users()
+        update_all_users() # 最新の状態に更新試行
     except Exception as e:
-        print(f"ユーザーリストの更新エラー: {str(e)}")
-    return jsonify({'members': users, 'all_members': all_users}), 200
+        print(f"ユーザーリストの更新エラー (/confirm): {str(e)}")
+        # エラーでも現在のリストを返す（あるいはエラーを示す）
+    return jsonify({'selected_members': users, 'all_available_members': all_users}), 200
 
-# リセット画面（テンプレート: reset.html）
-@app.route('/reset_html', methods=['GET', 'POST']) 
-def reset_html():
-    return render_template('reset.html')
 
-# メンバー削除&累積音声削除
-@app.route('/reset_member', methods=['GET', 'POST'])
+# 複数メンバー削除 (POST推奨)
+@app.route('/reset_member', methods=['POST']) # GETよりPOSTが適切
 def reset_member():
     global users
+    global all_users
     global total_audio
     global transcription_text
-    
-    # 一時ディレクトリのクリーンアップ
-    if total_audio:
-        process.delete_files_in_directory(total_audio)
-    process.delete_files_in_directory('/tmp/data/transcription_audio')
-    
-    # 書き起こしテキストの削除
-    if os.path.exists(transcription_text):
+
+    # --- 一時ファイル/変数クリア ---
+    print("Resetting temporary files and variables...")
+    # total_audio パスの処理 (存在チェックと種類判別)
+    if total_audio and os.path.exists(total_audio):
+        try:
+            if os.path.isfile(total_audio):
+                os.remove(total_audio)
+                print(f"Deleted file: {total_audio}")
+            elif os.path.isdir(total_audio):
+                 # ディレクトリ内のファイルを削除 (AudioProcessorに任せる)
+                 process.delete_files_in_directory(total_audio)
+                 print(f"Cleared files in directory: {total_audio}")
+                 # 必要ならディレクトリ自体も削除: shutil.rmtree(total_audio)
+            else:
+                 print(f"Warning: Path exists but is not a file or directory: {total_audio}")
+        except Exception as e:
+            print(f"Error clearing total_audio path '{total_audio}': {e}")
+    total_audio = "" # パスをクリア
+
+    # 書き起こしテキストファイルの削除
+    if transcription_text and os.path.exists(transcription_text):
         try:
             os.remove(transcription_text)
-            print(f"{transcription_text} を削除しました。")
+            print(f"Deleted transcription file: {transcription_text}")
         except Exception as e:
-            print(f"ファイル削除中にエラーが発生しました: {e}")
-    
-    transcription_text = ""
-    
+            print(f"Error deleting transcription file '{transcription_text}': {e}")
+    transcription_text = "" # パスをクリア
+
+    # その他の関連一時ディレクトリのクリア (存在しなければ何もしない)
+    try:
+        transcription_audio_dir = '/tmp/data/transcription_audio'
+        if os.path.isdir(transcription_audio_dir):
+            process.delete_files_in_directory(transcription_audio_dir)
+            print(f"Cleared files in directory: {transcription_audio_dir}")
+    except Exception as e:
+        print(f"Error clearing transcription_audio directory: {e}")
+    # --- ここまで一時ファイル/変数クリア ---
+
     try:
         data = request.get_json()
-        if not data or "names" not in data:
-            return jsonify({"status": "error", "message": "Invalid request body"}), 400
+        if not data or "names" not in data or not isinstance(data["names"], list):
+            return jsonify({"status": "error", "message": "Invalid request body, 'names' array is required"}), 400
+
+        names_to_delete = data["names"]
+        if not names_to_delete:
+             return jsonify({"status": "warning", "message": "No names provided for deletion."}), 200 # 何もしないで成功
+
+        print(f"Bulk delete request for names: {names_to_delete}")
+        deleted_names = []
+        errors = []
 
-        names = data.get("names", [])
-        
-        # GASからファイルを削除
-        for name in names:
+        for name in names_to_delete:
+            if not name: continue # 空の名前はスキップ
+            filename_to_delete = f"{name}.wav"
             try:
-                delete_from_cloud(f"{name}.wav")
-                print(f"クラウドから {name}.wav を削除しました。")
+                delete_from_cloud(filename_to_delete)
+                deleted_names.append(name)
+                # ローカルリストからも削除
+                if name in all_users: all_users.remove(name)
+                if name in users: users.remove(name)
             except Exception as e:
-                print(f"クラウド削除中にエラーが発生しました: {e}")
-                return jsonify({"status": "error", "message": f"Failed to delete {name} from cloud: {e}"}), 500
+                error_msg = f"Failed to delete '{name}': {str(e)}"
+                print(error_msg)
+                errors.append({"name": name, "error": str(e)})
 
-        # usersリストから削除するユーザーを除外
-        users = [u for u in users if u not in names]
-        
-        # 全ユーザーリストの更新
-        update_all_users()
-
-        return jsonify({"status": "success", "message": "Members deleted successfully", "users": users}), 200
+        # 削除処理後に最新のユーザーリストをGASから取得して同期するのが望ましい
+        final_users_list = all_users # エラーがあっても現在のリストを返す
+        try:
+            final_users_list = update_all_users()
+        except Exception as e:
+            print(f"Failed to refresh user list after bulk delete: {e}")
+            errors.append({"name": "N/A", "error": f"Failed to refresh user list: {e}"})
+
+
+        if errors:
+             # 一部成功、一部失敗、またはリスト更新失敗
+             return jsonify({
+                 "status": "partial_success" if deleted_names else "error",
+                 "message": f"Deleted {len(deleted_names)} out of {len(names_to_delete)} requested members. Some errors occurred.",
+                 "deleted": deleted_names,
+                 "errors": errors,
+                 "current_users": final_users_list # 更新後のリスト
+                 }), 207 # Multi-Status or 500 if no success
+        else:
+             # すべて成功
+             return jsonify({
+                 "status": "success",
+                 "message": f"Successfully deleted {len(deleted_names)} members.",
+                 "deleted": deleted_names,
+                 "current_users": final_users_list # 更新後のリスト
+                 }), 200
 
     except Exception as e:
-        print(f"An unexpected error occurred: {e}")
+        print(f"Unexpected error in /reset_member: {e}")
         return jsonify({"status": "error", "message": f"Internal server error: {e}"}), 500
 
-# 書き起こし作成エンドポイント
-@app.route('/transcription', methods=['GET', 'POST'])
+# 書き起こし作成エンドポイント (エラーハンドリング改善)
+@app.route('/transcription', methods=['POST']) # GET不要なら削除
 def transcription():
     global transcription_text
     global total_audio
-    
-    if not os.path.exists(transcription_text) or not transcription_text:
-        try: 
-            if not total_audio or not os.path.exists(total_audio):
-                return jsonify({"error": "No audio segments provided"}), 400
+
+    # 書き起こしテキストが既に存在するかチェック
+    if transcription_text and os.path.exists(transcription_text):
+         print(f"Returning existing transcription file: {transcription_text}")
+         # 既存のファイルを返す
+    else:
+        # 書き起こしが存在しない、またはパスが無効な場合、新規作成を試みる
+        print("Transcription file not found or path invalid. Attempting to create...")
+        if not total_audio or not os.path.exists(total_audio):
+             print("Error: total_audio path is not set or file does not exist.")
+             return jsonify({"error": "Audio data for transcription is missing or invalid."}), 400
+
+        try:
+            # ここで実際に書き起こし処理を実行
             transcription_text = transcripter.create_transcription(total_audio)
-            print("transcription")
-            print(transcription_text)
+            if not transcription_text or not os.path.exists(transcription_text):
+                 # create_transcription がパスを返さない、またはファイルが生成されなかった場合
+                 raise FileNotFoundError("Transcription process did not generate a valid file path.")
+            print(f"Transcription created: {transcription_text}")
         except Exception as e:
-            return jsonify({"error": str(e)}), 500
-    
+            print(f"Error during transcription creation: {str(e)}")
+            transcription_text = "" # エラー時はパスをクリア
+            return jsonify({"error": f"Failed to create transcription: {str(e)}"}), 500
+
+    # 有効な書き起こしファイルパスがある場合、内容を読み込んで返す
     try:
         with open(transcription_text, 'r', encoding='utf-8') as file:
             file_content = file.read()
-            print(file_content)
-            return jsonify({'transcription': file_content}), 200
+        # print(f"Transcription content: {file_content[:200]}...") # 内容の一部をログ表示
+        return jsonify({'transcription': file_content}), 200
     except FileNotFoundError:
-        return jsonify({"error": "Transcription file not found"}), 404
+        print(f"Error: Transcription file not found at path: {transcription_text}")
+        return jsonify({"error": "Transcription file could not be read (not found)."}), 404
     except Exception as e:
-        return jsonify({"error": f"Unexpected error: {str(e)}"}), 500
+        print(f"Error reading transcription file: {str(e)}")
+        return jsonify({"error": f"Unexpected error reading transcription: {str(e)}"}), 500
 
-# AI分析エンドポイント
-@app.route('/analyze', methods=['GET', 'POST'])
+# AI分析エンドポイント (APIキーチェック改善)
+@app.route('/analyze', methods=['POST']) # GET不要なら削除
 def analyze():
     global transcription_text
     global total_audio
-    
-    if not os.path.exists(transcription_text) or not transcription_text:
-        try: 
-            if not total_audio:
-                return jsonify({"error": "No audio segments provided"}), 400
+
+    # まず書き起こしファイルが存在するか確認、なければ作成試行
+    if not transcription_text or not os.path.exists(transcription_text):
+        print("Transcription not found for analysis. Attempting to create...")
+        # /transcription エンドポイントと同様のロジックで書き起こし作成を試みる
+        if not total_audio or not os.path.exists(total_audio):
+             return jsonify({"error": "Audio data for analysis is missing or invalid."}), 400
+        try:
             transcription_text = transcripter.create_transcription(total_audio)
+            if not transcription_text or not os.path.exists(transcription_text):
+                 raise FileNotFoundError("Transcription process did not generate a valid file path.")
+            print(f"Transcription created for analysis: {transcription_text}")
         except Exception as e:
-            return jsonify({"error": str(e)}), 500    
-    
-    analyzer = TextAnalyzer(transcription_text, harassment_keywords)
+            print(f"Error creating transcription during analysis: {str(e)}")
+            transcription_text = ""
+            return jsonify({"error": f"Failed to create transcription for analysis: {str(e)}"}), 500
+
+    # APIキーのチェック
     api_key = os.environ.get("DEEPSEEK")
-    if api_key is None:
-        raise ValueError("DEEPSEEK_API_KEY が設定されていません。")
-    
-    results = analyzer.analyze(api_key=api_key)
-
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-    if "deepseek_analysis" in results and results["deepseek_analysis"]:
-        deepseek_data = results["deepseek_analysis"]
-        conversation_level = deepseek_data.get("conversationLevel")
-        harassment_present = deepseek_data.get("harassmentPresent")
-        harassment_type = deepseek_data.get("harassmentType")
-        repetition = deepseek_data.get("repetition")
-        pleasantConversation = deepseek_data.get("pleasantConversation")
-        blameOrHarassment = deepseek_data.get("blameOrHarassment")
-
-        print("\n--- DeepSeek 分析結果 ---")
-        print(f"会話レベル: {conversation_level}")
-        print(f"ハラスメントの有無: {harassment_present}")
-        print(f"ハラスメントの種類: {harassment_type}")
-        print(f"繰り返しの程度: {repetition}")
-        print(f"会話の心地よさ: {pleasantConversation}")
-        print(f"非難またはハラスメントの程度: {blameOrHarassment}")
-    
-    return jsonify({"results": results}), 200
-
-
-# クラウドから音声を取得してローカルに保存する関数
-def download_from_cloud(filename, local_path):
+    if not api_key:
+        print("Error: DEEPSEEK environment variable is not set.")
+        # サーバー内部の問題なので 500 Internal Server Error が適切
+        return jsonify({"error": "Analysis service API key is not configured on the server."}), 500
+
     try:
-        payload = {
-            "action": "download",
-            "fileName": filename
-        }
-        
-        print(f"クラウドから {filename} をダウンロード中...")
-        response = requests.post(GAS_URL, json=payload)
-        if response.status_code != 200:
-            print(f"ダウンロードエラー: ステータスコード {response.status_code}")
-            print(f"レスポンス: {response.text}")
-            raise Exception(f"クラウドからのダウンロードに失敗しました: {response.text}")
-        
-        try:
-            res_json = response.json()
-        except:
-            print("JSONデコードエラー、レスポンス内容:")
-            print(response.text[:500])  # 最初の500文字だけ表示
-            raise Exception("サーバーからの応答をJSONとして解析できませんでした")
-        
-        if res_json.get("status") != "success":
-            print(f"ダウンロードステータスエラー: {res_json.get('message')}")
-            raise Exception(f"クラウドからのダウンロードに失敗しました: {res_json.get('message')}")
-        
-        # Base64文字列をデコード
-        base64_data = res_json.get("base64Data")
-        if not base64_data:
-            print("Base64データが存在しません")
-            raise Exception("応答にBase64データが含まれていません")
-            
-        try:
-            audio_binary = base64.b64decode(base64_data)
-        except Exception as e:
-            print(f"Base64デコードエラー: {str(e)}")
-            raise Exception(f"音声データのデコードに失敗しました: {str(e)}")
-        
-        # 指定パスに保存
-        os.makedirs(os.path.dirname(local_path), exist_ok=True)
-        with open(local_path, 'wb') as f:
-            f.write(audio_binary)
-            
-        print(f"{filename} をローカルに保存しました: {local_path}")
-        
-        # データの整合性チェック（ファイルサイズが0より大きいかなど）
-        if os.path.getsize(local_path) <= 0:
-            raise Exception(f"保存されたファイル {local_path} のサイズが0バイトです")
-            
-        return local_path
+        analyzer = TextAnalyzer(transcription_text, harassment_keywords)
+        print(f"Analyzing text from: {transcription_text}")
+        results = analyzer.analyze(api_key=api_key) # analyzeメソッドにAPIキーを渡す
+
+        # 結果のログ出力（必要なら）
+        # print(json.dumps(results, ensure_ascii=False, indent=2))
+        if "deepseek_analysis" in results and results["deepseek_analysis"]:
+             print("--- DeepSeek Analysis Results ---")
+             for key, value in results["deepseek_analysis"].items():
+                 print(f"{key}: {value}")
+             print("-------------------------------")
+
+        return jsonify({"results": results}), 200
+    except FileNotFoundError:
+        # TextAnalyzer初期化時や analyze メソッド内でファイルが見つからない場合
+         print(f"Error: Transcription file not found during analysis: {transcription_text}")
+         return jsonify({"error": "Transcription file could not be read for analysis."}), 404
     except Exception as e:
-        print(f"ダウンロード中にエラーが発生しました: {str(e)}")
-        # エラーを上位に伝播させる
-        raise
+        print(f"Error during text analysis: {str(e)}")
+        return jsonify({"error": f"Analysis failed: {str(e)}"}), 500
 
-# クラウドからファイルを削除する関数
-def delete_from_cloud(filename):
-    payload = {
-        "action": "delete",
-        "fileName": filename
-    }
-    response = requests.post(GAS_URL, json=payload)
-    if response.status_code != 200:
-        raise Exception(f"クラウドからの削除に失敗しました: {response.text}")
-    
-    res_json = response.json()
-    if res_json.get("status") != "success":
-        raise Exception(f"クラウドからの削除に失敗しました: {res_json.get('message')}")
-    
-    return True
-# すべてのベース音声ユーザーリストを更新する関数
-def update_all_users():
-    global all_users
-    
-    payload = {"action": "list"}
-    response = requests.post(GAS_URL, json=payload)
-    if response.status_code != 200:
-        raise Exception(f"GAS一覧取得エラー: {response.text}")
-    
-    res_json = response.json()
-    if res_json.get("status") != "success":
-        raise Exception(f"GAS一覧取得失敗: {res_json.get('message')}")
-    
-    # ファイル名から拡張子を除去してユーザーリストを作成
-    all_users = [os.path.splitext(filename)[0] for filename in res_json.get("fileNames", [])]
-    return all_users
-
-# 音声アップロード＆解析エンドポイント
+
+# 音声アップロード＆解析エンドポイント (エラーハンドリング、一時ファイル管理改善)
 @app.route('/upload_audio', methods=['POST'])
 def upload_audio():
     global total_audio
     global users
-    
+
+    temp_audio_file = None # 一時ファイルのパスを保持
+    temp_base_audio_dir = "/tmp/data/base_audio" # ベース音声の一時保存先
+
     try:
         data = request.get_json()
         if not data or 'audio_data' not in data:
-            return jsonify({"error": "音声データがありません"}), 400
-            
-        # リクエストからユーザーリストを取得（指定がなければ現在のusersを使用）
-        if 'selected_users' in data and data['selected_users']:
-            users = data['selected_users']
-            print(f"選択されたユーザー: {users}")
+            return jsonify({"error": "音声データ(audio_data)がありません"}), 400
+        if 'selected_users' in data and isinstance(data['selected_users'], list):
+            # リクエストで指定されたユーザーリストを使用
+            current_selected_users = data['selected_users']
+            if not current_selected_users:
+                 return jsonify({"error": "選択されたユーザー(selected_users)がいません"}), 400
+            users = current_selected_users # グローバル変数も更新 (必要なら)
+            print(f"Received selected users: {users}")
+        elif not users:
+            # リクエストにもグローバル変数にもユーザーがいない場合
+            return jsonify({"error": "処理対象のユーザーが選択されていません"}), 400
+        else:
+             print(f"Using globally selected users: {users}")
 
-        if not users:
-            return jsonify({"error": "選択されたユーザーがいません"}), 400
 
-        # Base64デコードして音声バイナリを取得
+        # --- アップロードされた音声の一時保存 ---
         audio_binary = base64.b64decode(data['audio_data'])
-        
-        upload_name = 'tmp'
-        audio_dir = "/tmp/data"
+        if not audio_binary:
+             return jsonify({"error": "音声データのデコードに失敗しました"}), 400
+
+        # 一時ファイルを作成 (アップロードされた音声)
+        audio_dir = "/tmp/data/uploads" # アップロード専用の一時フォルダ推奨
         os.makedirs(audio_dir, exist_ok=True)
-        audio_path = os.path.join(audio_dir, f"{upload_name}.wav")
-        with open(audio_path, 'wb') as f:
+        # 一意なファイル名を使用 (例: UUIDやタイムスタンプ)
+        temp_audio_fd, temp_audio_file = tempfile.mkstemp(suffix=".wav", dir=audio_dir)
+        os.close(temp_audio_fd) # ファイルディスクリプタを閉じる
+        with open(temp_audio_file, 'wb') as f:
             f.write(audio_binary)
-        
-        print(f"処理を行うユーザー: {users}")
-        
-        # ベース音声を一時ディレクトリにダウンロード
-        temp_dir = "/tmp/data/base_audio"
-        os.makedirs(temp_dir, exist_ok=True)
-        
-        # 各ユーザーの参照音声ファイルのパスをリストに格納
+        print(f"Uploaded audio saved temporarily to: {temp_audio_file}")
+        # --- ここまで一時保存 ---
+
+
+        # --- 参照音声の準備 (ダウンロード) ---
+        os.makedirs(temp_base_audio_dir, exist_ok=True)
         reference_paths = []
-        for user in users:
+        missing_users = []
+        for user_name in users:
+            ref_path = os.path.join(temp_base_audio_dir, f"{user_name}.wav")
             try:
-                ref_path = os.path.join(temp_dir, f"{user}.wav")
-                if not os.path.exists(ref_path):
-                    # クラウドから取得
-                    download_from_cloud(f"{user}.wav", ref_path)
-                    print(f"クラウドから {user}.wav をダウンロードしました")
-                
-                if not os.path.exists(ref_path):
-                    return jsonify({"error": "参照音声ファイルが見つかりません", "details": ref_path}), 500
-                    
-                reference_paths.append(ref_path)
+                if not os.path.exists(ref_path) or os.path.getsize(ref_path) == 0:
+                    # ローカルにないか、空ファイルの場合はクラウドからダウンロード
+                    print(f"Reference audio for '{user_name}' not found locally, downloading...")
+                    download_from_cloud(f"{user_name}.wav", ref_path)
+                else:
+                     print(f"Using local reference audio for '{user_name}': {ref_path}")
+
+                if os.path.exists(ref_path) and os.path.getsize(ref_path) > 0:
+                    reference_paths.append(ref_path)
+                else:
+                     # ダウンロード後もファイルが存在しないか空の場合
+                     missing_users.append(user_name)
+
             except Exception as e:
-                return jsonify({"error": f"ユーザー {user} の音声取得に失敗しました", "details": str(e)}), 500
-        
-        # 複数人の場合は参照パスのリストを、1人の場合は単一のパスを渡す
+                print(f"Error preparing reference audio for user '{user_name}': {str(e)}")
+                missing_users.append(user_name)
+                # 一人のエラーで全体を失敗させるか、続行するかは要件次第
+                # ここではエラーリストに追加して最後にチェックする
+
+        if missing_users:
+            # 必要な参照音声の一部または全部が見つからなかった場合
+            return jsonify({"error": f"参照音声の準備に失敗しました。見つからない、またはダウンロードできないユーザー: {', '.join(missing_users)}"}), 404 # Not Found or 500
+
+        if not reference_paths:
+             return jsonify({"error": "有効な参照音声ファイルがありません"}), 500
+        # --- ここまで参照音声の準備 ---
+
+
+        # --- 音声処理の実行 ---
+        print(f"Processing audio with {len(users)} user(s)...")
+        merged_segments_result = None # 初期化
         if len(users) > 1:
-            print("複数人の場合の処理")
-            matched_times, merged_segments = process.process_multi_audio(reference_paths, audio_path, users, threshold=0.05)
-            total_audio = transcripter.save_marged_segments(merged_segments)
-            # 各メンバーのrateを計算
-            total_time = sum(matched_times)
+            # 複数ユーザーの場合
+            matched_times, merged_segments_result = process.process_multi_audio(
+                reference_paths, temp_audio_file, users, threshold=0.05
+            )
+            total_time = sum(matched_times) if matched_times else 0
             rates = [(time / total_time) * 100 if total_time > 0 else 0 for time in matched_times]
-            
-            # ユーザー名と話した割合をマッピング
             user_rates = {users[i]: rates[i] for i in range(len(users))}
-            return jsonify({"rates": rates, "user_rates": user_rates}), 200
+            result_data = {"rates": rates, "user_rates": user_rates}
+            print(f"Multi-user processing result: {result_data}")
         else:
-            matched_time, unmatched_time, merged_segments = process.process_audio(reference_paths[0], audio_path, users[0], threshold=0.05)
-            total_audio = transcripter.save_marged_segments(merged_segments)
-            print("単一ユーザーの処理")
+            # 単一ユーザーの場合
+            matched_time, unmatched_time, merged_segments_result = process.process_audio(
+                reference_paths[0], temp_audio_file, users[0], threshold=0.05
+            )
             total_time = matched_time + unmatched_time
             rate = (matched_time / total_time) * 100 if total_time > 0 else 0
-            return jsonify({"rate": rate, "user": users[0]}), 200
-            
+            result_data = {"rate": rate, "user": users[0]}
+            print(f"Single-user processing result: {result_data}")
+
+        # マージされたセグメントを保存し、グローバル変数 total_audio を更新
+        if merged_segments_result is not None:
+             # 以前の total_audio ファイルがあれば削除
+             if total_audio and os.path.exists(total_audio) and os.path.isfile(total_audio):
+                  try: os.remove(total_audio)
+                  except OSError as e: print(f"Could not remove previous total_audio file '{total_audio}': {e}")
+
+             total_audio = transcripter.save_marged_segments(merged_segments_result)
+             print(f"Merged audio saved to: {total_audio}")
+             if not total_audio or not os.path.exists(total_audio):
+                  print("Warning: Saving merged segments did not produce a valid file path.")
+                  # エラーにするか警告に留めるか
+                  # return jsonify({"error": "Failed to save processed audio segments."}), 500
+        else:
+             print("Warning: No merged segments were generated by the process.")
+             # 必要に応じて total_audio をクリア
+             if total_audio and os.path.exists(total_audio) and os.path.isfile(total_audio):
+                  try: os.remove(total_audio)
+                  except OSError as e: print(f"Could not remove previous total_audio file '{total_audio}': {e}")
+             total_audio = ""
+
+
+        return jsonify(result_data), 200
+        # --- ここまで音声処理 ---
+
+    except base64.binascii.Error as e:
+         print(f"Error decoding base64 audio data: {e}")
+         return jsonify({"error": "無効な音声データ形式です (Base64デコード失敗)"}), 400
+    except FileNotFoundError as e:
+         print(f"File not found error during audio processing: {e}")
+         return jsonify({"error": "処理に必要なファイルが見つかりません", "details": str(e)}), 404
     except Exception as e:
-        print("Error in /upload_audio:", str(e))
-        return jsonify({"error": "サーバーエラー", "details": str(e)}), 500
+        # その他の予期せぬエラー
+        print(f"Unexpected error in /upload_audio: {str(e)}")
+        # traceback.print_exc() # 詳細なスタックトレースをログに出力する場合
+        return jsonify({"error": "音声処理中にサーバーエラーが発生しました", "details": str(e)}), 500
+    finally:
+        # --- 一時ファイルのクリーンアップ ---
+        if temp_audio_file and os.path.exists(temp_audio_file):
+            try:
+                os.remove(temp_audio_file)
+                print(f"Cleaned up temporary upload file: {temp_audio_file}")
+            except Exception as e:
+                print(f"Error cleaning up temporary file '{temp_audio_file}': {e}")
+        # ベース音声の一時ファイルは他の処理で使う可能性があるため、ここでは削除しない
+        # clear_tmp エンドポイントなどで定期的に削除することを推奨
+        # --- ここまでクリーンアップ ---
 
-# ユーザー選択画面（テンプレート: userSelect.html）
-@app.route('/')
-@app.route('/userselect', methods=['GET'])
-def userselect():
-    return render_template('userSelect.html')
 
 # 選択したユーザーを設定するエンドポイント
 @app.route('/select_users', methods=['POST'])
 def select_users():
     global users
-    
+    global all_users # 選択されたユーザーが実際に存在するか確認するために使用
+
     try:
         data = request.get_json()
-        if not data or 'users' not in data:
-            return jsonify({"error": "ユーザーリストがありません"}), 400
-            
-        users = data['users']
-        print(f"選択されたユーザー: {users}")
-        
-        return jsonify({"status": "success", "selected_users": users}), 200
+        if not data or 'users' not in data or not isinstance(data['users'], list):
+            return jsonify({"error": "リクエストボディに 'users' 配列がありません"}), 400
+
+        selected_user_names = data['users']
+        print(f"Received users to select: {selected_user_names}")
+
+        # (任意) 選択されたユーザーが実際に存在するか確認
+        try:
+            update_all_users() # 最新の全ユーザーリストを取得
+        except Exception as e:
+            print(f"Warning: Could not verify selected users against the latest list due to update error: {e}")
+            # エラーが発生しても処理は続行するが、存在しないユーザーが含まれる可能性がある
+
+        valid_selected_users = []
+        invalid_users = []
+        for name in selected_user_names:
+             if name in all_users:
+                 valid_selected_users.append(name)
+             else:
+                 invalid_users.append(name)
+
+        if invalid_users:
+             print(f"Warning: The following selected users do not exist in the available list: {invalid_users}")
+             # 無効なユーザーを除外するか、エラーにするかは要件次第
+             # ここでは有効なユーザーのみを設定する
+             users = sorted(list(set(valid_selected_users))) # 重複除去とソート
+             return jsonify({
+                 "status": "warning",
+                 "message": f"一部のユーザーが存在しませんでした: {', '.join(invalid_users)}",
+                 "selected_users": users
+             }), 200 # 成功扱いにするか、クライアント側で処理しやすいステータスコード（例: 207 Multi-Status）
+        else:
+             # 全員有効な場合
+             users = sorted(list(set(valid_selected_users)))
+             print(f"Successfully selected users: {users}")
+             return jsonify({"status": "success", "selected_users": users}), 200
+
     except Exception as e:
-        print("Error in /select_users:", str(e))
-        return jsonify({"error": "サーバーエラー", "details": str(e)}), 500
+        print(f"Error in /select_users: {str(e)}")
+        return jsonify({"error": "サーバーエラーが発生しました", "details": str(e)}), 500
 
-@app.route('/reset', methods=['GET'])
+# リセットエンドポイント (選択中ユーザーと一時ファイルをクリア)
+@app.route('/reset', methods=['GET']) # または POST
 def reset():
     global users
-    users = []
     global total_audio
     global transcription_text
-    
-    # 一時ディレクトリのクリーンアップ
-    if total_audio:
-        process.delete_files_in_directory(total_audio)
-        process.delete_files_in_directory('/tmp/data/transcription_audio')
-    
-    # 書き起こしテキストの削除
-    if os.path.exists(transcription_text):
+
+    print("Resetting selected users and temporary analysis files...")
+    # 選択中ユーザーをクリア
+    users = []
+    print("Selected users list cleared.")
+
+    # 一時ファイル/変数クリア (/reset_member と同様のロジック)
+    if total_audio and os.path.exists(total_audio):
         try:
-            os.remove(transcription_text)
-            print(f"{transcription_text} を削除しました。")
-        except Exception as e:
-            print(f"ファイル削除中にエラーが発生しました: {e}")
-    
+            if os.path.isfile(total_audio): os.remove(total_audio); print(f"Deleted: {total_audio}")
+            elif os.path.isdir(total_audio): process.delete_files_in_directory(total_audio); print(f"Cleared dir: {total_audio}")
+        except Exception as e: print(f"Error clearing total_audio path '{total_audio}': {e}")
+    total_audio = ""
+
+    if transcription_text and os.path.exists(transcription_text):
+        try: os.remove(transcription_text); print(f"Deleted: {transcription_text}")
+        except Exception as e: print(f"Error deleting transcription file '{transcription_text}': {e}")
     transcription_text = ""
 
-    return jsonify({"status": "success", "message": "Users reset"}), 200
+    try:
+        transcription_audio_dir = '/tmp/data/transcription_audio'
+        if os.path.isdir(transcription_audio_dir):
+            process.delete_files_in_directory(transcription_audio_dir)
+            print(f"Cleared dir: {transcription_audio_dir}")
+    except Exception as e: print(f"Error clearing transcription_audio directory: {e}")
+
+    return jsonify({"status": "success", "message": "Selected users and temporary analysis files have been reset."}), 200
 
+
+# 選択されたファイルのコピー (ダウンロード)
 @app.route('/copy_selected_files', methods=['POST'])
 def copy_selected_files():
+    # このエンドポイントの目的が不明瞭（どこにコピーするのか？）
+    # もしクライアント側でダウンロードさせたいなら、ファイルリストを返す方が適切かもしれない
+    # ここでは指定された名前のファイルを /tmp/data/selected_audio にダウンロードする実装とする
     try:
         data = request.get_json()
-        if not data or "names" not in data:
-            return jsonify({"error": "namesパラメータが存在しません"}), 400
+        if not data or "names" not in data or not isinstance(data["names"], list):
+            return jsonify({"error": "リクエストボディに 'names' 配列がありません"}), 400
+
+        names_to_copy = data["names"]
+        if not names_to_copy:
+             return jsonify({"status": "warning", "message": "No names provided for copying."}), 200
 
-        names = data["names"]
-        dest_dir = "/tmp/data/selected_audio"  # コピー先のフォルダ
+        dest_dir = "/tmp/data/selected_audio"  # コピー先 (サーバー上の一時フォルダ)
         os.makedirs(dest_dir, exist_ok=True)
+        print(f"Copying selected files to server directory: {dest_dir}")
 
         copied_files = []
-        for name in names:
+        errors = []
+        for name in names_to_copy:
+            if not name: continue
             dest_path = os.path.join(dest_dir, f"{name}.wav")
             try:
-                # クラウドから直接ダウンロード
                 download_from_cloud(f"{name}.wav", dest_path)
                 copied_files.append(name)
-                print(f"{name}.wav を {dest_path} にダウンロードしました。")
+                print(f"Downloaded '{name}.wav' to {dest_path}")
             except Exception as e:
-                print(f"ダウンロード中にエラーが発生しました: {e}")
-                continue
-
-        return jsonify({"status": "success", "copied": copied_files}), 200
+                error_msg = f"Failed to download '{name}': {str(e)}"
+                print(error_msg)
+                errors.append({"name": name, "error": str(e)})
+                # エラーがあっても続行
+
+        if errors:
+            return jsonify({
+                "status": "partial_success" if copied_files else "error",
+                "message": f"Copied {len(copied_files)} files. Some errors occurred.",
+                "copied": copied_files,
+                "errors": errors,
+                "destination_directory": dest_dir # 参考情報
+                }), 207 # Multi-Status
+        else:
+            return jsonify({
+                "status": "success",
+                "message": f"Successfully copied {len(copied_files)} files.",
+                "copied": copied_files,
+                "destination_directory": dest_dir
+                }), 200
 
     except Exception as e:
-        print("Error in /copy_selected_files:", str(e))
-        return jsonify({"error": "サーバー内部エラー", "details": str(e)}), 500
+        print(f"Error in /copy_selected_files: {str(e)}")
+        return jsonify({"error": "サーバー内部エラーが発生しました", "details": str(e)}), 500
+
 
-@app.route('/clear_tmp', methods=['GET'])
+# 一時フォルダクリアエンドポイント (注意して使用)
+@app.route('/clear_tmp', methods=['POST']) # GETよりPOST/DELETEが適切
 def clear_tmp():
+    # このエンドポイントはサーバー上の /tmp/data を再帰的に削除するため、非常に危険
+    # 実行すると、処理中のファイルも含めてす��て消える可能性がある
+    # 使用は慎重に行うべき
+    tmp_root_dir = "/tmp/data"
+    print(f"WARNING: Received request to clear directory: {tmp_root_dir}")
+    if not os.path.isdir(tmp_root_dir):
+         return jsonify({"status": "warning", "message": f"Directory not found, nothing to clear: {tmp_root_dir}"}), 200
+
     try:
-        tmp_dir = "/tmp/data"  # アプリケーションが使用しているtmpフォルダ
-        # ファイルのみの削除
-        process.delete_files_in_directory(tmp_dir)
-        # フォルダがあれば再帰的に削除
-        for item in os.listdir(tmp_dir):
-            item_path = os.path.join(tmp_dir, item)
-            if os.path.isdir(item_path):
-                shutil.rmtree(item_path)
-                print(f"ディレクトリを削除しました: {item_path}")
-
-        return jsonify({"status": "success", "message": "tmp配下がすべて削除されました"}), 200
+        # 安全のため、特定のサブディレクトリのみを対象にする方が良いかもしれない
+        # 例: subdirs_to_clear = ['uploads', 'base_audio', 'selected_audio', 'transcription_audio']
+        # for subdir_name in subdirs_to_clear:
+        #     subdir_path = os.path.join(tmp_root_dir, subdir_name)
+        #     if os.path.isdir(subdir_path):
+        #         shutil.rmtree(subdir_path)
+        #         print(f"Removed directory: {subdir_path}")
+
+        # 現在の実装: /tmp/data 直下のファイルとディレクトリをすべて削除
+        deleted_items = []
+        errors = []
+        for item_name in os.listdir(tmp_root_dir):
+            item_path = os.path.join(tmp_root_dir, item_name)
+            try:
+                if os.path.isfile(item_path) or os.path.islink(item_path):
+                    os.unlink(item_path)
+                    deleted_items.append(item_name)
+                    print(f"Deleted file/link: {item_path}")
+                elif os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+                    deleted_items.append(item_name + "/") # ディレクトリを示す
+                    print(f"Deleted directory: {item_path}")
+            except Exception as e:
+                error_msg = f"Failed to delete '{item_name}': {str(e)}"
+                print(error_msg)
+                errors.append({"item": item_name, "error": str(e)})
+
+        if errors:
+             return jsonify({
+                 "status": "partial_success",
+                 "message": f"Cleared some items in {tmp_root_dir}, but errors occurred.",
+                 "deleted_items": deleted_items,
+                 "errors": errors
+                 }), 207
+        else:
+             return jsonify({
+                 "status": "success",
+                 "message": f"Successfully cleared contents of {tmp_root_dir}",
+                 "deleted_items": deleted_items
+                 }), 200
 
     except Exception as e:
-        print("Error in /clear_tmp:", str(e))
-        return jsonify({"error": "サーバー内部エラー", "details": str(e)}), 500
+        print(f"Error in /clear_tmp: {str(e)}")
+        return jsonify({"error": "サーバー内部エラーが発生しました", "details": str(e)}), 500
+
 
+# ベース音声アップロード (ユーザー登録)
 @app.route('/upload_base_audio', methods=['POST'])
 def upload_base_audio():
-    global all_users
-    
+    global all_users # 登録後にリストを更新するため
+
     try:
         data = request.get_json()
         if not data or 'audio_data' not in data or 'name' not in data:
-            return jsonify({"error": "音声データまたは名前がありません"}), 400
-        name = data['name']
-        print(f"登録名: {name}")
-        
-        # GASのアップロードエンドポイントにリクエスト
+            return jsonify({"error": "音声データ(audio_data)または名前(name)がありません"}), 400
+
+        name = data['name'].strip() # 前後の空白を除去
+        if not name:
+            return jsonify({"error": "名前が空です"}), 400
+        # TODO: 名前に使用できない文字（ファイル名として不適切、セキュリティリスクなど）をチェックするバリデーションを追加推奨
+        # 例: if not re.match(r'^[a-zA-Z0-9_-]+$', name): return jsonify({"error": "Invalid characters in name"}), 400
+
+        filename_to_upload = f"{name}.wav"
+        print(f"Base audio upload request for name: {name} (filename: {filename_to_upload})")
+
         payload = {
             "action": "upload",
-            "fileName": f"{name}.wav",
+            "fileName": filename_to_upload,
             "base64Data": data['audio_data']
         }
-        
-        response = requests.post(GAS_URL, json=payload)
-        if response.status_code != 200:
-            return jsonify({"error": "GASアップロードエラー", "details": response.text}), 500
-        
-        res_json = response.json()
-        if res_json.get("status") != "success":
-            return jsonify({"error": "GASアップロード失敗", "details": res_json.get("message")}), 500
-        
-        # 全ユーザーリストを更新
-        update_all_users()
-        
-        return jsonify({"state": "Registration Success!", "driveFileId": res_json.get("fileId")}), 200
-    except Exception as e:
-        print("Error in /upload_base_audio:", str(e))
-        return jsonify({"error": "サーバーエラー", "details": str(e)}), 500
 
-@app.route('/list_base_audio', methods=['GET'])
-def list_base_audio():
-    try:
-        global all_users
-        all_users = update_all_users()
-        return jsonify({"status": "success", "fileNames": all_users}), 200
-    except Exception as e:
-        print("Error in /list_base_audio:", str(e))
-        return jsonify({"error": "サーバーエラー", "details": str(e)}), 500
+        # GASにアップロード実行
+        res_json = _make_gas_request(payload, timeout=60) # アップロードは時間がかかる可能性
 
+        print(f"Successfully uploaded base audio to cloud. File ID: {res_json.get('fileId')}")
+
+        # 全ユーザーリストを更新 (GASに再度問い合わせるのが確実)
+        try:
+            update_all_users()
+        except Exception as update_e:
+            print(f"Warning: Failed to refresh user list after upload: {update_e}")
+            # アップロード自体は成功しているので、警告付きで成功レスポンスを返す
+            return jsonify({
+                "state": "Registration Success (List update may be delayed)",
+                "driveFileId": res_json.get("fileId"),
+                "warning": f"User list update failed: {update_e}"
+                }), 200 # または 201 Created
+
+        return jsonify({"state": "Registration Success!", "driveFileId": res_json.get("fileId")}), 201 # 201 Created がより適切かも
+
+    except base64.binascii.Error as e:
+         print(f"Error decoding base64 audio data: {e}")
+         return jsonify({"error": "無効な音声データ形式です (Base64デコード失敗)"}), 400
+    except (TimeoutError, ConnectionError, ValueError, Exception) as e:
+        error_message = f"Failed to upload base audio for '{name}'."
+        details = str(e)
+        print(f"{error_message} Details: {details}")
+        # GASからのエラーメッセージに 'already exists' が含まれていたら 409 Conflict を返す
+        status_code = 409 if "already exists" in details.lower() else 500
+        return jsonify({"error": error_message, "details": details}), status_code
+
+# === アプリケーションの実行 ===
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 7860))
+    # 本番環境では debug=False に設定すること
+    # host='0.0.0.0' はコンテナなど外部からアクセスする場合に必要
+    print(f"Starting Flask server on host 0.0.0.0 port {port} with debug mode {'ON' if app.debug else 'OFF'}")
     app.run(debug=True, host="0.0.0.0", port=port)