import os
from flask import Flask, request, jsonify
from services.blog_fetcher import fetch_blog_info, fetch_posts
from services.search_api import check_search_exposure
from services.datalab_api import get_keyword_trends
from services.analyzer import analyze_posts
from services.consulting import build_consulting_comments
from services.consulting_real_estate import build_real_estate_consulting
from services.competitor_compare import build_batch_comparison_insights
from services.title_pattern_compare import build_title_pattern_insights
from services.title_ai import generate_ai_titles_for_posts
from services.conversion_score import build_conversion_score
from services.naver_seo_score import build_naver_seo_score
from services.consulting_cta import build_cta_messages
from config import INTERNAL_API_KEY, DEFAULT_POST_LIMIT

print("=" * 100)
print("RUNNING APP FILE:", os.path.abspath(__file__))
print("=" * 100)

app = Flask(__name__)


def validate_api_key(req):
    api_key = req.headers.get("X-Internal-Api-Key", "").strip()
    return api_key == INTERNAL_API_KEY


def run_single_analysis(blog_id: str, limit: int):
    collect_status = "ok"
    collect_error_message = ""

    try:
        blog = fetch_blog_info(blog_id)
        posts = fetch_posts(blog_id, limit)

        if len(posts) == 0:
            collect_status = "empty"
            collect_error_message = "게시글 링크 수집 결과가 0건입니다."

    except Exception as e:
        blog = {
            "blog_id": blog_id,
            "blog_name": "",
            "blog_url": f"https://blog.naver.com/{blog_id}",
        }
        posts = []
        collect_status = "error"
        collect_error_message = str(e)

    search_exposure = []
    search_status = "ok"
    search_error_message = ""

    try:
        search_exposure = check_search_exposure(posts)
    except Exception as e:
        search_status = "error"
        search_error_message = str(e)

    seed_keywords = []
    for post in posts:
        title = (post.get("title") or "").strip()
        if title:
            seed_keywords.append(title)
        if len(seed_keywords) >= 5:
            break

    print("[run_single_analysis] BLOG ID:", blog_id)
    print("[run_single_analysis] POSTS COUNT:", len(posts))
    print("[run_single_analysis] SEED KEYWORDS:", seed_keywords)

    trends = {"results": []}
    trend_status = "ok"
    trend_error_message = ""

    try:
        if not seed_keywords:
            trend_status = "empty"
            trend_error_message = "트렌드 분석용 키워드가 없습니다."
            trends = {"results": []}
        else:
            trends = get_keyword_trends(seed_keywords)

            if not trends.get("results"):
                trend_status = "empty"
                trend_error_message = "DataLab 응답은 성공했지만 트렌드 결과가 비어 있습니다."

    except Exception as e:
        trend_status = "error"
        trend_error_message = str(e)
        trends = {"results": []}

    analysis = analyze_posts(posts, search_exposure, trends)

    title_ai = generate_ai_titles_for_posts(posts, 10)

    conversion = build_conversion_score(posts, analysis)

    naver_seo = build_naver_seo_score(posts, analysis)

    cta_messages = build_cta_messages(posts, analysis)

    consulting = build_consulting_comments(
        analysis=analysis,
        posts=posts,
        search_exposure=search_exposure,
        trends=trends,
        collect_status=collect_status,
        trend_status=trend_status,
    )

    real_estate_consulting = build_real_estate_consulting(
        analysis=analysis,
        posts=posts,
    )

    consulting["comments"] = (
        consulting.get("comments", []) + real_estate_consulting.get("comments", [])
    )[:8]

    consulting["actions"] = (
        consulting.get("actions", []) + real_estate_consulting.get("actions", [])
    )[:6]

    if conversion:
        conversion_summary = conversion.get("summary", "")
        conversion_actions = conversion.get("actions", [])

        if conversion_summary:
            consulting["comments"] = (
                [conversion_summary] + consulting.get("comments", [])
            )[:8]

        if conversion_actions:
            consulting["actions"] = (
                conversion_actions + consulting.get("actions", [])
            )[:6]

    if naver_seo:
        naver_summary = naver_seo.get("summary", "")
        naver_actions = naver_seo.get("actions", [])

        if naver_summary:
            consulting["comments"] = (
                [naver_summary] + consulting.get("comments", [])
            )[:8]

        if naver_actions:
            consulting["actions"] = (
                naver_actions + consulting.get("actions", [])
            )[:6]
        
    if cta_messages:
        consulting["actions"] = (
            cta_messages.get("messages", []) + consulting.get("actions", [])
        )[:8]

    result = {
        "success": True,
        "blog": blog,
        "posts": posts,
        "analysis": analysis,
        "title_ai": title_ai,
        "conversion": conversion,
        "naver_seo": naver_seo,
        "cta_messages": cta_messages,
        "search_exposure": search_exposure,
        "trends": trends,
        "consulting": consulting,
        "collect_status": collect_status,
        "collect_error_message": collect_error_message,
        "search_status": search_status,
        "search_error_message": search_error_message,
        "trend_status": trend_status,
        "trend_error_message": trend_error_message,
    }

    print("[run_single_analysis] RESPONSE STATUS FIELDS:")
    print(" collect_status =", result["collect_status"])
    print(" search_status  =", result["search_status"])
    print(" trend_status   =", result["trend_status"])
    print(" title_ai count =", len(title_ai))
    print(" conversion score =", conversion.get("score", 0))
    print(" naver seo overall =", naver_seo.get("overall_score", 0))

    return result


@app.route("/health", methods=["GET"])
def health():
    return jsonify({"status": "ok"})


@app.route("/analyze", methods=["POST"])
def analyze():
    if not validate_api_key(request):
        return jsonify({"success": False, "message": "인증 실패"}), 403

    try:
        data = request.get_json(silent=True) or {}
        blog_id = (data.get("blog_id") or "").strip()
        limit = int(data.get("limit") or DEFAULT_POST_LIMIT)

        if not blog_id:
            return jsonify({"success": False, "message": "blog_id 값이 필요합니다."}), 400

        result = run_single_analysis(blog_id, limit)
        return jsonify(result)

    except Exception as e:
        print("[/analyze] ERROR:", str(e))
        return jsonify({"success": False, "message": str(e)}), 500


@app.route("/analyze_batch", methods=["POST"])
def analyze_batch():
    if not validate_api_key(request):
        return jsonify({"success": False, "message": "인증 실패"}), 403

    try:
        data = request.get_json(silent=True) or {}
        blog_ids = data.get("blog_ids") or []
        base_blog_id = (data.get("base_blog_id") or "").strip()
        limit = int(data.get("limit") or DEFAULT_POST_LIMIT)

        if not isinstance(blog_ids, list) or not blog_ids:
            return jsonify({"success": False, "message": "blog_ids 값이 필요합니다."}), 400

        results = []

        for blog_id in blog_ids:
            blog_id = str(blog_id).strip()
            if not blog_id:
                continue

            try:
                results.append(run_single_analysis(blog_id, limit))
            except Exception as e:
                results.append({
                    "success": False,
                    "blog": {"blog_id": blog_id},
                    "message": str(e),
                })

        successful = [x for x in results if x.get("success")]
        successful.sort(
            key=lambda x: x.get("analysis", {}).get("final_score", 0),
            reverse=True,
        )

        for rank, item in enumerate(successful, start=1):
            item["analysis"]["compared_rank"] = rank

        comparison_insights = build_batch_comparison_insights(results, base_blog_id)
        title_pattern_insights = build_title_pattern_insights(results, base_blog_id)

        print("[/analyze_batch] SUCCESS COUNT:", len(successful))
        print("[/analyze_batch] BASE BLOG ID:", base_blog_id)
        print("[/analyze_batch] COMPARISON INSIGHTS COUNT:", len(comparison_insights))
        print("[/analyze_batch] TITLE PATTERN INSIGHTS COUNT:", len(title_pattern_insights))

        return jsonify({
            "success": True,
            "results": results,
            "comparison_insights": comparison_insights,
            "title_pattern_insights": title_pattern_insights,
        })

    except Exception as e:
        print("[/analyze_batch] ERROR:", str(e))
        return jsonify({"success": False, "message": str(e)}), 500


if __name__ == "__main__":
    # 운영/관제 모드:
    # debug=True는 Flask reloader가 부모/자식 프로세스를 만들어
    # Server Manager의 PID 추적/ON/OFF 제어가 불안정해질 수 있습니다.
    app.run(
        host="0.0.0.0",
        port=5000,
        debug=False,
        use_reloader=False,
    )