#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import re
import subprocess
import sys
import urllib.parse
import urllib.request
from dataclasses import dataclass
from datetime import date, datetime, timedelta
from html import unescape
from pathlib import Path
from zoneinfo import ZoneInfo

KST = ZoneInfo('Asia/Seoul')
CALENDAR_ID = 'mini.snowoyh@gmail.com'
WORKSPACE = Path('/Users/snowoyh/.openclaw/agents/stock/workspace')
STATE_DIR = WORKSPACE / 'state'
STATE_DIR.mkdir(parents=True, exist_ok=True)
STATE_FILE = STATE_DIR / 'ipo_calendar_sync.json'
CONFIG_PATH = Path('/Users/snowoyh/.openclaw/openclaw.json')
TELEGRAM_ACCOUNT = 'stock'
SUBSCRIPTION_URL = 'https://www.38.co.kr/html/fund/index.htm?o=k'
LISTING_URL = 'https://www.38.co.kr/html/fund/index.htm?o=nw'
NAVER_IPO_API_URL = 'https://stock.naver.com/api/domestic/market/ipo/progress'
SOURCE_LABEL = '네이버페이 증권 IPO'
LISTING_LOOKBACK_DAYS = 14


class IpoParserError(RuntimeError):
    def __init__(self, errors: list[str]):
        self.errors = errors
        super().__init__('IPO 파서 전부 실패: ' + ' | '.join(errors))


@dataclass
class EventSpec:
    kind: str
    name: str
    start_date: date
    end_date: date  # inclusive
    brokers: str
    source_url: str
    source_label: str = SOURCE_LABEL

    @property
    def summary(self) -> str:
        prefix = '[공모청약]' if self.kind == 'subscription' else '[신규상장]'
        return f'{prefix} {self.name}'

    @property
    def description(self) -> str:
        label = '청약일' if self.kind == 'subscription' else '상장일'
        if self.start_date == self.end_date:
            date_str = self.start_date.isoformat()
        else:
            date_str = f'{self.start_date.isoformat()} ~ {self.end_date.isoformat()}'
        return (
            f'종목명: {self.name}\n'
            f'증권사: {self.brokers or "미확인"}\n'
            f'{label}: {date_str}\n'
            f'기준: {self.source_label}\n'
            f'출처: {self.source_url}'
        )

    @property
    def state_key(self) -> str:
        return f'{self.kind}|{self.name}'


def run(cmd: list[str]) -> str:
    p = subprocess.run(cmd, capture_output=True, text=True)
    if p.returncode != 0:
        raise RuntimeError(p.stderr.strip() or p.stdout.strip() or 'command failed')
    return p.stdout


def send_telegram(text: str) -> bool:
    try:
        cfg = json.loads(CONFIG_PATH.read_text())
        acct = cfg['channels']['telegram']['accounts'][TELEGRAM_ACCOUNT]
        token = acct['botToken']
        chat_ids = acct.get('allowFrom') or []
    except Exception as e:
        print(f'telegram cfg load failed: {e}', file=sys.stderr)
        return False
    if not chat_ids:
        print('no telegram chat_ids', file=sys.stderr)
        return False

    url = f'https://api.telegram.org/bot{token}/sendMessage'
    ok = True
    for chat_id in chat_ids:
        body = urllib.parse.urlencode({
            'chat_id': chat_id,
            'text': text[:4000],
            'disable_web_page_preview': 'true',
        }).encode()
        try:
            req = urllib.request.Request(url, data=body, method='POST')
            with urllib.request.urlopen(req, timeout=15) as response:
                if response.status != 200:
                    ok = False
        except Exception as e:
            print(f'telegram send failed: {e}', file=sys.stderr)
            ok = False
    return ok


def fetch(url: str, encoding: str = 'euc-kr') -> str:
    req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
    with urllib.request.urlopen(req, timeout=30) as r:
        raw = r.read()
    if encoding == 'auto':
        # 한글 페이지는 utf-8과 cp949 둘 중 하나 — strict 디코드 성공하는 쪽 사용 (네이버가 메타태그로 거짓말하는 경우 대비)
        for enc in ('utf-8', 'cp949'):
            try:
                return raw.decode(enc)
            except UnicodeDecodeError:
                continue
        return raw.decode('utf-8', errors='ignore')
    return raw.decode(encoding, 'ignore')


def clean_text(html_fragment: str) -> str:
    text = re.sub(r'<br\s*/?>', ' ', html_fragment, flags=re.I)
    text = re.sub(r'<[^>]+>', ' ', text)
    text = unescape(text)
    text = text.replace('\xa0', ' ')
    return re.sub(r'\s+', ' ', text).strip()


def parse_html_rows(table_html: str) -> list[list[str]]:
    rows = []
    for row in re.findall(r'<tr[^>]*>(.*?)</tr>', table_html, re.S | re.I):
        cols = [clean_text(c) for c in re.findall(r'<t[dh][^>]*>(.*?)</t[dh]>', row, re.S | re.I)]
        if cols:
            rows.append(cols)
    return rows


def parse_date_range(text: str) -> tuple[date, date] | None:
    text = text.strip()
    m = re.match(r'(\d{4})\.(\d{2})\.(\d{2})~(\d{2})\.(\d{2})$', text)
    if not m:
        return None
    y, m1, d1, m2, d2 = map(int, m.groups())
    return date(y, m1, d1), date(y, m2, d2)


def _naver_api_rows(payload: dict) -> list[dict]:
    """네이버 IPO progress API의 단계별 배열을 종목 단위로 합친다."""
    list_keys = (
        'examinationList', 'demandForecastingList', 'forecastingCompleteList',
        'subscriptionList', 'subscriptionCompleteList', 'listingList',
    )
    if not isinstance(payload, dict) or not any(key in payload for key in list_keys):
        raise ValueError('네이버 IPO API 스키마 불일치')
    rows: dict[str, dict] = {}
    for key in list_keys:
        items = payload.get(key) or []
        if not isinstance(items, list):
            raise ValueError(f'네이버 IPO API {key} 타입 불일치')
        for item in items:
            if not isinstance(item, dict):
                continue
            code = (item.get('ipoCode') or item.get('itemCode') or '').strip()
            name = (item.get('compName') or item.get('stockName') or '').strip()
            if not code or not name:
                continue
            rows[code] = {**rows.get(code, {}), **item}
    return list(rows.values())


def parse_naver_api_events_from(cutoff: date) -> list[EventSpec]:
    payload = json.loads(fetch(NAVER_IPO_API_URL, encoding='utf-8'))
    events: list[EventSpec] = []
    for info in _naver_api_rows(payload):
        code = info.get('ipoCode') or info.get('itemCode')
        name = (info.get('compName') or info.get('stockName') or '').strip()
        brokers = (info.get('orgNm') or '').strip()
        source_url = f'https://stock.naver.com/ipo/{code}'

        start_raw = (info.get('poStartDate') or '').strip()
        end_raw = (info.get('poEndDate') or '').strip()
        if start_raw and end_raw:
            try:
                start_date = date.fromisoformat(start_raw)
                end_date = date.fromisoformat(end_raw)
            except ValueError:
                pass
            else:
                if end_date >= cutoff:
                    events.append(EventSpec(
                        'subscription', name, start_date, end_date, brokers, source_url
                    ))

        listed_raw = (info.get('lcalDate') or info.get('listingDate') or '').strip()
        if listed_raw:
            try:
                listed_date = date.fromisoformat(listed_raw)
            except ValueError:
                pass
            else:
                if listed_date >= cutoff:
                    events.append(EventSpec(
                        'listing', name, listed_date, listed_date, brokers, source_url
                    ))
    return events


def _table_by_summary(html: str, summary: str) -> str:
    match = re.search(
        r'<table[^>]*summary=["\']' + re.escape(summary) + r'["\'][^>]*>(.*?)</table>',
        html,
        re.S | re.I,
    )
    if not match:
        raise ValueError(f'38커뮤니케이션 테이블 없음: {summary}')
    return match.group(0)


def parse_38_subscription_html(html: str, cutoff: date) -> list[EventSpec]:
    events: list[EventSpec] = []
    for cols in parse_html_rows(_table_by_summary(html, '공모주 청약일정')):
        if len(cols) < 6 or cols[0] == '종목명':
            continue
        parsed = parse_date_range(cols[1])
        if not parsed:
            continue
        start_date, end_date = parsed
        if end_date < cutoff:
            continue
        events.append(EventSpec(
            'subscription', cols[0], start_date, end_date, cols[5], SUBSCRIPTION_URL,
            source_label='38커뮤니케이션 IPO',
        ))
    return events


def parse_38_listing_html(html: str, cutoff: date) -> list[EventSpec]:
    events: list[EventSpec] = []
    for cols in parse_html_rows(_table_by_summary(html, '신규상장종목')):
        if len(cols) < 2 or cols[0] == '기업명':
            continue
        try:
            listed_date = date.fromisoformat(cols[1].replace('/', '-'))
        except ValueError:
            continue
        if listed_date < cutoff:
            continue
        events.append(EventSpec(
            'listing', cols[0], listed_date, listed_date, '', LISTING_URL,
            source_label='38커뮤니케이션 IPO',
        ))
    return events


def parse_38_events_from(cutoff: date) -> list[EventSpec]:
    subscriptions = parse_38_subscription_html(fetch(SUBSCRIPTION_URL), cutoff)
    listing_cutoff = cutoff - timedelta(days=LISTING_LOOKBACK_DAYS)
    listings = parse_38_listing_html(fetch(LISTING_URL), listing_cutoff)
    # 보조 소스는 스팩 종목명이 주 소스와 크게 달라 과거 건을 중복 생성할 수 있다.
    listings = [
        ev for ev in listings
        if ev.start_date == cutoff or '스팩' not in ev.name
    ]
    return subscriptions + listings


def collect_ipo_events(cutoff: date) -> tuple[list[EventSpec], str, list[str]]:
    """네이버 API를 우선 사용하고 실패·0건이면 38 파서로 자동 전환한다.

    네이버 API는 상장 당일 장 시작 후 종목을 listingList에서 제거하므로, 주 파서가
    정상이어도 최근 14일 신규상장을 38 목록으로 보강한다.
    """
    errors: list[str] = []
    try:
        events = parse_naver_api_events_from(cutoff)
    except Exception as e:
        events = []
        errors.append(f'naver_api: {e}')

    parser_used = 'naver_api'
    if not events:
        if not errors:
            errors.append('naver_api: 수집 결과 0건')
        try:
            events = parse_38_events_from(cutoff)
            parser_used = '38_fallback'
        except Exception as e:
            errors.append(f'38_fallback: {e}')
            raise IpoParserError(errors) from e
    else:
        try:
            listing_cutoff = cutoff - timedelta(days=LISTING_LOOKBACK_DAYS)
            recent_listings = parse_38_listing_html(fetch(LISTING_URL), listing_cutoff)
            existing_keys = {ev.state_key for ev in events}
            events.extend(
                ev for ev in recent_listings
                if ev.state_key not in existing_keys
                and ev.start_date <= cutoff
                and (ev.start_date == cutoff or '스팩' not in ev.name)
            )
        except Exception as e:
            errors.append(f'38_same_day: {e}')

    deduped = {ev.state_key: ev for ev in events}
    return list(deduped.values()), parser_used, errors


def load_state() -> dict:
    if STATE_FILE.exists():
        try:
            return json.loads(STATE_FILE.read_text())
        except Exception:
            return {}
    return {}


def save_state(state: dict):
    STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2))


def update_parser_health(
    state: dict,
    status: str,
    errors: list[str],
    total_found: int,
    dry_run: bool = False,
) -> None:
    """파서 상태가 바뀔 때만 알리고, 실패한 발송은 다음 실행에서 재시도한다."""
    now_iso = datetime.now(KST).isoformat()
    previous = state.get('parser_health_status')
    state['parser_health_status'] = status
    state['parser_health_checked_at'] = now_iso
    state['parser_errors'] = errors

    if status == 'healthy':
        state['parser_last_success_at'] = now_iso
    else:
        state['parser_last_failure_at'] = now_iso

    if dry_run:
        return

    message = None
    if status == 'failed' and (
        previous != status or state.get('parser_alerted_status') != status
    ):
        message = (
            '[IPO 일정] 파서 전체 실패\n'
            + '\n'.join(errors)
            + '\n캘린더 동기화를 중단했고 기존 일정은 유지했습니다.'
        )
    elif status == 'degraded' and (
        previous != status or state.get('parser_alerted_status') != status
    ):
        source = '38커뮤니케이션으로 자동 전환했습니다.'
        if not any(error.startswith('naver_api:') for error in errors):
            source = '네이버 주 파서는 정상이며 당일 상장 보강 파서만 실패했습니다.'
        message = (
            '[IPO 일정] 파서 일부 실패\n'
            + '\n'.join(errors)
            + f'\n{source}\n수집 결과: {total_found}건\n기존 일정 자동 삭제는 중지했습니다.'
        )
    elif status == 'healthy' and previous in {'degraded', 'failed'}:
        message = (
            '[IPO 일정] 파서 복구\n'
            f'네이버 IPO API와 당일 상장 보강 파서가 정상입니다.\n수집 결과: {total_found}건'
        )

    if message and send_telegram(message):
        state['parser_alerted_status'] = status
        state['parser_alert_sent_at'] = now_iso


def event_key_from_summary(summary: str) -> tuple[str, str] | None:
    summary = (summary or '').strip()
    if summary.startswith('[공모청약] '):
        return ('subscription', summary.replace('[공모청약] ', '', 1).strip())
    if summary.startswith('[신규상장] '):
        return ('listing', summary.replace('[신규상장] ', '', 1).strip())
    return None


def fetch_existing_events(start_date: date, end_date: date) -> dict[str, dict]:
    start_dt = datetime(start_date.year, start_date.month, start_date.day, 0, 0, tzinfo=KST)
    end_dt = datetime(end_date.year, end_date.month, end_date.day, 0, 0, tzinfo=KST)
    out = run([
        'gog', 'calendar', 'events', CALENDAR_ID,
        '--from', start_dt.isoformat(), '--to', end_dt.isoformat(),
        '--all-pages', '--max', '250', '--json'
    ])
    data = json.loads(out)
    existing: dict[str, list[dict]] = {}
    for ev in data.get('events', []):
        parsed = event_key_from_summary(ev.get('summary', ''))
        if not parsed:
            continue
        kind, name = parsed
        key = f'{kind}|{name}'
        existing.setdefault(key, []).append(ev)
    return existing


def create_event(ev: EventSpec, dry_run: bool = False):
    start_date = ev.start_date.isoformat()
    end_date = (ev.end_date + timedelta(days=1)).isoformat()  # Google Calendar 종일 이벤트는 end가 exclusive
    if dry_run:
        print(json.dumps({'summary': ev.summary, 'date': start_date, 'description': ev.description, 'all_day': True}, ensure_ascii=False))
        return
    run([
        'gog', 'calendar', 'create', CALENDAR_ID,
        '--summary', ev.summary,
        '--description', ev.description,
        '--from', start_date,
        '--to', end_date,
        '--all-day',
        '--event-color', '5' if ev.kind == 'subscription' else '10'
    ])


def update_event(event_id: str, ev: EventSpec, dry_run: bool = False):
    start_date = ev.start_date.isoformat()
    end_date = (ev.end_date + timedelta(days=1)).isoformat()
    if dry_run:
        print(json.dumps({'update_event_id': event_id, 'summary': ev.summary, 'date': start_date, 'description': ev.description, 'all_day': True}, ensure_ascii=False))
        return 'updated'
    try:
        run([
            'gog', 'calendar', 'update', CALENDAR_ID, event_id,
            '--summary', ev.summary,
            '--description', ev.description,
            '--from', start_date,
            '--to', end_date,
            '--all-day',
            '--event-color', '5' if ev.kind == 'subscription' else '10'
        ])
        return 'updated'
    except Exception:
        run(['gog', 'calendar', 'delete', CALENDAR_ID, event_id, '--force', '--no-input'])
        create_event(ev, dry_run=False)
        return 'recreated'


def delete_event(event_id: str, dry_run: bool = False):
    if dry_run:
        print(json.dumps({'delete_event_id': event_id}, ensure_ascii=False))
        return
    run(['gog', 'calendar', 'delete', CALENDAR_ID, event_id, '--force', '--no-input'])


def event_date_range(ev: dict) -> tuple[str, str]:
    start_info = ev.get('start', {})
    end_info = ev.get('end', {})
    start = start_info.get('date') or start_info.get('dateTime', '')[:10]
    end_excl = end_info.get('date') or end_info.get('dateTime', '')[:10]
    end = ''
    if end_excl:
        end = (date.fromisoformat(end_excl) - timedelta(days=1)).isoformat()
    return start, end


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--dry-run', action='store_true')
    args = parser.parse_args()

    cutoff = datetime.now(KST).date()
    state = load_state()
    previous_parser_used = state.get('parser_used')
    try:
        events, parser_used, parser_errors = collect_ipo_events(cutoff)
    except IpoParserError as e:
        update_parser_health(state, 'failed', e.errors, 0, dry_run=args.dry_run)
        state['last_run_at'] = datetime.now(KST).isoformat()
        state['parser_used'] = 'failed'
        if not args.dry_run:
            save_state(state)
        print(json.dumps({
            'cutoff_after': cutoff.isoformat(),
            'parser_used': 'failed',
            'parser_errors': e.errors,
            'total_found': 0,
            'dry_run': args.dry_run,
        }, ensure_ascii=False), file=sys.stderr)
        return 1

    events.sort(key=lambda e: (e.start_date, e.kind, e.name))
    parser_health = 'degraded' if parser_errors else 'healthy'
    update_parser_health(
        state, parser_health, parser_errors, len(events), dry_run=args.dry_run
    )
    state['parser_used'] = parser_used
    if not args.dry_run:
        # 알림 상태를 먼저 저장해 이후 캘린더 작업 실패 시 같은 경보가 반복되지 않게 한다.
        save_state(state)

    end_date = max((ev.end_date for ev in events), default=cutoff) + timedelta(days=1)
    # 사이트 스크래핑 실패 시 모든 일정이 삭제되는 사고 방지 — events 비면 cleanup 스킵
    listing_cutoff = cutoff - timedelta(days=LISTING_LOOKBACK_DAYS)
    existing = {} if not events else fetch_existing_events(listing_cutoff, end_date)
    created = []
    updated = []
    recreated = []
    deleted = []
    duplicates_removed = []
    unchanged = 0
    changes = []

    event_keys = {ev.state_key for ev in events}

    for ev in events:
        existing_list = existing.get(ev.state_key, [])
        # 같은 state_key로 여러 건이면 가장 최근 created를 남기고 나머지 삭제
        if len(existing_list) > 1:
            existing_list.sort(key=lambda e: e.get('created', ''), reverse=True)
            for dup in existing_list[1:]:
                delete_event(dup['id'], dry_run=args.dry_run)
                duplicates_removed.append(ev.state_key)
                old_start, old_end = event_date_range(dup)
                old_date = old_start if old_start == old_end or not old_end else f'{old_start}~{old_end}'
                changes.append({'kind': ev.kind, 'name': ev.name, 'action': 'duplicate_removed', 'event_id': dup['id'], 'old_date': old_date})

        existing_ev = existing_list[0] if existing_list else None

        if not existing_ev:
            create_event(ev, dry_run=args.dry_run)
            created.append(ev.state_key)
            changes.append({'kind': ev.kind, 'name': ev.name, 'action': 'created', 'new_date': ev.start_date.isoformat() if ev.start_date == ev.end_date else f'{ev.start_date.isoformat()}~{ev.end_date.isoformat()}'})
            continue

        existing_start, existing_end = event_date_range(existing_ev)
        desired_start = ev.start_date.isoformat()
        desired_end = ev.end_date.isoformat()
        existing_description = (existing_ev.get('description') or '').strip()
        desired_description = ev.description.strip()

        if existing_start != desired_start or existing_end != desired_end or existing_description != desired_description:
            result = update_event(existing_ev['id'], ev, dry_run=args.dry_run)
            if result == 'recreated':
                recreated.append(ev.state_key)
            else:
                updated.append(ev.state_key)
            old_date = existing_start if existing_start == existing_end or not existing_end else f'{existing_start}~{existing_end}'
            new_date = desired_start if desired_start == desired_end else f'{desired_start}~{desired_end}'
            changes.append({'kind': ev.kind, 'name': ev.name, 'action': result, 'old_date': old_date, 'new_date': new_date})
        else:
            unchanged += 1

    # 보조 소스는 종목명 표기가 다를 수 있어 failover 실행 중에는 stale 삭제를 하지 않는다.
    # 장기간 장애 후 복구 첫 실행도 오탐 삭제를 막고, 주 파서가 2회 연속 정상일 때만 정리한다.
    cleanup_allowed = parser_used == 'naver_api' and previous_parser_used == 'naver_api'
    if cleanup_allowed:
        for key, existing_list in existing.items():
            if key in event_keys:
                continue
            kind, name = key.split('|', 1)
            for stale in existing_list:
                old_start, old_end = event_date_range(stale)
                # 소급 조회는 누락 상장 보강용이다. 이미 지난 일정은 삭제하지 않는다.
                if old_end and date.fromisoformat(old_end) < cutoff:
                    continue
                delete_event(stale['id'], dry_run=args.dry_run)
                deleted.append(key)
                old_date = old_start if old_start == old_end or not old_end else f'{old_start}~{old_end}'
                changes.append({'kind': kind, 'name': name, 'action': 'deleted', 'event_id': stale['id'], 'old_date': old_date})

    state['last_changes'] = changes
    state['last_run_at'] = datetime.now(KST).isoformat()
    if not args.dry_run:
        save_state(state)

    print(json.dumps({'cutoff_after': cutoff.isoformat(), 'parser_used': parser_used, 'parser_errors': parser_errors, 'total_found': len(events), 'newly_created': len(created), 'updated': len(updated), 'recreated': len(recreated), 'deleted': len(deleted), 'duplicates_removed': len(duplicates_removed), 'unchanged': unchanged, 'dry_run': args.dry_run, 'changes': changes}, ensure_ascii=False))
    return 0


if __name__ == '__main__':
    raise SystemExit(main())