import hashlib
import hmac
import time
import requests
from typing import Dict, Any

class S2SPostbackClient:
    def __init__(self, secret_key: str, signature_algo: str = "sha256"):
        self.secret_key = secret_key
        self.signature_algo = signature_algo
        self.retry_delays = [1800]  # 1 分钟、5 分钟、30 分钟[60][300]

    def generate_signature(self, params: Dict[str, Any]) -> str:
        """
        根据媒体要求的参数排序规则与签名算法生成签名串
        """
        # 按 key 字母顺序排序参数
        sorted_params = sorted(params.items())
        param_string = "&".join(f"{k}={v}" for k, v in sorted_params)
        param_string += f"&key={self.secret_key}"  # 附加密钥
        
        if self.signature_algo == "md5":
            return hashlib.md5(param_string.encode()).hexdigest()
        elif self.signature_algo == "sha256":
            return hashlib.sha256(param_string.encode()).hexdigest()
        elif self.signature_algo == "hmac-sha256":
            return hmac.new(
                self.secret_key.encode(),
                param_string.encode(),
                hashlib.sha256
            ).hexdigest()
        else:
            raise ValueError(f"Unsupported signature algorithm: {self.signature_algo}")

    def execute_postback_with_retry(
        self,
        event_payload: Dict[str, Any],
        target_url: str,
        max_retries: int = 3
    ) -> bool:
        """
        执行带指数退避重试的 S2S 回传
        """
        for attempt in range(max_retries + 1):
            try:
                # 生成签名
                event_payload["sign"] = self.generate_signature(event_payload)
                
                # 发送 POST 请求
                response = requests.post(target_url, json=event_payload, timeout=5)
                
                if response.status_code == 200:
                    return True
                else:
                    # 媒体侧返回错误，根据状态码决定是否重试
                    if response.status_code >= 500:  # 服务器错误，可重试
                        raise requests.exceptions.RequestException(f"Server error: {response.status_code}")
                    else:  # 客户端错误，不重试
                        return False
            except requests.exceptions.RequestException as e:
                if attempt < max_retries:
                    # 指数退避等待
                    delay = self.retry_delays[attempt] if attempt < len(self.retry_delays) else self.retry_delays[-1]
                    time.sleep(delay)
                else:
                    # 重试次数用尽，记录日志并告警
                    print(f"Postback failed after {max_retries} retries: {e}")
                    return False
        
        return False

# 示例：向巨量引擎回传付费事件
client = S2SPostbackClient(secret_key="your_secret_key", signature_algo="sha256")
payload = {
    "event_type": "purchase",
    "click_id": "click_123456",
    "transaction_id": "order_789012",  # 唯一去重键
    "revenue": 99.9,
    "currency": "CNY",
    "timestamp": int(time.time())
}
target_url = "[https://api.oceanengine.com/2/app/track/activate/](https://api.oceanengine.com/2/app/track/activate/)"

success = client.execute_postback_with_retry(payload, target_url)
print(f"Postback success: {success}")

def handle_postback_request(request):
    """
    媒体侧接收 S2S 回传请求并执行去重处理
    """
    # 1. 验签
    received_sign = request.json.get("sign")
    expected_sign = generate_expected_signature(request.json, secret_key)
    
    if received_sign != expected_sign:
        return {"status": "error", "message": "Invalid signature"}, 401
    
    # 2. 去重检查
    transaction_id = request.json.get("transaction_id")
    if is_duplicate_transaction(transaction_id):
        # 已处理过该转化，直接返回成功（幂等）
        return {"status": "success", "message": "Duplicate ignored"}, 200
    
    # 3. 处理转化事件
    process_conversion_event(request.json)
    mark_transaction_as_processed(transaction_id)
    
    return {"status": "success", "message": "Event processed"}, 200