#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
blgpdf: Blogger 月別アーカイブを PDF 化（Playwright → PyMuPDF）
- 例: ./blgpdf 202506 202509  # 2025年6月〜9月を順次処理
- 出力: ./YYYY-MM.pdf
- ロジック:
  1) https://koshix.blogspot.com/YYYY/MM/ を取得
  2) 1日が含まれていない場合のみ「前の投稿」を1回だけ辿る
  3) 各ページを Playwright(Chromium) で PDF 化（背景/JS 完了待ち/自動スクロール）
  4) PyMuPDF で“実質白紙”ページを除去
  5) 1枚に結合し YYYY-MM.pdf へ保存
"""

import argparse
import os
import re
import sys
import time
from pathlib import Path
from urllib.parse import urljoin, urlparse

import fitz  # PyMuPDF
import numpy as np
import requests
from bs4 import BeautifulSoup

# ---- Playwright 同期 API を利用
from playwright.sync_api import sync_playwright


BASE = "https://koshix.blogspot.com"


def yyyymm_iter(start_yyyymm: str, end_yyyymm: str):
    sy = int(start_yyyymm[:4])
    sm = int(start_yyyymm[4:])
    ey = int(end_yyyymm[:4])
    em = int(end_yyyymm[4:])
    y, m = sy, sm
    while (y < ey) or (y == ey and m <= em):
        yield y, m
        m += 1
        if m == 13:
            y += 1
            m = 1


def month_url(year: int, month: int) -> str:
    # あなたのブログ構成に合わせて固定
    return f"{BASE}/{year:04d}/{month:02d}/"


def fetch_html(url: str, timeout=30) -> str:
    headers = {
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15"
    }
    r = requests.get(url, headers=headers, timeout=timeout)
    r.raise_for_status()
    return r.text


def page_contains_day1(html: str, year: int, month: int) -> bool:
    """
    Blogger の記事内 <time datetime="YYYY-MM-DD..."> 等を探索し、
    その月の「1日」が含まれているかを概ね判定。
    """
    soup = BeautifulSoup(html, "html.parser")

    # 1) datetime属性 timeタグ優先
    for t in soup.find_all(["time"]):
        dt = t.get("datetime") or t.get("content")
        if dt and re.match(rf"{year:04d}-{month:02d}-01\b", dt):
            return True

    # 2) microdataなどの meta[itemprop=datePublished] など
    for meta in soup.find_all("meta"):
        if meta.get("itemprop") in ("datePublished", "dateModified"):
            c = meta.get("content", "")
            if re.match(rf"{year:04d}-{month:02d}-01\b", c):
                return True

    # 3) テキストからの素朴拾い（最終手段）
    #   例: "2025年9月1日", "September 1, 2025" など—最低限の日本語表記だけ試す
    jp = f"{year}年{month}月1日"
    if jp in soup.get_text():
        return True

    return False


def find_older_posts_link(html: str, base_url: str) -> str | None:
    """
    「前の投稿(Older posts)」リンクを推定。
    - class="blog-pager-older-link"
    - rel="next"（テーマによる）
    - hrefに "search?updated-max=" を含む
    """
    soup = BeautifulSoup(html, "html.parser")

    # 1) クラス名で
    a = soup.find("a", class_=re.compile(r"blog-pager-older-link"))
    if a and a.get("href"):
        return urljoin(base_url, a["href"])

    # 2) rel=next（テーマによって older を next 扱いする場合がある）
    a = soup.find("a", rel=re.compile(r"\bnext\b", re.I))
    if a and a.get("href"):
        return urljoin(base_url, a["href"])

    # 3) URL パターンで
    for a in soup.find_all("a", href=True):
        href = a["href"]
        if "search?updated-max=" in href:
            return urljoin(base_url, href)

    return None


def html_to_pdf_with_playwright(url: str, pdf_path: Path, verbose=False):
    """
    Playwright(Chromium) で
    - 完全ロード待ち (networkidle)
    - Lazy Load 対策の自動スクロール
    - 背景印刷込み
    でPDF化
    """
    if verbose:
        print(f"[playwright] rendering -> {pdf_path.name}")

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True, args=["--no-sandbox"])
        context = browser.new_context()
        page = context.new_page()
        page.set_default_timeout(60000)  # 60s

        page.goto(url, wait_until="networkidle")

        # 連続スクロールで Lazy Load をほぼ出し切る
        last_height = 0
        for _ in range(30):  # 最大30回
            page.evaluate("window.scrollTo(0, document.body.scrollHeight);")
            time.sleep(0.5)
            new_height = page.evaluate("document.body.scrollHeight")
            if new_height == last_height:
                break
            last_height = new_height

        # 追加のアイドル待ち
        try:
            page.wait_for_load_state("networkidle", timeout=5000)
        except Exception:
            pass

        # PDF 出力
        page.pdf(
            path=str(pdf_path),
            print_background=True,
            format="A4",
            margin={"top": "10mm", "right": "10mm", "bottom": "10mm", "left": "10mm"},
            scale=1.0,
        )

        context.close()
        browser.close()


def is_near_white_pixmap(pix, white_tolerance=3, white_ratio_threshold=0.997):
    """
    PyMuPDF pixmap → “ほぼ白紙”判定。
    - white_tolerance: 255 からの許容差 (0〜3 推奨)
    - white_ratio_threshold: これ以上が白比率なら白紙扱い
    """
    # pix.samples は bytes
    arr = np.frombuffer(pix.samples, dtype=np.uint8)
    ncomp = pix.n  # 3 or 4 (RGB or RGBA)
    if ncomp < 3:
        return False

    arr = arr.reshape((pix.height, pix.width, ncomp))
    rgb = arr[:, :, :3]
    # “かなり白”判定
    near_white = (rgb >= (255 - white_tolerance)).all(axis=2)
    white_ratio = near_white.mean()
    return white_ratio >= white_ratio_threshold


def scrub_blank_pages(in_pdf: Path, out_pdf: Path, dpi=110, verbose=False):
    """
    PDF 内の“実質白紙”ページを削除して保存。
    - DPI は高すぎるとノイズを拾いがち。100〜120程度が実測安定。
    """
    if verbose:
        print(f"[scrub] {in_pdf.name} -> remove blank pages")

    src = fitz.open(in_pdf)
    keep = []

    # 全ページ走査
    for i in range(len(src)):
        page = src[i]
        # ラスタライズ
        mat = fitz.Matrix(dpi / 72.0, dpi / 72.0)
        pix = page.get_pixmap(matrix=mat, alpha=False)
        if is_near_white_pixmap(pix):
            # 白紙 ⇒ スキップ
            continue
        keep.append(i)

    # すべて白紙なら空PDFに
    if not keep:
        # 1ページも残らなければ“薄い文字”を見逃した可能性があるので保険で1ページだけ残す
        if len(src) > 0:
            keep = [0]

    # 書き出し
    dst = fitz.open()
    for i in keep:
        dst.insert_pdf(src, from_page=i, to_page=i)
    dst.save(out_pdf)
    dst.close()
    src.close()


def merge_pdfs(pdf_paths, out_pdf: Path, verbose=False):
    if verbose:
        print(f"[merge] {out_pdf.name} <= {[p.name for p in pdf_paths]}")
    dst = fitz.open()
    for p in pdf_paths:
        if not p.exists() or p.stat().st_size == 0:
            continue
        src = fitz.open(p)
        dst.insert_pdf(src)
        src.close()
    dst.save(out_pdf)
    dst.close()


def process_one_month(year: int, month: int, outdir: Path, workdir: Path, verbose=False):
    url1 = month_url(year, month)
    html1 = fetch_html(url1)
    need_older = not page_contains_day1(html1, year, month)

    url2 = None
    if need_older:
        url2 = find_older_posts_link(html1, url1)

    if verbose:
        print(f"[month] {year}-{month:02d} url1={url1} need_older={need_older} url2={url2}")

    # 1ページ目→PDF
    pdf1_raw = workdir / f"{year}-{month:02d}-p1-raw.pdf"
    pdf1 = workdir / f"{year}-{month:02d}-p1.pdf"
    html_to_pdf_with_playwright(url1, pdf1_raw, verbose=verbose)
    scrub_blank_pages(pdf1_raw, pdf1, verbose=verbose)

    pdfs_to_merge = [pdf1]

    # 2ページ目（必要なときだけ）
    if url2:
        pdf2_raw = workdir / f"{year}-{month:02d}-p2-raw.pdf"
        pdf2 = workdir / f"{year}-{month:02d}-p2.pdf"
        html_to_pdf_with_playwright(url2, pdf2_raw, verbose=verbose)
        scrub_blank_pages(pdf2_raw, pdf2, verbose=verbose)
        pdfs_to_merge.append(pdf2)

    # 連結 → 最終ファイル名
    out_pdf = outdir / f"{year:04d}-{month:02d}.pdf"
    merge_pdfs(pdfs_to_merge, out_pdf, verbose=verbose)

    # 作業ファイル削除（必要ならコメントアウト）
    for p in [pdf1_raw, pdf1] + ([pdf2_raw, pdf2] if url2 else []):
        try:
            p.unlink()
        except Exception:
            pass

    if verbose:
        print(f"[done] {out_pdf}")


def main():
    ap = argparse.ArgumentParser(description="Blogger 月次 PDF アーカイブ（Playwright 版）")
    ap.add_argument("start_yyyymm", help="開始 (YYYYMM)")
    ap.add_argument("end_yyyymm", help="終了 (YYYYMM)")
    ap.add_argument("--outdir", default=".", help="出力先ディレクトリ（既定: カレント）")
    ap.add_argument("-v", "--verbose", action="store_true", help="詳細ログ")
    args = ap.parse_args()

    # 引数整形
    s = re.fullmatch(r"(\d{6})", args.start_yyyymm)
    e = re.fullmatch(r"(\d{6})", args.end_yyyymm)
    if not (s and e):
        print("start_yyyymm / end_yyyymm は YYYYMM 形式で指定してください。", file=sys.stderr)
        sys.exit(1)

    outdir = Path(args.outdir).expanduser().resolve()
    outdir.mkdir(parents=True, exist_ok=True)
    workdir = outdir / ".blgpdf_tmp"
    workdir.mkdir(exist_ok=True)

    try:
        for y, m in yyyymm_iter(args.start_yyyymm, args.end_yyyymm):
            process_one_month(y, m, outdir=outdir, workdir=workdir, verbose=args.verbose)
    finally:
        # 作業ディレクトリを空なら削除
        try:
            if workdir.exists() and not any(workdir.iterdir()):
                workdir.rmdir()
        except Exception:
            pass


if __name__ == "__main__":
    main()