import os
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from fastapi.templating import Jinja2Templates
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from fastapi.middleware.cors import CORSMiddleware
from starlette.requests import Request
from pydantic import BaseModel
import json, os, hmac, hashlib
import logging
from concurrent.futures import ThreadPoolExecutor
import asyncio
import traceback
from services.crm_management.pigeon_cloud.data_utils import change_scraping_info
from services.my_slack.my_slack import send_slack

app = FastAPI(docs_url="/docs", redoc_url="/redoc")
security = HTTPBasic()
current_directory = os.path.dirname(os.path.abspath(__file__))
templates = Jinja2Templates(directory=f"{current_directory}/templates")

# CORS設定
origins = [
    "http://localhost",  # ローカル環境でのフロントエンド
    "https://career.cs-park.jp",  # 本番環境のフロントエンド
    "https://career-staging.cs-park.jp", #ステージング環境のフロントエンド
    "http://127.0.0.1",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,  # 許可するオリジンを指定
    allow_credentials=True,  # Cookieを含むリクエストを許可
    allow_methods=["*"],  # 許可するHTTPメソッド (GET, POSTなど)
    allow_headers=["*"],  # 許可するHTTPヘッダー
)

# スレッドプールの設定
executor = ThreadPoolExecutor(max_workers=3)

#ログ出力の設定
logging.basicConfig(
    level=logging.INFO,  # ログレベル（INFOレベルに変更）
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f'{current_directory}/app.log', mode='a'),  # ファイル出力
        logging.StreamHandler()  # コンソール出力
    ]
)

#app.pyの起動確認用
@app.get("/")
def root():
  return {"message": "Hello, World!(正しく起動しています。)"}
    
# Zoom webhook endpoint
@app.post("/summarize/")
async def summarize_webhook(request: Request):
    try:
        data = await request.json()
        logging.info(f"Received Data : {data}")
        event_type = data.get("event", "")
        
        # Zoom URL validation
        if event_type == "endpoint.url_validation":
            payload = data.get("payload", {})
            plain_token = payload.get("plainToken")
            if plain_token:
                try:
                    SECRET = os.environ.get("ZOOM_SECRET_TOKEN")
                    if not SECRET:
                        logging.error("ZOOM_SECRET_TOKEN environment variable not set")
                        return JSONResponse(status_code=500, content={"error": "Secret token not configured"})
                    
                    # HMAC-SHA256でハッシュ化
                    enc = hmac.new(SECRET.encode(), plain_token.encode(), hashlib.sha256).hexdigest()
                    
                    response_data = {
                        "plainToken": plain_token,
                        "encryptedToken": enc
                    }
                    
                    logging.info(f"URL validation successful - plainToken: {plain_token}")
                    logging.info(f"URL validation response: {response_data}")
                    return JSONResponse(content=response_data)
                    
                except Exception as e:
                    logging.error(f"URL validation error: {str(e)}")
                    return JSONResponse(status_code=500, content={"error": "Validation failed"})
            else:
                logging.error("No plainToken found in payload")
                return JSONResponse(status_code=400, content={"error": "Invalid payload"})
            
        # Webhookイベントの詳細ログを記録
        logging.info(f"=== Zoom Webhook Received ===")
        logging.info(f"Event Type: {event_type}")
        logging.info(f"Full Webhook Data: {data}")
        logging.info(f"Headers: {dict(request.headers)}")
        logging.info(f"=== End Webhook Log ===")
        
        if event_type in ["recording.completed", "recording.transcript_completed"]:
            # 録画完了時の処理をバックグラウンドで実行
            recording_data = data.get("payload", {}).get("object", {})
            download_token = data.get("download_token", "")
            
            logging.info(f"Recording data extracted: {recording_data}")
            logging.info(f"Download token found: {'Yes' if download_token else 'No'}")
            
            # バックグラウンドタスクで処理（download_tokenを渡す）
            asyncio.create_task(process_recording_webhook(recording_data, download_token))
            
            return {"status": "success", "message": "Recording processing started"}
        
        # その他のイベントもログに記録
        logging.info(f"Unhandled event type: {event_type}")
        return {"status": "received", "event": event_type}
    except Exception as e:
        logging.error(f"Webhook processing error: {str(e)}")
        return JSONResponse(
            status_code=500,
            content={"status": "error", "message": "Failed to process webhook"}
        )

async def process_recording_webhook(recording_data, download_token):
    """Webhook受信時のZoom録画処理"""
    try:
        # 録画処理をバックグラウンドで実行
        loop = asyncio.get_event_loop()
        await loop.run_in_executor(executor, process_zoom_recording, recording_data, download_token)
    except Exception as e:
        logging.error(f"Background recording processing error: {str(e)}")

def process_zoom_recording(recording_data, download_token):
    """Zoom録画をVimeoにアップロードしSlackに通知"""
    try:
        from use_cases.zoom.webhook_processor import process_webhook_recording
        process_webhook_recording(recording_data, download_token)
    except Exception as e:
        logging.error(f"Recording processing error: {str(e)}")
        # Slack通知はエラーを避けるために一時的に無効化
        print(f"録画処理エラー: {str(e)}")

@app.exception_handler(Exception)
async def custom_exception_handler(request: Request, exc: Exception):
    error_details = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
    logging.error("Error occurred: %s", error_details)  # エラーログをファイルに記録
    return JSONResponse(
        status_code=500,
        content={
            "message": "An error occurred",
            "error": "Internal Server Error"  # 本番環境では詳細を表示しない
        }
    )

if __name__ == '__main__':
 import uvicorn
 uvicorn.run(app, host="0.0.0.0", port=8074)