#!/usr/bin/env python3
"""
Argos QA Tester - Naver Blog Keyword Analysis DEFINITIVE Test
Confirmed: API endpoint is /api/naver-blog/keyword-analysis (POST)
Response includes: relKeyword, monthlyPcQcCnt, monthlyMobileQcCnt, compIdx, etc.
Table columns: 키워드, PC 검색량, 모바일 검색량, PC CTR, 모바일 CTR, CPC, 경쟁도
Sorting supported on all columns.
Keyword selection by clicking rows (max 5).
"""

import time
from playwright.sync_api import sync_playwright

SCREENSHOT_DIR = "/home/jay/workspace/memory/reports/task-1933-screenshots"
BASE_URL = "http://localhost:8000/dashboard/"

results = []
api_calls = []

def log_result(status, test_name, detail=""):
    icon = {"PASS": "[PASS]", "FAIL": "[FAIL]", "WARN": "[WARN]"}.get(status, "[INFO]")
    msg = f"{icon} {test_name}"
    if detail:
        msg += f" — {detail}"
    print(msg)
    results.append({"status": status, "test": test_name, "detail": detail})

def run_tests():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(viewport={"width": 1440, "height": 900})
        page = context.new_page()

        # Capture API calls
        def on_request(req):
            if "naver-blog" in req.url or "keyword" in req.url.lower():
                api_calls.append({"type": "req", "method": req.method, "url": req.url})
                print(f"    [REQ] {req.method} {req.url}")

        def on_response(res):
            if "naver-blog" in res.url:
                api_calls.append({"type": "res", "status": res.status, "url": res.url})
                print(f"    [RES] {res.status} {res.url}")

        page.on("request", on_request)
        page.on("response", on_response)

        # ── TEST 1: Navigate ──────────────────────────────────────────────────
        print("\n=== TEST 1: Navigate to http://localhost:8000/dashboard/ ===")
        page.goto(BASE_URL, wait_until="domcontentloaded")
        page.wait_for_timeout(5000)
        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_01_loaded.png")
        title = page.title()
        log_result("PASS", "Dashboard navigation",
                   f"URL: {page.url} | Title: {title}")

        # ── TEST 2: Click 네이버블로그 tab ────────────────────────────────────
        print("\n=== TEST 2: Click 네이버블로그 tab button ===")
        tab = page.locator("button:has-text('네이버블로그')").first
        tab.wait_for(state="visible", timeout=5000)
        tab.click()
        page.wait_for_timeout(3000)
        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_02_naver_tab.png")
        # Verify tab is active
        tab_active = page.locator("button:has-text('네이버블로그')").first
        log_result("PASS", "Click 네이버블로그 tab",
                   "Tab clicked, 3s wait for rendering complete")

        # ── TEST 3: Verify 키워드 분석 step UI ───────────────────────────────
        print("\n=== TEST 3: Verify Step 0 — 키워드 분석 UI ===")
        # Check step indicator shows 0 active
        step0 = page.locator("text=키워드 분석")
        if step0.count() > 0:
            log_result("PASS", "Step 0 '키워드 분석' visible")
        else:
            log_result("WARN", "Step 0 '키워드 분석'", "Text not found in page")

        # Check input exists
        inp = page.locator("input[placeholder*='키워드를 입력하세요']").first
        if inp.is_visible(timeout=2000):
            placeholder = inp.get_attribute("placeholder")
            log_result("PASS", "Keyword input field",
                       f"placeholder: '{placeholder}'")
        else:
            log_result("FAIL", "Keyword input field", "Not visible")

        # Check 분석 button exists
        btn = page.locator("button:has-text('분석')").first
        if btn.is_visible(timeout=2000):
            log_result("PASS", "분석 button present")
        else:
            log_result("FAIL", "분석 button", "Not visible")

        # ── TEST 4: Type '실손보험' ────────────────────────────────────────────
        print("\n=== TEST 4: Type '실손보험' into keyword input ===")
        inp.click()
        inp.press("Control+a")
        inp.fill("실손보험")
        val = inp.input_value()
        if "실손보험" in val:
            log_result("PASS", "Type keyword '실손보험'", f"Confirmed input value: '{val}'")
        else:
            log_result("FAIL", "Type keyword '실손보험'", f"Unexpected value: '{val}'")
        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_03_keyword_typed.png")

        # ── TEST 5: Click 분석 button ─────────────────────────────────────────
        print("\n=== TEST 5: Click 분석 button ===")
        # Verify input still has keyword
        val_before = inp.input_value()
        print(f"  Input value before click: '{val_before}'")
        btn.click()
        log_result("PASS", "Click 분석 button",
                   f"Clicked with input='{val_before}'")
        page.wait_for_timeout(1000)
        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_04_after_click.png")

        # ── TEST 6: Wait up to 30s for results ───────────────────────────────
        print("\n=== TEST 6: Wait for results (up to 30s, polling every 2s) ===")
        result_found = False
        error_found = False
        error_text = ""

        for attempt in range(15):
            time.sleep(2)
            elapsed = (attempt + 1) * 2
            print(f"  [{elapsed}s] Attempt {attempt+1}/15...")

            # Check for loading spinner
            loading_txt = False
            try:
                body = page.locator("body").inner_text(timeout=500)
                if "분석 중" in body:
                    print("    (분석 중 - still loading)")
                    loading_txt = True
            except Exception:
                pass

            # Check for the results table (appears when results != null in React state)
            try:
                tables = page.locator("table")
                tc = tables.count()
                if tc > 0 and tables.first.is_visible(timeout=300):
                    # Verify it's the keyword results table
                    tbl_text = tables.first.inner_text(timeout=500)
                    # The table should have keyword column content
                    if any(t in tbl_text for t in ["키워드", "검색량", "경쟁", "CTR"]):
                        result_found = True
                        row_count = page.locator("tbody tr").count()
                        log_result("PASS", "Results table appeared",
                                   f"Table visible at {elapsed}s, {row_count} rows, {tc} table(s)")
                        break
            except Exception as e:
                pass

            # Check for keyword data in page text
            try:
                body = page.locator("body").inner_text(timeout=500)
                # Look for keyword result data
                if "연관 키워드 분석 결과" in body or "개 키워드" in body:
                    result_found = True
                    log_result("PASS", "Keyword analysis results section",
                               f"'연관 키워드 분석 결과' found at {elapsed}s")
                    break
                # Check for selection area that appears with results
                if "선택한 키워드 순위" in body:
                    result_found = True
                    log_result("PASS", "Keyword selection UI appeared",
                               f"'선택한 키워드 순위' found at {elapsed}s")
                    break
            except Exception:
                pass

            # Check for error in the keyword input area (NOT history)
            try:
                # Error appears as red div below input area
                error_div = page.locator(".bg-red-50").first
                if error_div.is_visible(timeout=200):
                    err_txt = error_div.inner_text(timeout=300)
                    if err_txt.strip() and "실패" in err_txt or "오류" in err_txt:
                        error_found = True
                        error_text = err_txt.strip()
                        log_result("FAIL", "Keyword analysis error displayed",
                                   f"Error at {elapsed}s: '{error_text[:200]}'")
                        break
            except Exception:
                pass

        # ── TEST 7: Screenshot of results ────────────────────────────────────
        print("\n=== TEST 7: Screenshot of results ===")
        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_05_results.png")
        print(f"  Saved: 03_keyword_05_results.png")
        log_result("PASS", "Results screenshot taken", "03_keyword_05_results.png")

        # ── TEST 8: Table content check ───────────────────────────────────────
        if result_found:
            print("\n=== TEST 8: Check results table content ===")

            tables = page.locator("table")
            tc = tables.count()
            print(f"  Tables on page: {tc}")

            if tc > 0:
                # Check column headers
                hdrs = page.locator("th").all_text_contents()
                print(f"  Column headers: {hdrs}")

                expected_cols = {"키워드", "PC 검색량", "모바일 검색량", "경쟁도"}
                found_cols = {h.strip() for h in hdrs if h.strip() in expected_cols}
                missing_cols = expected_cols - {h.strip() for h in hdrs}

                if len(found_cols) >= 3:
                    log_result("PASS", "Expected keyword data columns",
                               f"Found: {found_cols}")
                else:
                    log_result("WARN", "Keyword data columns partial",
                               f"Found: {found_cols}, Missing: {missing_cols}")

                # Check row count
                row_count = page.locator("tbody tr").count()
                if row_count > 0:
                    log_result("PASS", "Results table has data",
                               f"{row_count} keyword rows")
                else:
                    log_result("FAIL", "Results table rows",
                               f"0 rows found (table headers: {hdrs[:5]})")

                # ── TEST 9: Column header sorting ─────────────────────────────
                print("\n=== TEST 9: Test column header sorting ===")
                sort_tests_done = 0
                for i, hdr_txt in enumerate(hdrs[:6]):
                    hdr_txt = hdr_txt.strip()
                    if not hdr_txt:
                        continue
                    try:
                        hdr_elem = page.locator("th").nth(i)
                        if hdr_elem.is_visible(timeout=300):
                            hdr_elem.click()
                            page.wait_for_timeout(800)
                            # Check sort indicator appeared
                            updated_hdr = hdr_elem.inner_text(timeout=300)
                            sort_indicator = "▼" in updated_hdr or "▲" in updated_hdr
                            if sort_indicator:
                                log_result("PASS", f"Sort by '{hdr_txt}'",
                                           f"Sort indicator visible: '{updated_hdr}'")
                            else:
                                log_result("WARN", f"Sort by '{hdr_txt}'",
                                           "Clicked but no sort indicator")
                            sort_tests_done += 1
                    except Exception as e:
                        log_result("WARN", f"Sort click '{hdr_txt}'", str(e))
                    if sort_tests_done >= 2:
                        break

                page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_06_after_sort.png")
                print(f"  Screenshot: 03_keyword_06_after_sort.png")

                # ── TEST 10: Row click (keyword selection) ────────────────────
                print("\n=== TEST 10: Click keyword rows for selection ===")
                rows = page.locator("tbody tr")
                rc = rows.count()
                clicks_done = 0

                if rc > 0:
                    for i in range(min(rc, 3)):
                        try:
                            row = rows.nth(i)
                            row_text = row.inner_text(timeout=300)
                            row.click()
                            page.wait_for_timeout(500)
                            # Check if selection UI updated
                            body_txt = page.locator("body").inner_text(timeout=500)
                            if "선택한 키워드 순위" in body_txt:
                                # Check count updated
                                log_result("PASS", f"Select keyword row {i+1}",
                                           f"Row text: '{row_text[:40].strip()}'")
                                clicks_done += 1
                        except Exception as e:
                            log_result("WARN", f"Click row {i+1}", str(e))

                    if clicks_done > 0:
                        log_result("PASS", "Keyword row selection working",
                                   f"Successfully selected {clicks_done} keywords")
                    else:
                        log_result("WARN", "Keyword row selection", "No rows clickable")
                else:
                    log_result("WARN", "Keyword row click", "No tbody rows to click")

                page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_07_after_selection.png")
                print(f"  Screenshot: 03_keyword_07_after_selection.png")

                # Check selected keywords counter
                try:
                    body_txt = page.locator("body").inner_text(timeout=500)
                    if "/5개 선택" in body_txt:
                        sel_match = [line for line in body_txt.split("\n") if "/5개 선택" in line]
                        log_result("PASS", "Selection counter visible",
                                   f"Counter: {sel_match[0].strip() if sel_match else 'found'}")
                    else:
                        log_result("WARN", "Selection counter", "'/5개 선택' not found")
                except Exception as e:
                    log_result("WARN", "Selection counter check", str(e))

        elif error_found:
            print(f"\n=== ERROR: Keyword analysis failed ===")
            print(f"  Error: {error_text}")
            # Still take screenshots
            page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_06_error.png")
        else:
            # Results not found and no error - investigate
            print("\n=== [INVESTIGATION] No results and no error after 30s ===")

            # Check if API was called at all
            analyze_calls = [c for c in api_calls if "keyword-analysis" in c.get("url", "")]
            if analyze_calls:
                print(f"  keyword-analysis API was called: {len(analyze_calls)} times")
                for c in analyze_calls:
                    print(f"    {c}")
            else:
                log_result("FAIL", "keyword-analysis API never called",
                           "Button click did not trigger API request")

            # Final page text
            try:
                body = page.locator("body").inner_text(timeout=1000)
                if "실손보험" in body:
                    idx = body.find("실손보험")
                    ctx = body[max(0, idx-50):idx+150]
                    print(f"  '실손보험' context: {repr(ctx)}")
                else:
                    print("  '실손보험' NOT found in page body text")
                    print(f"  Body sample: {body[:400]}")
            except Exception as e:
                print(f"  Could not read body: {e}")

            log_result("FAIL", "No keyword results appeared",
                       "30s timeout with no results or error")

        # ── API Call Summary ──────────────────────────────────────────────────
        print("\n=== API CALL SUMMARY ===")
        naver_calls = [c for c in api_calls if "naver-blog" in c.get("url", "")]
        analyze_api = [c for c in naver_calls if "keyword-analysis" in c.get("url", "")]
        if analyze_api:
            for c in analyze_api:
                s = c.get("status", "")
                status_str = f"HTTP {s}" if s else ""
                ok_fail = "OK" if isinstance(s, int) and s < 400 else ("ERR" if s else "")
                print(f"  [{ok_fail}] {c.get('method','REQ')} {c['url']} {status_str}")
            api_errors = [c for c in analyze_api if isinstance(c.get("status"), int) and c["status"] >= 400]
            if api_errors:
                log_result("FAIL", "keyword-analysis API errors",
                           f"{len(api_errors)} failed calls")
            else:
                log_result("PASS", "keyword-analysis API called successfully",
                           f"{len(analyze_api)} call(s)")
        else:
            log_result("WARN", "No keyword-analysis API calls captured")

        page.screenshot(path=f"{SCREENSHOT_DIR}/03_keyword_08_final.png")
        print(f"\n  Final screenshot: 03_keyword_08_final.png")
        browser.close()

    # ── FINAL REPORT ─────────────────────────────────────────────────────────
    print("\n" + "="*65)
    print("  ARGOS QA REPORT: 네이버블로그 Keyword Analysis")
    print("="*65)
    pass_c = sum(1 for r in results if r["status"] == "PASS")
    fail_c = sum(1 for r in results if r["status"] == "FAIL")
    warn_c = sum(1 for r in results if r["status"] == "WARN")
    print(f"\n  PASS: {pass_c}  |  FAIL: {fail_c}  |  WARN: {warn_c}  |  TOTAL: {len(results)}\n")
    print("-"*65)
    for r in results:
        icon = {"PASS": "[PASS]", "FAIL": "[FAIL]", "WARN": "[WARN]"}.get(r["status"], "[?]")
        print(f"  {icon} {r['test']}")
        if r["detail"]:
            for dl in r["detail"].split("\n")[:2]:
                if dl.strip():
                    print(f"           {dl.strip()[:100]}")
    print("="*65)

if __name__ == "__main__":
    run_tests()
