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

import os
import re
import json
import time
import random
import requests


BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DEBUG_DIR = os.path.join(BASE_DIR, "debug_outputs")

os.makedirs(DEBUG_DIR, exist_ok=True)


HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/124.0.0.0 Safari/537.36"
    ),
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8",
    "Referer": "https://fin.land.naver.com/",
}


def save_file(filename, content):
    path = os.path.join(DEBUG_DIR, filename)

    with open(path, "w", encoding="utf-8") as f:
        f.write(content)

    print("[SAVED]", path)


def request_fin_article(article_no):
    url = f"https://fin.land.naver.com/articles/{article_no}"

    print("[REQUEST]", url)

    time.sleep(random.uniform(0.8, 1.6))

    try:
        res = requests.get(url, headers=HEADERS, timeout=25)

        print("[STATUS]", res.status_code)
        print("[CONTENT-TYPE]", res.headers.get("content-type"))
        print("[URL]", res.url)
        print("[LENGTH]", len(res.text))

        return res.text

    except Exception as e:
        print("[REQUEST ERROR]", str(e))
        return ""


def find_patterns(html):
    patterns = {
        "article_no": [
            r"articleNo[=:\"'\s]+([0-9]{8,})",
            r"article_no[=:\"'\s]+([0-9]{8,})",
            r"/articles/([0-9]{8,})",
            r"\b([0-9]{10})\b",
        ],
        "realtor_keys": [
            r"officeId[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"officeNo[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"realtorId[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"realtorNo[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"agentId[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"agentNo[=:\"'\s]+([A-Za-z0-9_\-]+)",
            r"cpId[=:\"'\s]+([A-Za-z0-9_\-]+)",
        ],
        "phone_like": [
            r"0\d{1,2}[-.\s]?\d{3,4}[-.\s]?\d{4}",
            r"01\d[-.\s]?\d{3,4}[-.\s]?\d{4}",
        ],
        "api_paths": [
            r"(/api/[A-Za-z0-9_\-/?.=&%]+)",
            r"(https://fin\.land\.naver\.com/api/[A-Za-z0-9_\-/?.=&%]+)",
            r"(https://new\.land\.naver\.com/api/[A-Za-z0-9_\-/?.=&%]+)",
        ],
        "json_script": [
            r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
        ],
    }

    result = {}

    for group, group_patterns in patterns.items():
        found = set()

        for pattern in group_patterns:
            matches = re.findall(pattern, html or "", flags=re.DOTALL)

            for match in matches:
                if isinstance(match, tuple):
                    match = match[0]

                value = str(match).strip()

                if group == "json_script":
                    value = value[:1000]

                found.add(value)

        result[group] = sorted(found)

    return result


def extract_next_data(html):
    m = re.search(
        r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
        html or "",
        flags=re.DOTALL
    )

    if not m:
        return None

    raw = m.group(1).strip()

    try:
        return json.loads(raw)
    except Exception:
        return None


def recursive_find_keys(obj, wanted_keywords, path=""):
    found = []

    if isinstance(obj, dict):
        for k, v in obj.items():
            key_lower = str(k).lower()
            next_path = f"{path}.{k}" if path else str(k)

            if any(word.lower() in key_lower for word in wanted_keywords):
                found.append({
                    "path": next_path,
                    "key": k,
                    "value_preview": str(v)[:300]
                })

            found.extend(recursive_find_keys(v, wanted_keywords, next_path))

    elif isinstance(obj, list):
        for i, item in enumerate(obj):
            found.extend(recursive_find_keys(item, wanted_keywords, f"{path}[{i}]"))

    return found


def main():
    article_no = input("articleNo 입력: ").strip()

    if not article_no:
        print("articleNo가 없습니다.")
        return

    html = request_fin_article(article_no)

    save_file(f"fin_article_{article_no}.html", html[:1000000])

    patterns = find_patterns(html)

    next_data = extract_next_data(html)

    key_report = []

    if next_data:
        save_file(
            f"fin_article_{article_no}_next_data.json",
            json.dumps(next_data, ensure_ascii=False, indent=2)
        )

        key_report = recursive_find_keys(
            next_data,
            [
                "article",
                "realtor",
                "office",
                "agent",
                "phone",
                "tel",
                "name",
                "address",
                "price",
                "complex",
            ]
        )

    report = {
        "article_no": article_no,
        "html_length": len(html),
        "patterns": patterns,
        "has_next_data": next_data is not None,
        "key_report": key_report[:300],
    }

    save_file(
        f"fin_article_{article_no}_report.json",
        json.dumps(report, ensure_ascii=False, indent=2)
    )

    print("=" * 80)
    print("[RESULT]")
    print("HTML LENGTH:", len(html))
    print("HAS NEXT DATA:", next_data is not None)
    print("ARTICLE NO COUNT:", len(patterns.get("article_no", [])))
    print("REALTOR KEY COUNT:", len(patterns.get("realtor_keys", [])))
    print("PHONE COUNT:", len(patterns.get("phone_like", [])))
    print("API PATH COUNT:", len(patterns.get("api_paths", [])))
    print("=" * 80)
    print("debug_outputs 폴더의 report json을 확인하세요.")


if __name__ == "__main__":
    main()