from typing import Dict, List
from datetime import datetime, timedelta

class ClickInjectionDetector:
    def __init__(self, ctit_threshold_seconds: int = 120):
        self.ctit_threshold = timedelta(seconds=ctit_threshold_seconds)
    
    def detect_click_injection(
        self,
        click_time: datetime,
        install_time: datetime,
        device_fingerprint: Dict
    ) -> bool:
        """
        检测点击劫持（Click Injection）
        若 CTIT 低于阈值，直接判定为点击劫持
        """
        ctit = install_time - click_time
        
        if ctit < self.ctit_threshold:
            # CTIT 低于物理极限，判定为点击劫持
            return True
        
        # 进一步校验设备指纹相似度
        similarity = self.calculate_fingerprint_similarity(device_fingerprint)
        if similarity > 0.95 and ctit < timedelta(seconds=300):
            # 指纹相似度高且 CTIT 异常，判定为设备农场或点击劫持
            return True
        
        return False
    
    def calculate_fingerprint_similarity(self, fingerprint: Dict) -> float:
        """
        计算设备指纹相似度（简化示例）
        """
        # 实际实现应基于多维度特征加权打分
        return fingerprint.get("similarity_score", 0.0)

# 示例：检测点击劫持
detector = ClickInjectionDetector(ctit_threshold_seconds=120)

click_time = datetime(2026, 9, 22, 10, 0, 0)
install_time = datetime(2026, 9, 22, 10, 1, 30)  # CTIT = 90 秒（低于 120 秒阈值）
fingerprint = {"similarity_score": 0.98}

is_injection = detector.detect_click_injection(click_time, install_time, fingerprint)
print(f"是否点击劫持：{is_injection}")  # 应输出 True

from typing import Dict, List, Optional

class AttributionWaterfall:
    def __init__(self):
        self.deterministic_threshold = 0.95  # 确定性匹配阈值
        self.probabilistic_threshold = 0.75  # 概率匹配阈值
    
    def match_attribution(
        self,
        click_fingerprint: Dict,
        install_fingerprint: Dict
    ) -> Optional[Dict]:
        """
        归因瀑布流模型：从确定性匹配降级至概率匹配
        """
        # 步骤一：尝试确定性匹配（设备 ID 强比对）
        deterministic_match = self.deterministic_match(click_fingerprint, install_fingerprint)
        if deterministic_match:
            return {"match_type": "deterministic", "confidence": 1.0}
        
        # 步骤二：降级至概率匹配（多维特征池加权打分）
        probabilistic_score = self.probabilistic_match(click_fingerprint, install_fingerprint)
        if probabilistic_score >= self.probabilistic_threshold:
            return {"match_type": "probabilistic", "confidence": probabilistic_score}
        
        # 无匹配
        return None
    
    def deterministic_match(self, click_fp: Dict, install_fp: Dict) -> bool:
        """
        确定性匹配：设备 ID 强比对（OAID、IMEI、IDFA 等）
        """
        click_id = click_fp.get("device_id")
        install_id = install_fp.get("device_id")
        
        if click_id and install_id and click_id == install_id:
            return True
        return False
    
    def probabilistic_match(self, click_fp: Dict, install_fp: Dict) -> float:
        """
        概率匹配：多维特征池加权打分（IP、UA、屏幕分辨率等）
        """
        weights = {
            "ip": 0.3,
            "ua": 0.2,
            "screen_resolution": 0.2,
            "os_version": 0.15,
            "timezone": 0.15,
        }
        
        score = 0.0
        if click_fp.get("ip") == install_fp.get("ip"):
            score += weights["ip"]
        if click_fp.get("ua") == install_fp.get("ua"):
            score += weights["ua"]
        if click_fp.get("screen_resolution") == install_fp.get("screen_resolution"):
            score += weights["screen_resolution"]
        if click_fp.get("os_version") == install_fp.get("os_version"):
            score += weights["os_version"]
        if click_fp.get("timezone") == install_fp.get("timezone"):
            score += weights["timezone"]
        
        return score

# 示例：归因瀑布流匹配
waterfall = AttributionWaterfall()

click_fp = {
    "device_id": "device_123",
    "ip": "192.168.1.1",
    "ua": "Mozilla/5.0",
    "screen_resolution": "1080x1920",
    "os_version": "Android 13",
    "timezone": "UTC+8",
}
install_fp = {
    "device_id": "device_456",  # 设备 ID 不匹配
    "ip": "192.168.1.1",
    "ua": "Mozilla/5.0",
    "screen_resolution": "1080x1920",
    "os_version": "Android 13",
    "timezone": "UTC+8",
}

result = waterfall.match_attribution(click_fp, install_fp)
print(f"归因结果：{result}")  # 应输出概率匹配结果