"""
AI 기반 피싱 이메일 탐지 — 헤더 분석 + 텍스트 이상 탐지
실무에서는 이 기본 로직 위에 ML 모델을 결합한다.
"""
import re
from dataclasses import dataclass
from enum import Enum


class ThreatLevel(Enum):
    SAFE = "safe"
    SUSPICIOUS = "suspicious"
    DANGEROUS = "dangerous"


@dataclass(frozen=True)
class EmailAnalysis:
    threat_level: ThreatLevel
    score: float
    reasons: tuple[str, ...]


class PhishingDetector:
    """규칙 기반 피싱 탐지기 — 점수 기반 판정"""

    URGENCY_PATTERNS = [
        r"긴급|urgent|immediately|지금\s*바로|즉시",
        r"계정.*(?:정지|중단|만료)|account.*(?:suspend|terminat)",
        r"비밀번호.*(?:변경|재설정)|password.*(?:reset|change)",
        r"확인.*(?:클릭|링크)|verify.*(?:click|link)",
    ]

    SPOOFING_INDICATORS = [
        r"reply-to.*differs.*from",  # Reply-To ≠ From
        r"X-Mailer.*unknown",
        r"received.*from.*(?:unknown|suspicious)",
    ]

    def analyze(self, subject: str, body: str, headers: dict[str, str]) -> EmailAnalysis:
        score = 0.0
        reasons: list[str] = []

        # 1) 긴급성 패턴 탐지
        for pattern in self.URGENCY_PATTERNS:
            if re.search(pattern, f"{subject} {body}", re.IGNORECASE):
                score += 0.2
                reasons.append(f"긴급성 패턴 탐지: {pattern}")

        # 2) 발신자 스푸핑 검사
        from_addr = headers.get("From", "")
        reply_to = headers.get("Reply-To", "")
        if reply_to and from_addr and reply_to != from_addr:
            score += 0.3
            reasons.append(f"Reply-To({reply_to}) ≠ From({from_addr})")

        # 3) 의심스러운 URL 검사
        urls = re.findall(r"https?://[^\s<>\"']+", body)
        for url in urls:
            if re.search(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", url):
                score += 0.25
                reasons.append(f"IP 기반 URL 탐지: {url}")
            if len(url) > 100:
                score += 0.1
                reasons.append(f"비정상 긴 URL: {url[:50]}...")

        # 4) 위협 레벨 판정
        if score >= 0.7:
            threat_level = ThreatLevel.DANGEROUS
        elif score >= 0.4:
            threat_level = ThreatLevel.SUSPICIOUS
        else:
            threat_level = ThreatLevel.SAFE

        return EmailAnalysis(
            threat_level=threat_level,
            score=min(score, 1.0),
            reasons=tuple(reasons),
        )


# 사용 예시
if __name__ == "__main__":
    detector = PhishingDetector()
    result = detector.analyze(
        subject="[긴급] 계정 정지 예정 — 즉시 확인 필요",
        body="귀하의 계정이 24시간 내 정지됩니다. 아래 링크를 클릭하여 확인하세요: http://192.168.1.100/verify-account-now-please-click-here-immediately",
        headers={
            "From": "security@company.com",
            "Reply-To": "attacker@evil.xyz",
        },
    )
    print(f"위협 레벨: {result.threat_level.value}")
    print(f"점수: {result.score:.2f}")
    for reason in result.reasons:
        print(f"  - {reason}")

"""
제로 트러스트 접근 제어 미들웨어 — FastAPI 기반
매 요청마다 신원 + 디바이스 + 컨텍스트를 검증한다.
"""
from dataclasses import dataclass
from datetime import datetime
from enum import Enum
from typing import Optional

from fastapi import FastAPI, Request, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials


class RiskLevel(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"


@dataclass(frozen=True)
class DevicePosture:
    os_patched: bool
    edr_active: bool
    disk_encrypted: bool
    last_scan: datetime


@dataclass(frozen=True)
class AccessContext:
    user_id: str
    device: DevicePosture
    source_ip: str
    geo_location: str
    request_time: datetime
    resource_sensitivity: str


class ZeroTrustPolicyEngine:
    """정책 결정 지점(PDP) — 리스크 점수 기반 접근 제어"""

    TRUSTED_GEOS = {"KR", "US", "JP"}
    BUSINESS_HOURS = range(6, 23)  # 06:00 ~ 22:59

    def evaluate(self, ctx: AccessContext) -> tuple[bool, RiskLevel, list[str]]:
        risk_score = 0
        violations: list[str] = []

        # 1) 디바이스 상태 검증
        if not ctx.device.edr_active:
            risk_score += 30
            violations.append("EDR 비활성 상태")
        if not ctx.device.os_patched:
            risk_score += 20
            violations.append("OS 패치 미적용")
        if not ctx.device.disk_encrypted:
            risk_score += 15
            violations.append("디스크 암호화 미적용")

        # 2) 지리적 이상 탐지
        if ctx.geo_location not in self.TRUSTED_GEOS:
            risk_score += 25
            violations.append(f"비인가 지역 접근: {ctx.geo_location}")

        # 3) 시간 이상 탐지
        if ctx.request_time.hour not in self.BUSINESS_HOURS:
            risk_score += 10
            violations.append(f"업무 외 시간 접근: {ctx.request_time.hour}시")

        # 4) 리소스 민감도에 따른 임계값 조정
        threshold = {
            "public": 80,
            "internal": 50,
            "confidential": 30,
            "restricted": 15,
        }.get(ctx.resource_sensitivity, 30)

        # 5) 판정
        if risk_score >= 70:
            risk_level = RiskLevel.CRITICAL
        elif risk_score >= 50:
            risk_level = RiskLevel.HIGH
        elif risk_score >= 30:
            risk_level = RiskLevel.MEDIUM
        else:
            risk_level = RiskLevel.LOW

        allowed = risk_score < threshold
        return allowed, risk_level, violations


# FastAPI 미들웨어 적용 예시
app = FastAPI()
policy_engine = ZeroTrustPolicyEngine()
security = HTTPBearer()


async def zero_trust_gate(
    request: Request,
    credentials: HTTPAuthorizationCredentials = Depends(security),
) -> AccessContext:
    """모든 요청에 대해 제로 트러스트 검증 수행"""
    # 실제로는 JWT 디코딩, 디바이스 인증서 검증, GeoIP 조회 등이 필요
    ctx = AccessContext(
        user_id="user-from-jwt",
        device=DevicePosture(
            os_patched=True,
            edr_active=True,
            disk_encrypted=True,
            last_scan=datetime.now(),
        ),
        source_ip=request.client.host if request.client else "unknown",
        geo_location="KR",
        request_time=datetime.now(),
        resource_sensitivity="confidential",
    )

    allowed, risk_level, violations = policy_engine.evaluate(ctx)

    if not allowed:
        raise HTTPException(
            status_code=403,
            detail={
                "message": "접근 거부 — 제로 트러스트 정책 위반",
                "risk_level": risk_level.value,
                "violations": violations,
            },
        )

    return ctx


@app.get("/api/sensitive-data")
async def get_sensitive_data(ctx: AccessContext = Depends(zero_trust_gate)):
    return {"message": "접근 허용", "user": ctx.user_id}

"""
포스트양자암호 키 교환 예시 — oqs-python (liboqs 래퍼)
pip install oqs
※ liboqs 시스템 설치 필요: https://github.com/open-quantum-safe/liboqs
"""
import oqs


def pqc_key_exchange():
    """ML-KEM-768 (FIPS 203) 키 캡슐화 시뮬레이션"""
    kem_algorithm = "ML-KEM-768"

    # 1) 서버: 키 쌍 생성
    with oqs.KeyEncapsulation(kem_algorithm) as server:
        public_key = server.generate_keypair()
        print(f"알고리즘: {kem_algorithm}")
        print(f"공개키 크기: {len(public_key)} bytes")

        # 2) 클라이언트: 공개키로 공유 비밀 캡슐화
        with oqs.KeyEncapsulation(kem_algorithm) as client:
            ciphertext, shared_secret_client = client.encap_secret(public_key)
            print(f"암호문 크기: {len(ciphertext)} bytes")
            print(f"공유 비밀 크기: {len(shared_secret_client)} bytes")

        # 3) 서버: 비밀키로 공유 비밀 복호화
        shared_secret_server = server.decap_secret(ciphertext)

        # 4) 검증: 양쪽 공유 비밀이 동일한지 확인
        assert shared_secret_client == shared_secret_server
        print("✅ 키 교환 성공 — 양쪽 공유 비밀 일치")
        print(f"공유 비밀 (hex): {shared_secret_client[:16].hex()}...")


def pqc_digital_signature():
    """ML-DSA-65 (FIPS 204) 전자서명 시뮬레이션"""
    sig_algorithm = "ML-DSA-65"
    message = b"2026 PQC migration is critical"

    with oqs.Signature(sig_algorithm) as signer:
        public_key = signer.generate_keypair()
        signature = signer.sign(message)
        print(f"\n서명 알고리즘: {sig_algorithm}")
        print(f"서명 크기: {len(signature)} bytes")

    with oqs.Signature(sig_algorithm) as verifier:
        is_valid = verifier.verify(message, signature, public_key)
        print(f"서명 검증: {'✅ 유효' if is_valid else '❌ 무효'}")


if __name__ == "__main__":
    pqc_key_exchange()
    pqc_digital_signature()

"""
에이전트 AI용 세분화된 권한 관리 예시
RBAC(역할 기반)이 아닌 ABAC(속성 기반) + 시간 제한 토큰
"""
from dataclasses import dataclass
from datetime import datetime, timedelta
from enum import Enum
import hashlib
import secrets


class AgentType(Enum):
    CODE_ASSISTANT = "code_assistant"      # 코드 읽기만
    DEPLOYMENT_BOT = "deployment_bot"      # 배포 실행
    DATA_ANALYST = "data_analyst"          # 데이터 조회
    SECURITY_SCANNER = "security_scanner"  # 전체 읽기


@dataclass(frozen=True)
class AgentCredential:
    agent_id: str
    agent_type: AgentType
    allowed_resources: frozenset[str]
    max_actions_per_minute: int
    expires_at: datetime
    token_hash: str


class AgentIdentityManager:
    """에이전트 AI 전용 IAM — 최소 권한 + 시간 제한 + 속도 제한"""

    PERMISSION_MAP: dict[AgentType, frozenset[str]] = {
        AgentType.CODE_ASSISTANT: frozenset({"repo:read", "docs:read"}),
        AgentType.DEPLOYMENT_BOT: frozenset({"deploy:execute", "config:read", "logs:read"}),
        AgentType.DATA_ANALYST: frozenset({"data:read", "reports:write"}),
        AgentType.SECURITY_SCANNER: frozenset({"repo:read", "infra:read", "vuln:write"}),
    }

    RATE_LIMITS: dict[AgentType, int] = {
        AgentType.CODE_ASSISTANT: 60,
        AgentType.DEPLOYMENT_BOT: 10,
        AgentType.DATA_ANALYST: 30,
        AgentType.SECURITY_SCANNER: 120,
    }

    def __init__(self) -> None:
        self._credentials: dict[str, AgentCredential] = {}

    def register_agent(
        self,
        agent_type: AgentType,
        ttl_hours: int = 8,
    ) -> tuple[str, str]:
        """에이전트 등록 — 시간 제한 크레덴셜 발급"""
        agent_id = f"agent-{agent_type.value}-{secrets.token_hex(4)}"
        raw_token = secrets.token_urlsafe(32)
        token_hash = hashlib.sha256(raw_token.encode()).hexdigest()

        credential = AgentCredential(
            agent_id=agent_id,
            agent_type=agent_type,
            allowed_resources=self.PERMISSION_MAP[agent_type],
            max_actions_per_minute=self.RATE_LIMITS[agent_type],
            expires_at=datetime.now() + timedelta(hours=ttl_hours),
            token_hash=token_hash,
        )
        self._credentials[agent_id] = credential

        print(f"✅ 에이전트 등록: {agent_id}")
        print(f"   권한: {', '.join(credential.allowed_resources)}")
        print(f"   속도 제한: {credential.max_actions_per_minute}/min")
        print(f"   만료: {credential.expires_at.isoformat()}")

        return agent_id, raw_token

    def authorize(self, agent_id: str, resource: str) -> bool:
        """접근 시마다 권한 + 만료 검증"""
        cred = self._credentials.get(agent_id)
        if cred is None:
            print(f"❌ 미등록 에이전트: {agent_id}")
            return False

        if datetime.now() > cred.expires_at:
            print(f"❌ 만료된 크레덴셜: {agent_id}")
            del self._credentials[agent_id]
            return False

        if resource not in cred.allowed_resources:
            print(f"❌ 권한 없음: {agent_id} → {resource}")
            return False

        print(f"✅ 접근 허용: {agent_id} → {resource}")
        return True


if __name__ == "__main__":
    iam = AgentIdentityManager()
    agent_id, token = iam.register_agent(AgentType.CODE_ASSISTANT, ttl_hours=4)

    iam.authorize(agent_id, "repo:read")       # ✅ 허용
    iam.authorize(agent_id, "deploy:execute")   # ❌ 권한 없음

# 3. Python으로 SBOM 분석 — 취약 컴포넌트 탐지
import json
from dataclasses import dataclass
from pathlib import Path


@dataclass(frozen=True)
class Component:
    name: str
    version: str
    purl: str


def parse_cyclonedx_sbom(sbom_path: str) -> list[Component]:
    """CycloneDX SBOM JSON을 파싱하여 컴포넌트 목록 반환"""
    raw = Path(sbom_path).read_text(encoding="utf-8")
    data = json.loads(raw)

    components = []
    for comp in data.get("components", []):
        components.append(
            Component(
                name=comp.get("name", "unknown"),
                version=comp.get("version", "0.0.0"),
                purl=comp.get("purl", ""),
            )
        )
    return components


def check_known_vulnerable(
    components: list[Component],
    vuln_db: dict[str, list[str]],
) -> list[tuple[Component, list[str]]]:
    """알려진 취약점 DB와 대조하여 취약 컴포넌트 필터링"""
    vulnerable = []
    for comp in components:
        key = f"{comp.name}@{comp.version}"
        if key in vuln_db:
            vulnerable.append((comp, vuln_db[key]))
    return vulnerable


# 사용 예시
if __name__ == "__main__":
    # 간이 취약점 DB (실제로는 OSV.dev API 연동)
    sample_vuln_db = {
        "lodash@4.17.20": ["CVE-2021-23337", "CVE-2020-28500"],
        "log4j-core@2.14.1": ["CVE-2021-44228"],  # Log4Shell
    }

    components = parse_cyclonedx_sbom("sbom.json")
    print(f"총 {len(components)}개 컴포넌트 분석 중...")

    vulnerables = check_known_vulnerable(components, sample_vuln_db)
    for comp, cves in vulnerables:
        print(f"⚠️  {comp.name}@{comp.version}: {', '.join(cves)}")

    if not vulnerables:
        print("✅ 알려진 취약점 없음")

# Python에서 Valkey 사용 — redis-py와 100% 호환
import redis

# Valkey 연결 (Redis 클라이언트 그대로 사용)
client = redis.Redis(host="localhost", port=6379, decode_responses=True)

# 기본 CRUD
client.set("user:1001:name", "HoneyBee")
client.set("user:1001:role", "developer")

name = client.get("user:1001:name")
print(f"사용자: {name}")  # 사용자: HoneyBee

# 파이프라인으로 벌크 연산
with client.pipeline() as pipe:
    for i in range(1000):
        pipe.set(f"counter:{i}", i * 10)
    pipe.execute()

print(f"총 키 수: {client.dbsize()}")

# 오픈소스 거버넌스 자동화 파이프라인 예시
from dataclasses import dataclass, field
from enum import Enum


class RiskLevel(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"


@dataclass(frozen=True)
class DependencyAuditResult:
    package: str
    version: str
    license: str
    risk_level: RiskLevel
    issues: tuple[str, ...] = field(default=())


# 라이선스 호환성 매트릭스 (프로젝트 라이선스가 MIT일 때)
LICENSE_COMPATIBILITY: dict[str, bool] = {
    "MIT": True,
    "Apache-2.0": True,
    "BSD-2-Clause": True,
    "BSD-3-Clause": True,
    "ISC": True,
    "LGPL-2.1": True,     # 동적 링크 시 호환
    "GPL-2.0": False,     # 전체 프로젝트에 GPL 전파
    "GPL-3.0": False,
    "AGPL-3.0": False,    # 네트워크 서비스도 공개 의무
    "SSPL-1.0": False,    # OSI 미승인, 위험
    "BSL-1.1": False,     # 상업적 사용 제한
    "UNLICENSED": False,  # 라이선스 불명 — 사용 불가
}


def audit_dependency(
    package: str,
    version: str,
    license_id: str,
    known_cves: list[str],
    maintainer_count: int,
) -> DependencyAuditResult:
    """의존성 패키지를 보안·라이선스·유지보수 관점에서 감사"""
    issues: list[str] = []
    risk = RiskLevel.LOW

    # 1. 라이선스 호환성 검사
    if not LICENSE_COMPATIBILITY.get(license_id, False):
        issues.append(f"라이선스 비호환: {license_id}")
        risk = RiskLevel.HIGH

    # 2. 알려진 CVE 검사
    if known_cves:
        issues.append(f"CVE {len(known_cves)}건: {', '.join(known_cves[:3])}")
        risk = RiskLevel.CRITICAL

    # 3. 메인테이너 리스크 (bus factor)
    if maintainer_count <= 1:
        issues.append(f"단일 메인테이너 위험 (bus factor: {maintainer_count})")
        if risk.value != "critical":
            risk = RiskLevel.MEDIUM

    return DependencyAuditResult(
        package=package,
        version=version,
        license=license_id,
        risk_level=risk,
        issues=tuple(issues),
    )


# 사용 예시
if __name__ == "__main__":
    results = [
        audit_dependency("express", "4.18.2", "MIT", [], 15),
        audit_dependency("left-pad", "1.3.0", "MIT", [], 1),
        audit_dependency("my-db-driver", "2.1.0", "SSPL-1.0", ["CVE-2025-1234"], 2),
    ]

    for r in results:
        icon = {"low": "✅", "medium": "⚠️", "high": "🟠", "critical": "🔴"}
        print(f"{icon[r.risk_level.value]} {r.package}@{r.version} [{r.risk_level.value}]")
        for issue in r.issues:
            print(f"   └─ {issue}")

"""
B-Tree 인덱스 동작 원리를 이해하기 위한 간소화된 구현.
실제 DB 인덱스의 핵심 연산(검색, 삽입, 범위 탐색)을 체험한다.
"""
from __future__ import annotations
from typing import Optional


class BTreeNode:
    """B-Tree의 개별 노드. 최대 (2 * degree - 1)개의 키를 보관한다."""

    def __init__(self, degree: int, is_leaf: bool = True) -> None:
        self.degree = degree          # 최소 차수 (t)
        self.keys: list[int] = []     # 정렬된 키 목록
        self.children: list[BTreeNode] = []  # 자식 포인터
        self.is_leaf = is_leaf

    @property
    def is_full(self) -> bool:
        return len(self.keys) >= 2 * self.degree - 1


class BTree:
    """
    B-Tree 인덱스 시뮬레이터.
    
    degree=3 이면 노드당 최대 5개 키, 최소 2개 키.
    실제 DB는 degree가 수백 이상으로, 100만 행도 깊이 3~4 안에 처리한다.
    """

    def __init__(self, degree: int = 3) -> None:
        self.degree = degree
        self.root = BTreeNode(degree, is_leaf=True)
        self._io_count = 0  # 디스크 I/O 시뮬레이션

    def search(self, key: int, node: Optional[BTreeNode] = None) -> bool:
        """키 검색. 탐색 경로마다 I/O 카운트를 증가시킨다."""
        if node is None:
            node = self.root
            self._io_count = 0

        self._io_count += 1  # 이 노드를 디스크에서 읽었다고 가정

        # 현재 노드에서 키 위치를 찾는다
        i = 0
        while i < len(node.keys) and key > node.keys[i]:
            i += 1

        # 키를 찾았다
        if i < len(node.keys) and node.keys[i] == key:
            print(f"  ✅ 키 {key} 발견! (디스크 I/O: {self._io_count}회)")
            return True

        # 리프 노드인데 키가 없다 → 존재하지 않음
        if node.is_leaf:
            print(f"  ❌ 키 {key} 없음 (디스크 I/O: {self._io_count}회)")
            return False

        # 적절한 자식으로 내려간다
        return self.search(key, node.children[i])

    def insert(self, key: int) -> None:
        """키 삽입. 루트가 가득 차면 분할 후 삽입한다."""
        root = self.root

        if root.is_full:
            new_root = BTreeNode(self.degree, is_leaf=False)
            new_root.children.append(root)
            self._split_child(new_root, 0)
            self.root = new_root

        self._insert_non_full(self.root, key)

    def range_search(self, low: int, high: int) -> list[int]:
        """범위 검색 — B-Tree가 해시 인덱스보다 유리한 핵심 연산."""
        result: list[int] = []
        self._range_collect(self.root, low, high, result)
        print(f"  🔍 범위 [{low}, {high}]: {len(result)}건 발견")
        return result

    def _range_collect(
        self, node: BTreeNode, low: int, high: int, result: list[int]
    ) -> None:
        i = 0
        while i < len(node.keys):
            # 왼쪽 자식 탐색 (키보다 작은 범위에 해당 키가 있을 수 있음)
            if not node.is_leaf and node.keys[i] >= low:
                self._range_collect(node.children[i], low, high, result)

            # 현재 키가 범위 안이면 결과에 추가
            if low <= node.keys[i] <= high:
                result.append(node.keys[i])
            elif node.keys[i] > high:
                # 오른쪽은 볼 필요 없음 — 정렬 특성 활용
                if not node.is_leaf:
                    self._range_collect(node.children[i], low, high, result)
                return

            i += 1

        # 마지막 자식 탐색
        if not node.is_leaf and i < len(node.children):
            self._range_collect(node.children[i], low, high, result)

    def _split_child(self, parent: BTreeNode, index: int) -> None:
        t = self.degree
        full_child = parent.children[index]
        new_child = BTreeNode(t, is_leaf=full_child.is_leaf)

        # 중간 키를 부모로 승격
        parent.keys.insert(index, full_child.keys[t - 1])
        parent.children.insert(index + 1, new_child)

        # 오른쪽 절반을 새 노드로 이동
        new_child.keys = full_child.keys[t:]
        full_child.keys = full_child.keys[: t - 1]

        if not full_child.is_leaf:
            new_child.children = full_child.children[t:]
            full_child.children = full_child.children[:t]

    def _insert_non_full(self, node: BTreeNode, key: int) -> None:
        i = len(node.keys) - 1

        if node.is_leaf:
            node.keys.append(0)
            while i >= 0 and key < node.keys[i]:
                node.keys[i + 1] = node.keys[i]
                i -= 1
            node.keys[i + 1] = key
        else:
            while i >= 0 and key < node.keys[i]:
                i -= 1
            i += 1
            if node.children[i].is_full:
                self._split_child(node, i)
                if key > node.keys[i]:
                    i += 1
            self._insert_non_full(node.children[i], key)


# ── 실행 예시 ──
if __name__ == "__main__":
    tree = BTree(degree=3)

    # 데이터 삽입
    data = [10, 20, 5, 6, 12, 30, 7, 17, 3, 25, 40, 50, 15, 35, 45]
    for val in data:
        tree.insert(val)

    print("=== B-Tree 검색 ===")
    tree.search(17)   # ✅ 키 17 발견! (디스크 I/O: 2회)
    tree.search(99)   # ❌ 키 99 없음

    print("\n=== B-Tree 범위 검색 ===")
    results = tree.range_search(10, 30)
    print(f"  결과: {sorted(results)}")
    # 🔍 범위 [10, 30]: 6건 발견
    # 결과: [10, 12, 15, 17, 20, 25, 30]

# models.py
class Order(models.Model):
    customer_id = models.BigIntegerField(db_index=True)  # 단일 인덱스
    status = models.CharField(max_length=20)
    order_date = models.DateField()
    total_price = models.DecimalField(max_digits=10, decimal_places=2)

    class Meta:
        indexes = [
            # 복합 인덱스
            models.Index(
                fields=['customer_id', 'status', 'order_date'],
                name='idx_order_cust_status_date'
            ),
            # 조건부 인덱스 (PostgreSQL Partial Index)
            models.Index(
                fields=['customer_id', 'order_date'],
                condition=models.Q(status='pending'),
                name='idx_order_active'
            ),
        ]

"""
MinHeap & HeapSort — 배열 기반 완전 구현
"""


class MinHeap:
    """최소힙: 부모 <= 자식을 항상 유지하는 완전 이진 트리"""

    def __init__(self):
        self._data: list[int] = []

    def __len__(self) -> int:
        return len(self._data)

    def __bool__(self) -> bool:
        return len(self._data) > 0

    def peek(self) -> int:
        """최솟값 조회 — O(1)"""
        if not self._data:
            raise IndexError("heap is empty")
        return self._data[0]

    def push(self, value: int) -> None:
        """삽입 — O(log N)"""
        self._data.append(value)
        self._sift_up(len(self._data) - 1)

    def pop(self) -> int:
        """최솟값 추출 — O(log N)"""
        if not self._data:
            raise IndexError("heap is empty")

        # 루트와 마지막 원소 교환 후 제거
        root = self._data[0]
        last = self._data.pop()

        if self._data:
            self._data[0] = last
            self._sift_down(0)

        return root

    def push_pop(self, value: int) -> int:
        """push 후 pop — 최적화된 O(log N)"""
        if self._data and self._data[0] < value:
            # 새 값이 현재 최솟값보다 크면, 루트를 교체하고 sift down
            result = self._data[0]
            self._data[0] = value
            self._sift_down(0)
            return result
        # 새 값이 최솟값 이하면 그대로 반환
        return value

    def _sift_up(self, index: int) -> None:
        """새로 삽입된 노드를 위로 올림"""
        while index > 0:
            parent = (index - 1) // 2
            if self._data[index] < self._data[parent]:
                self._data[index], self._data[parent] = (
                    self._data[parent],
                    self._data[index],
                )
                index = parent
            else:
                break

    def _sift_down(self, index: int) -> None:
        """루트 노드를 아래로 내림"""
        size = len(self._data)
        while True:
            smallest = index
            left = 2 * index + 1
            right = 2 * index + 2

            if left < size and self._data[left] < self._data[smallest]:
                smallest = left
            if right < size and self._data[right] < self._data[smallest]:
                smallest = right

            if smallest == index:
                break

            self._data[index], self._data[smallest] = (
                self._data[smallest],
                self._data[index],
            )
            index = smallest

    @staticmethod
    def heapify(arr: list[int]) -> "MinHeap":
        """임의 배열 → 최소힙 변환 — O(N)"""
        heap = MinHeap()
        heap._data = list(arr)  # 원본 불변 — 새 리스트 생성
        # 마지막 내부 노드부터 역순으로 sift down
        for i in range(len(arr) // 2 - 1, -1, -1):
            heap._sift_down(i)
        return heap

    def __repr__(self) -> str:
        return f"MinHeap({self._data})"


def heap_sort(arr: list[int]) -> list[int]:
    """
    힙 정렬 — O(N log N), 불안정 정렬
    원본 배열을 변경하지 않고 정렬된 새 리스트 반환
    """
    heap = MinHeap.heapify(arr)
    return [heap.pop() for _ in range(len(heap))]


# ── 사용 예시 ──
if __name__ == "__main__":
    # 기본 사용
    h = MinHeap()
    for v in [5, 3, 8, 1, 9, 2]:
        h.push(v)
    print(f"힙 상태: {h}")           # MinHeap([1, 3, 2, 5, 9, 8])
    print(f"최솟값: {h.peek()}")      # 1
    print(f"추출: {h.pop()}")         # 1
    print(f"추출 후: {h}")            # MinHeap([2, 3, 8, 5, 9])

    # heapify
    data = [9, 7, 5, 3, 1, 8, 6]
    built = MinHeap.heapify(data)
    print(f"\nheapify 결과: {built}")  # MinHeap([1, 3, 5, 9, 7, 8, 6])

    # 힙 정렬
    unsorted = [38, 27, 43, 3, 9, 82, 10]
    print(f"\n정렬 전: {unsorted}")
    print(f"정렬 후: {heap_sort(unsorted)}")  # [3, 9, 10, 27, 38, 43, 82]

    # Python 표준 라이브러리 heapq 활용
    import heapq

    nums = [5, 3, 8, 1, 9]
    heapq.heapify(nums)               # in-place O(N) 변환
    heapq.heappush(nums, 2)           # 삽입
    smallest = heapq.heappop(nums)    # 추출
    top3 = heapq.nsmallest(3, nums)   # 상위 k개
    print(f"\nheapq — 최솟값: {smallest}, 상위 3개: {top3}")