# -*- coding: utf-8 -*-
"""
STEP103-16 Resume Failure Scenario Test

역할:
- 테스트용 scheduler_key에 일부러 "stage start만 있고 finish가 없는" Timeline을 생성한다.
- ResumeInspector가 should_resume=True로 판단하는지 검증한다.

실행:
  cd /d D:/honghee/blog_api
  python -m tools.test_v2_resume_failure_scenario --scheduler-key resume_test --realtor-id 1

주의:
- 기본 scheduler_key=resume_test 이므로 실제 server_default 운영 상태를 건드리지 않는다.
"""

import argparse
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))

from db import get_conn
from services.v2.resume_inspector import ResumeInspector


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--scheduler-key", default="resume_test")
    parser.add_argument("--realtor-id", type=int, default=1)
    parser.add_argument("--pipeline-id", default=None)
    parser.add_argument("--stage", default="publish")
    parser.add_argument("--article-no", default="TEST-ARTICLE")
    parser.add_argument("--draft-id", type=int, default=None)
    parser.add_argument("--publish-queue-id", type=int, default=None)
    args = parser.parse_args()

    pipeline_id = args.pipeline_id or f"V2-RESUME-TEST-R{args.realtor_id}"

    conn = get_conn()

    try:
        with conn.cursor() as cur:
            # 테스트용 scheduler_state 생성/갱신
            cur.execute(
                """
                INSERT INTO blog_v2_scheduler_state
                (
                    scheduler_key,
                    scheduler_type,
                    run_date,
                    status,
                    cursor_realtor_id,
                    cursor_stage,
                    cursor_article_no,
                    cursor_draft_id,
                    cursor_publish_queue_id,
                    last_pipeline_id,
                    last_message,
                    started_at,
                    last_heartbeat_at,
                    created_at,
                    updated_at
                )
                VALUES
                (
                    %s,
                    'test',
                    CURDATE(),
                    'running',
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    'resume failure scenario test',
                    NOW(),
                    NOW(),
                    NOW(),
                    NOW()
                )
                ON DUPLICATE KEY UPDATE
                    scheduler_type='test',
                    run_date=CURDATE(),
                    status='running',
                    cursor_realtor_id=VALUES(cursor_realtor_id),
                    cursor_stage=VALUES(cursor_stage),
                    cursor_article_no=VALUES(cursor_article_no),
                    cursor_draft_id=VALUES(cursor_draft_id),
                    cursor_publish_queue_id=VALUES(cursor_publish_queue_id),
                    last_pipeline_id=VALUES(last_pipeline_id),
                    last_message=VALUES(last_message),
                    last_heartbeat_at=NOW(),
                    updated_at=NOW()
                """,
                (
                    args.scheduler_key,
                    int(args.realtor_id),
                    args.stage,
                    args.article_no,
                    args.draft_id,
                    args.publish_queue_id,
                    pipeline_id,
                ),
            )

            # 같은 테스트 pipeline 기존 이벤트 정리
            cur.execute(
                """
                DELETE FROM blog_v2_pipeline_timeline
                WHERE scheduler_key=%s
                  AND pipeline_id=%s
                """,
                (args.scheduler_key, pipeline_id),
            )

            # pipeline start
            cur.execute(
                """
                INSERT INTO blog_v2_pipeline_timeline
                (
                    pipeline_id,
                    scheduler_key,
                    realtor_id,
                    article_no,
                    draft_id,
                    publish_queue_id,
                    stage,
                    event_type,
                    status,
                    success,
                    message,
                    started_at,
                    created_at
                )
                VALUES
                (
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    'pipeline',
                    'start',
                    'running',
                    NULL,
                    'resume test pipeline start',
                    NOW(),
                    NOW()
                )
                """,
                (
                    pipeline_id,
                    args.scheduler_key,
                    int(args.realtor_id),
                    args.article_no,
                    args.draft_id,
                    args.publish_queue_id,
                ),
            )

            # stage start만 기록. finish 없음.
            cur.execute(
                """
                INSERT INTO blog_v2_pipeline_timeline
                (
                    pipeline_id,
                    scheduler_key,
                    realtor_id,
                    article_no,
                    draft_id,
                    publish_queue_id,
                    stage,
                    event_type,
                    status,
                    success,
                    message,
                    started_at,
                    created_at
                )
                VALUES
                (
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    %s,
                    'start',
                    'running',
                    NULL,
                    'resume test stage start without finish',
                    NOW(),
                    NOW()
                )
                """,
                (
                    pipeline_id,
                    args.scheduler_key,
                    int(args.realtor_id),
                    args.article_no,
                    args.draft_id,
                    args.publish_queue_id,
                    args.stage,
                ),
            )

        conn.commit()

        inspector = ResumeInspector(conn, scheduler_key=args.scheduler_key)
        result = inspector.inspect()

        print("=" * 100)
        print("[STEP103-16 RESUME FAILURE SCENARIO TEST]")
        print("scheduler_key:", args.scheduler_key)
        print("pipeline_id:", pipeline_id)
        print("-" * 100)
        print("should_resume:", result.should_resume)
        print("reason:", result.reason)
        print("realtor_id:", result.realtor_id)
        print("stage:", result.stage)
        print("article_no:", result.article_no)
        print("draft_id:", result.draft_id)
        print("publish_queue_id:", result.publish_queue_id)
        print("=" * 100)

        if not result.should_resume:
            raise SystemExit("FAILED: should_resume expected True")

        if result.reason != "last_event_was_start_without_finish":
            raise SystemExit(f"FAILED: unexpected reason {result.reason}")

        print("SUCCESS")

    finally:
        conn.close()


if __name__ == "__main__":
    main()