# -*- coding: utf-8 -*-

import os
import sys
import json
from playwright.sync_api import sync_playwright

CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
ROOT_DIR = os.path.dirname(CURRENT_DIR)

if ROOT_DIR not in sys.path:
    sys.path.append(ROOT_DIR)

USER_AGENT = (
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
    "AppleWebKit/537.36 (KHTML, like Gecko) "
    "Chrome/136.0.0.0 Safari/537.36"
)


class NaverSchoolApiLogger:
    def __init__(self, article_no, headless=False):
        self.article_no = str(article_no or "").strip()
        self.headless = headless
        self.playwright = None
        self.browser = None
        self.context = None
        self.page = None
        self.article_data = None
        self.detected = []
        self.school_hits = []

    def start(self):
        print("=" * 80)
        print("[BROWSER START]")

        self.playwright = sync_playwright().start()
        self.browser = self.playwright.chromium.launch(
            headless=self.headless,
            args=[
                "--disable-blink-features=AutomationControlled",
                "--no-sandbox",
            ],
        )

        self.context = self.browser.new_context(
            locale="ko-KR",
            viewport={"width": 1365, "height": 900},
            user_agent=USER_AGENT,
        )

        self.page = self.context.new_page()
        self.page.on("response", self.handle_response)

        print("[BROWSER READY]")

    def close(self):
        print("[BROWSER CLOSED]")

        try:
            if self.browser:
                self.browser.close()
        except Exception:
            pass

        try:
            if self.playwright:
                self.playwright.stop()
        except Exception:
            pass

    def build_url(self):
        return "https://new.land.naver.com/complexes?articleNo=" + self.article_no

    def is_json_response(self, response):
        try:
            content_type = response.headers.get("content-type", "")
            return "json" in content_type.lower()
        except Exception:
            return False

    def has_school_keyword(self, data):
        text = json.dumps(data, ensure_ascii=False).lower()

        keywords = [
            "school",
            "education",
            "edu",
            "academy",
            "poi",
            "facility",
            "초등학교",
            "중학교",
            "고등학교",
            "학교",
            "학군",
            "교육",
        ]

        return any(k.lower() in text for k in keywords)

    def handle_response(self, response):
        try:
            url = str(response.url)
            lowered = url.lower()

            if not self.is_json_response(response):
                return

            watch_keywords = [
                "article",
                "complex",
                "hscp",
                "school",
                "education",
                "edu",
                "poi",
                "facility",
                "around",
                "near",
                "map",
                "place",
                "infra",
                "developmentplan",
            ]

            if not any(k in lowered for k in watch_keywords):
                return

            data = response.json()

            print("[API DETECTED]", url)

            if f"/api/articles/{self.article_no}" in lowered:
                self.article_data = data
                print("[ARTICLE API CAPTURED]")

            if self.has_school_keyword(data):
                preview = json.dumps(data, ensure_ascii=False)[:700]
                print("[SCHOOL/EDU KEYWORD FOUND]", url)
                print("[PREVIEW]", preview)

                self.school_hits.append({
                    "url": url,
                    "preview": preview,
                })

            keys = list(data.keys()) if isinstance(data, dict) else []

            self.detected.append({
                "url": url,
                "keys": keys,
            })

        except Exception:
            pass

    def get_article_meta(self):
        if not self.article_data:
            print("[ARTICLE META] not captured")
            return {}

        detail = self.article_data.get("articleDetail") or {}

        meta = {
            "article_no": detail.get("articleNo") or self.article_no,
            "article_name": detail.get("articleName"),
            "hscp_no": detail.get("hscpNo"),
            "complex_no": detail.get("complexNo"),
            "latitude": detail.get("latitude"),
            "longitude": detail.get("longitude"),
            "cortar_no": detail.get("cortarNo"),
            "realtor_id": detail.get("realtorId"),
        }

        print("=" * 80)
        print("[ARTICLE META]")

        for key, value in meta.items():
            print(f"{key}: {value}")

        print("=" * 80)

        return meta

    def try_click_candidates(self):
        candidates = [
            "text=학군",
            "text=학교",
            "text=주변",
            "text=주변시설",
            "text=생활",
            "text=단지정보",
            "text=시설",
            "text=교육",
            "text=교통",
            "button:has-text('학군')",
            "button:has-text('학교')",
            "button:has-text('주변')",
            "button:has-text('주변시설')",
            "a:has-text('학군')",
            "a:has-text('학교')",
            "a:has-text('주변')",
            "a:has-text('주변시설')",
        ]

        print("=" * 80)
        print("[CLICK CANDIDATES START]")

        for selector in candidates:
            try:
                locator = self.page.locator(selector)
                count = locator.count()

                if count <= 0:
                    continue

                print("[CLICK TRY]", selector, "count=", count)

                locator.first.click(force=True, timeout=2500)
                self.page.wait_for_timeout(2500)

            except Exception as e:
                print("[CLICK FAIL]", selector, str(e)[:160])

        print("[CLICK CANDIDATES END]")
        print("=" * 80)

    def try_direct_api_candidates(self, meta):
        hscp_no = meta.get("hscp_no")
        lat = meta.get("latitude")
        lon = meta.get("longitude")
        cortar_no = meta.get("cortar_no")

        candidates = []

        if hscp_no:
            candidates += [
                f"https://new.land.naver.com/api/complexes/{hscp_no}",
                f"https://new.land.naver.com/api/complexes/{hscp_no}/overview",
                f"https://new.land.naver.com/api/complexes/{hscp_no}/schools",
                f"https://new.land.naver.com/api/complexes/{hscp_no}/school",
                f"https://new.land.naver.com/api/complexes/{hscp_no}/facilities",
                f"https://new.land.naver.com/api/complexes/{hscp_no}/around",
            ]

        if lat and lon:
            candidates += [
                f"https://new.land.naver.com/api/poi?lat={lat}&lon={lon}",
                f"https://new.land.naver.com/api/poi/school?lat={lat}&lon={lon}",
                f"https://new.land.naver.com/api/schools?lat={lat}&lon={lon}",
                f"https://new.land.naver.com/api/school?lat={lat}&lon={lon}",
                f"https://new.land.naver.com/api/facility?lat={lat}&lon={lon}",
                f"https://new.land.naver.com/api/facilities?lat={lat}&lon={lon}",
            ]

        if cortar_no:
            candidates += [
                f"https://new.land.naver.com/api/regions/schools?cortarNo={cortar_no}",
                f"https://new.land.naver.com/api/schools?cortarNo={cortar_no}",
            ]

        print("=" * 80)
        print("[DIRECT API CANDIDATES START]")

        for url in candidates:
            try:
                result = self.page.evaluate(
                    """
                    async (url) => {
                        const res = await fetch(url, {
                            method: 'GET',
                            credentials: 'include',
                            headers: {
                                'accept': 'application/json, text/plain, */*'
                            }
                        });

                        const text = await res.text();

                        return {
                            url,
                            status: res.status,
                            contentType: res.headers.get('content-type') || '',
                            text: text.slice(0, 1000)
                        };
                    }
                    """,
                    url,
                )

                print("[DIRECT API]", result.get("status"), url)

                text = result.get("text") or ""

                if any(k in text.lower() for k in [
                    "school",
                    "education",
                    "초등학교",
                    "중학교",
                    "고등학교",
                    "학교",
                ]):
                    print("[DIRECT SCHOOL HIT]", url)
                    print(text[:1000])

            except Exception as e:
                print("[DIRECT API FAIL]", url, str(e)[:160])

        print("[DIRECT API CANDIDATES END]")
        print("=" * 80)

    def print_summary(self):
        print("=" * 80)
        print("[SUMMARY]")
        print("[DETECTED API COUNT]", len(self.detected))
        print("[SCHOOL HIT COUNT]", len(self.school_hits))

        if self.school_hits:
            print("-" * 80)
            print("[SCHOOL HITS]")

            for idx, item in enumerate(self.school_hits, 1):
                print(f"[{idx}] {item['url']}")
                print(item["preview"][:700])
                print("-" * 80)

        print("=" * 80)

    def run(self):
        if not self.article_no:
            raise ValueError("article_no is required")

        self.start()

        try:
            url = self.build_url()
            print("[OPEN]", url)

            self.page.goto(
                url,
                wait_until="commit",
                timeout=30000,
            )

            self.page.wait_for_timeout(7000)

            meta = self.get_article_meta()

            self.try_click_candidates()

            self.page.wait_for_timeout(5000)

            meta = self.get_article_meta()

            self.try_direct_api_candidates(meta)

            self.print_summary()

        finally:
            self.close()


def main():
    import argparse

    parser = argparse.ArgumentParser()

    parser.add_argument(
        "--article-no",
        type=str,
        default="2627920510",
    )

    parser.add_argument(
        "--headless",
        action="store_true",
        help="headless mode",
    )

    args = parser.parse_args()

    logger = NaverSchoolApiLogger(
        article_no=args.article_no,
        headless=args.headless,
    )

    logger.run()


if __name__ == "__main__":
    main()
