import requests
from bs4 import BeautifulSoup
from pathlib import Path
import time

BASE_URL = "https://songseungwon.tistory.com"
PAGES = 12  # 페이지 수

def scrape_tistory_posts():
    """Tistory에서 모든 포스트 URL 추출"""
    posts = []
    for page in range(1, PAGES + 1):
        url = f"{BASE_URL}?page={page}"
        response = requests.get(url)
        soup = BeautifulSoup(response.content, 'html.parser')

        # 포스트 링크 추출
        for link in soup.find_all('a', {'class': 'post-link'}):
            post_url = link.get('href')
            if post_url:
                posts.append(post_url)

        time.sleep(0.5)  # 서버 부하 분산

    return posts

def extract_post_content(url):
    """개별 포스트에서 제목, 날짜, 내용 추출"""
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # 제목 추출
    title = soup.find('h1', {'class': 'title-article'})
    title_text = title.get_text(strip=True) if title else "Untitled"

    # 날짜 추출 (형식: 2025. 6. 10. 18:54)
    date_elem = soup.find('span', {'class': 'date'})
    date_text = date_elem.get_text(strip=True) if date_elem else ""
    date_formatted = convert_date_format(date_text)  # 2025-06-10

    # 본문 추출
    article = soup.find('div', {'class': 'article-view'})

    return {
        'title': title_text,
        'date': date_formatted,
        'content': article,
        'url': url
    }

def convert_date_format(date_str):
    """Tistory 날짜 형식을 Jekyll 형식으로 변환
    2025. 6. 10. 18:54 -> 2025-06-10
    """
    parts = date_str.split('.')
    year = parts[0].strip()
    month = parts[1].strip().zfill(2)
    day = parts[2].strip().zfill(2)
    return f"{year}-{month}-{day}"

def download_images(article, post_id):
    """포스트에서 모든 이미지를 다운로드하고 URL 업데이트"""
    images_dir = Path("assets/images/posts")
    images_dir.mkdir(parents=True, exist_ok=True)

    img_counter = 0
    for img in article.find_all('img'):
        src = img.get('src') or img.get('data-src')
        if not src:
            continue

        try:
            # 이미지 URL 정규화
            img_url = resolve_image_url(src, BASE_URL)
            response = requests.get(img_url, timeout=5)
            response.raise_for_status()

            # 파일 형식 감지
            ext = get_image_extension(img_url, response)
            img_name = f"{post_id}-{img_counter}{ext}"
            img_dest = images_dir / img_name

            # 이미지 저장
            with open(img_dest, 'wb') as f:
                f.write(response.content)

            # 로컬 경로로 업데이트 (중요!)
            img['src'] = f"/assets/images/posts/{img_name}"
            img_counter += 1

        except Exception as e:
            print(f"이미지 다운로드 실패: {img_url} - {e}")
            img.decompose()  # 실패한 이미지 제거

def resolve_image_url(src, base_url):
    """상대경로, CDN URL, 프로토콜 없는 URL 등 처리"""
    if src.startswith('http'):
        return src
    elif src.startswith('//'):
        return 'https:' + src
    elif src.startswith('/'):
        return base_url + src
    else:
        return base_url + '/' + src

def get_image_extension(url, response):
    """Content-Type으로부터 파일 확장자 감지"""
    content_type = response.headers.get('content-type', '').lower()

    type_to_ext = {
        'image/jpeg': '.jpg',
        'image/png': '.png',
        'image/gif': '.gif',
        'image/webp': '.webp'
    }

    for mime_type, ext in type_to_ext.items():
        if mime_type in content_type:
            return ext

    # URL에서 확장자 추출
    path = url.split('?')[0]
    return Path(path).suffix or '.jpg'

from PIL import Image

def compress_to_webp(image_path, quality=85):
    """이미지를 WebP 형식으로 압축"""
    try:
        img = Image.open(image_path)

        # RGBA를 RGB로 변환 (압축률 향상)
        if img.mode in ('RGBA', 'LA', 'P'):
            background = Image.new('RGB', img.size, (255, 255, 255))
            if img.mode == 'P':
                img = img.convert('RGBA')
            background.paste(img, mask=img.split()[-1] if img.mode in ('RGBA', 'LA') else None)
            img = background
        elif img.mode not in ('RGB', 'L'):
            img = img.convert('RGB')

        # WebP로 저장
        webp_path = image_path.with_suffix('.webp')
        img.save(
            webp_path,
            'WEBP',
            quality=quality,
            method=6  # 최대 압축
        )

        # 원본 이미지 삭제
        image_path.unlink()

        return webp_path

    except Exception as e:
        print(f"WebP 압축 실패: {image_path} - {e}")
        return None

from markdownify import markdownify

def convert_to_markdown(article):
    """HTML을 마크다운으로 변환
    이미지 링크 보존이 핵심!
    """
    # 먼저 이미지를 다운로드하고 src를 업데이트
    download_images(article, post_id)

    # 그 후에 마크다운으로 변환
    markdown_content = markdownify(
        str(article),
        heading_style="underlined"
    )

    # 과도한 줄바꿈 정리
    markdown_content = re.sub(r'\n\s*\n\s*\n', '\n\n', markdown_content).strip()

    return markdown_content

def create_jekyll_post(title, date, content, categories, post_id):
    """Jekyll 형식의 포스트 파일 생성"""

    # 파일명 생성 (YYYY-MM-DD-title.md)
    safe_title = re.sub(r'[^\w\s-]', '', title)
    safe_title = re.sub(r'[-\s]+', '-', safe_title)
    filename = f"_posts/{date}-{safe_title}.md"

    # YAML Front Matter
    front_matter = f"""---
layout: post
title: {title}
date: {date}
categories: {categories}
---

"""

    # 포스트 저장
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(front_matter + content)

    return filename

def extract_tistory_categories():
    """Tistory의 모든 카테고리 추출"""
    url = "https://songseungwon.tistory.com/category"
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    categories = {}
    for link in soup.find_all('a', href=True):
        href = link.get('href', '')
        if '/category/' in href:
            text = link.get_text(strip=True)
            if text:
                categories[text] = href

    return categories

def infer_category_from_title(title):
    """포스트 제목에서 카테고리 추론"""
    title_lower = title.lower()

    # 키워드 기반 카테고리 분류
    category_keywords = {
        "Web/JavaScript": ['javascript', 'html', 'css', 'nodejs', 'npm'],
        "ML/DL": ['machine', 'deep', 'learning', 'neural', 'gan', 'xgboost'],
        "Finance": ['주식', 'stock', 'etf', 'bitcoin', 'crypto', '금융', 'finance'],
        "Server/Data/Cloud": ['docker', 'kubernetes', 'elastic', 'gcp', 'cloud'],
        "Quantitative Investment": ['정량', 'quantitative', '매크로', 'macro'],
    }

    for category, keywords in category_keywords.items():
        if any(kw in title_lower for kw in keywords):
            return category

    return "Technology"  # 기본값

def add_category_to_post(post_file, category):
    """포스트의 YAML에 카테고리 추가"""
    with open(post_file, 'r', encoding='utf-8') as f:
        content = f.read()

    # YAML 파싱
    parts = content.split('---', 2)
    front_matter = parts[1]
    body = parts[2]

    # 카테고리 추가
    front_matter = re.sub(
        r'(date: [^\n]+\n)',
        r'\1categories: ["' + category + '"]\n',
        front_matter
    )

    # 저장
    with open(post_file, 'w', encoding='utf-8') as f:
        f.write(f"---{front_matter}---{body}")

def remove_control_characters(text):
    """제어 문자 제거"""
    cleaned = ''.join(
        ch for ch in text
        if ord(ch) >= 32 or ch in '\n\t\r'
    )
    return cleaned.replace('\x00', '')

def clean_filename(filename):
    """연속된 대시 제거"""
    clean = re.sub(r'-{2,}', '-', filename)
    return clean.strip('- ')

# 잘못된 방법 ❌
content = article.get_text()  # 이미지 링크 손실

# 올바른 방법 ✅
# 1단계: 이미지 다운로드 및 src 업데이트
for img in article.find_all('img'):
    # ... 이미지 다운로드
    img['src'] = f"/assets/images/posts/{img_name}"

# 2단계: 마크다운으로 변환 (이미지 링크 보존)
content = markdownify(str(article))

import yaml

def validate_posts():
    """모든 포스트 검증"""
    posts_dir = Path('_posts')
    valid_count = 0
    error_count = 0

    for post_file in posts_dir.glob('*.md'):
        try:
            with open(post_file, 'r', encoding='utf-8') as f:
                content = f.read()

            # YAML 파싱 (문법 체크)
            if content.startswith('---'):
                parts = content.split('---', 2)
                yaml.safe_load(parts[1])

            # 제어 문자 확인
            if any(ord(ch) < 32 and ch not in '\n\t\r' for ch in content):
                print(f"제어 문자 발견: {post_file.name}")
                error_count += 1
                continue

            valid_count += 1

        except Exception as e:
            print(f"오류: {post_file.name} - {e}")
            error_count += 1

    print(f"\n✅ 유효한 포스트: {valid_count}")
    print(f"❌ 오류: {error_count}")

    return valid_count, error_count

import logging

logging.basicConfig(
    filename='migration.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

try:
    # 작업 수행
    pass
except Exception as e:
    logging.error(f"Error: {e}", exc_info=True)