use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use redis::{Client as RedisClient, Commands};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::Mutex;

// 廣告請求結構
#[derive(Serialize, Deserialize, Debug)]
struct AdRequest {
    content_id: String,      // 正在觀看的內容ID
    user_id: String,         // 使用者唯一標識
    timestamp: u64,          // 請求時間戳
    current_position: f32,   // 影片當前位置（秒）
    device_type: String,     // 裝置類別
    placement_type: String,  // 廣告位置類別（前貼片、中插等）
}

// 廣告回應結構
#[derive(Serialize, Deserialize)]
struct AdResponse {
    ad_id: String,           // 廣告ID
    duration: u32,           // 廣告時長（秒）
    url: String,             // 廣告資源URL
    tracking_events: Vec<TrackingEvent>, // 跟蹤事件列表
    skip_offset: Option<u32>, // 可跳過時間（秒）
}

// 廣告跟蹤事件
#[derive(Serialize, Deserialize)]
struct TrackingEvent {
    event_type: String,      // 事件類別（開始、25%、完成等）
    tracking_url: String,    // 上報URL
}

// 分享應用狀態
struct AppState {
    redis: Arc<Mutex<redis::Connection>>,
}

// 廣告請求處理函式
async fn request_ad(
    app_state: web::Data<AppState>,
    ad_request: web::Json<AdRequest>
) -> impl Responder {
    println!("收到廣告請求: {:?}", ad_request);
    
    // 取得Redis連線
    let mut redis_conn = app_state.redis.lock().await;
    
    // 檢查快取是否有針對該使用者的預選廣告
    let cache_key = format!("pre_selected_ad:{}", ad_request.user_id);
    let cached_ad: Option<String> = redis_conn.get(&cache_key).unwrap_or(None);
    
    if let Some(ad_json) = cached_ad {
        // 從快取回傳預選廣告
        return HttpResponse::Ok().body(ad_json);
    }
    
    // 根據請求引數構建廣告回應
    // 實際系統中這裡會有複雜的廣告選擇邏輯
    let ad_response = AdResponse {
        ad_id: format!("ad_{}", uuid::Uuid::new_v4()),
        duration: 30,
        url: "https://ads.example.com/creative/video12345.mp4".to_string(),
        tracking_events: vec![
            TrackingEvent {
                event_type: "start".to_string(),
                tracking_url: "https://analytics.ads.com/track/start".to_string(),
            },
            TrackingEvent {
                event_type: "complete".to_string(),
                tracking_url: "https://analytics.ads.com/track/complete".to_string(),
            },
        ],
        skip_offset: Some(5),
    };
    
    // 序列化回應
    let response_json = serde_json::to_string(&ad_response).unwrap();
    
    // 將結果存入快取，有效期30秒
    let _: () = redis_conn.set_ex(&cache_key, &response_json, 30).unwrap();
    
    HttpResponse::Ok().body(response_json)
}

// 記錄廣告事件的處理函式
async fn track_ad_event(
    app_state: web::Data<AppState>,
    event_data: web::Json<serde_json::Value>,
) -> impl Responder {
    // 記錄廣告事件到Redis用於後續分析
    let mut redis_conn = app_state.redis.lock().await;
    let _: () = redis_conn.lpush(
        "ad_events", 
        serde_json::to_string(&event_data.0).unwrap()
    ).unwrap();
    
    HttpResponse::Ok().json("事件已記錄")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 初始化Redis客戶端
    let redis_client = RedisClient::open("redis://127.0.0.1:6379").unwrap();
    let redis_conn = redis_client.get_connection().unwrap();
    let redis_conn = Arc::new(Mutex::new(redis_conn));
    
    // 建立分享狀態
    let app_state = web::Data::new(AppState {
        redis: redis_conn,
    });
    
    // 啟動HTTP伺服器
    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .route("/api/v1/request_ad", web::post().to(request_ad))
            .route("/api/v1/track_event", web::post().to(track_ad_event))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

import tensorflow as tf
import numpy as np
import redis
import json
import uvicorn
from fastapi import FastAPI, HTTPException, BackgroundTasks
from pydantic import BaseModel
from typing import List, Optional
import httpx
import time

# 初始化FastAPI應用
app = FastAPI(title="AI廣告決策引擎")

# Redis連線
redis_client = redis.Redis(host='localhost', port=6379, db=0)

# 載入預訓練的廣告推薦模型
ad_model = tf.keras.models.load_model('models/ad_recommendation_model')

# 使用者特徵正規化器
user_scaler = tf.keras.models.load_model('models/user_feature_scaler')

# 廣告函式庫lass AdCreative(BaseModel):
    ad_id: str
    brand: str
    category: str
    duration: int
    target_demographics: List[str]
    engagement_score: float

# 使用者狀態請求
class UserContextRequest(BaseModel):
    user_id: str
    content_id: str
    watch_time: float
    session_duration: int
    interaction_rate: float
    device_type: str
    time_of_day: int
    previous_skips: int
    completion_rate: float
    geo_location: str

# 廣告決策回應
class AdDecisionResponse(BaseModel):
    recommended_ad_id: str
    confidence_score: float
    placement_position: float  # 建議的廣告插入位置(秒)
    reasoning: str

# 廣告函式庫實際系統會從資料函式庫PI取得)
AD_INVENTORY = [
    AdCreative(
        ad_id="ad_001",
        brand="TechGadgets",
        category="electronics",
        duration=15,
        target_demographics=["tech_enthusiasts", "young_adults"],
        engagement_score=0.78
    ),
    AdCreative(
        ad_id="ad_002", 
        brand="HealthPlus",
        category="health",
        duration=30,
        target_demographics=["health_conscious", "middle_age"],
        engagement_score=0.65
    ),
    AdCreative(
        ad_id="ad_003",
        brand="EcoFriendly",
        category="sustainable_products",
        duration=20,
        target_demographics=["environmentalists", "high_income"],
        engagement_score=0.82
    ),
    # 更多廣告...
]

# 將使用者連貫的背景與環境轉換為模型輸入特徵
def prepare_user_features(user_context: UserContextRequest):
    # 從Redis取得使用者歷史資料
    user_history_key = f"user_history:{user_context.user_id}"
    user_history = redis_client.get(user_history_key)
    
    if user_history:
        history_data = json.loads(user_history)
        ad_response_rate = history_data.get("ad_response_rate", 0.5)
        content_preferences = history_data.get("content_preferences", {})
    else:
        ad_response_rate = 0.5  # 預設值
        content_preferences = {}

use redis::{Commands, Connection, RedisResult};

fn cache_ad(ad_id: &str, ad_content: &str, con: &mut Connection) -> RedisResult<()> {
    con.set_ex(ad_id, ad_content, 3600)?; // 快取一小時
    Ok(())
}

fn fetch_ad(ad_id: &str, con: &mut Connection) -> RedisResult<String> {
    con.get(ad_id)
}

fn main() {
    let client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let mut con = client.get_connection().unwrap();

    let ad_id = "ad_12345";
    let ad_content = "<video src='ad.mp4' autoplay></video>";

    cache_ad(ad_id, ad_content, &mut con).unwrap();
    let cached_ad = fetch_ad(ad_id, &mut con).unwrap();

    println!("Fetched Ad: {}", cached_ad);
}

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_ad(ad_html: &str) {
    let window: Window = web_sys::window().unwrap();
    let document: Document = window.document().unwrap();
    let body: Element = document.body().unwrap();

    let ad_element = document.create_element("div").unwrap();
    ad_element.set_inner_html(ad_html);
    body.append_child(&ad_element).unwrap();
}

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use redis::Commands;

#[derive(Serialize, Deserialize)]
struct AdRequest {
    user_id: String,
    video_id: String,
    context: String,
}

async fn serve_ad(ad_request: web::Json<AdRequest>) -> impl Responder {
    let redis_client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let mut conn = redis_client.get_connection().unwrap();
    
    let ad_key = format!("ad:{}:{}", ad_request.user_id, ad_request.video_id);
    let ad: Option<String> = conn.get(&ad_key).ok();

    match ad {
        Some(ad_data) => HttpResponse::Ok().json(ad_data),
        None => {
            let ad_data = fetch_ad_from_ai_engine(&ad_request.user_id, &ad_request.video_id);
            let _ = conn.set_ex(&ad_key, &ad_data, 3600);
            HttpResponse::Ok().json(ad_data)
        }
    }
}

fn fetch_ad_from_ai_engine(user_id: &str, video_id: &str) -> String {
    // 模擬AI驅動的廣告選擇機制
    format!("Ad for user {} watching {}", user_id, video_id)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/get_ad", web::post().to(serve_ad))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

import numpy as np
import tensorflow as tf
from sklearn.preprocessing import StandardScaler

# 載入預訓練模型
model = tf.keras.models.load_model("ad_selector_model.h5")

# 定義使用者行為資料處理函式
def predict_best_ad(watch_time, click_rate, device, location, interests):
    features = np.array([[watch_time, click_rate, device, location, interests]])
    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)

    ad_probability = model.predict(features_scaled)[0][0]
    return "ad_12345" if ad_probability > 0.75 else "ad_67890"

# 使用範例
watch_time = 200  # 秒數
click_rate = 0.65  # 65%互動率
device = 1  # 1代表行動裝置，0代表桌面裝置
location = 3  # 編碼後的位置資料
interests = 4  # 編碼後的興趣類別

selected_ad = predict_best_ad(watch_time, click_rate, device, location, interests)
print(f"選定廣告: {selected_ad}")

use redis::{Commands, Connection, RedisResult};

fn cache_ad(ad_id: &str, ad_content: &str, con: &mut Connection) -> RedisResult<()> {
    con.set_ex(ad_id, ad_content, 3600)?;
    Ok(())
}

fn fetch_ad(ad_id: &str, con: &mut Connection) -> RedisResult<String> {
    con.get(ad_id)
}

fn main() {
    let client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let mut con = client.get_connection().unwrap();

    let ad_id = "ad_12345";
    let ad_content = "<video src='ad.mp4' autoplay></video>";

    cache_ad(ad_id, ad_content, &mut con).unwrap();
    let cached_ad = fetch_ad(ad_id, &mut con).unwrap();

    println!("取得廣告: {}", cached_ad);
}

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_ad(ad_html: &str) {
    let window: Window = web_sys::window().unwrap();
    let document: Document = window.document().unwrap();
    let body: Element = document.body().unwrap();

    let ad_element = document.create_element("div").unwrap();
    ad_element.set_inner_html(ad_html);
    body.append_child(&ad_element).unwrap();
}

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use redis::Commands;
use std::sync::Mutex;

#[derive(Serialize, Deserialize)]
struct AdInsertionRequest {
    ad_id: String,
    event_id: String,
    position: String, // "pre", "mid", "post"
    ad_type: String,  // "mute", "fullscreen", "skippable", "non-skippable"
}

struct AppState {
    redis_client: Mutex<redis::Client>,
}

async fn insert_manual_ad(
    data: web::Data<AppState>,
    ad_request: web::Json<AdInsertionRequest>,
) -> impl Responder {
    let mut conn = data.redis_client.lock().unwrap().get_connection().unwrap();

    let ad_key = format!(
        "manual_ad:{}:{}",
        ad_request.event_id, ad_request.position
    );

    let ad_data = serde_json::to_string(&ad_request).unwrap();
    let _: () = conn.set_ex(ad_key, ad_data, 3600).unwrap(); // 快取1小時

    HttpResponse::Ok().json("廣告成功插入")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let redis_client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let shared_state = web::Data::new(AppState {
        redis_client: Mutex::new(redis_client),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(shared_state.clone())
            .route("/insert_ad", web::post().to(insert_manual_ad))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

import numpy as np
import tensorflow as tf
from sklearn.preprocessing import StandardScaler

# 載入預訓練的廣告時機預測模型
model = tf.keras.models.load_model("ad_timing_model.h5")

def suggest_ad_slot(viewer_count, chat_activity, event_type):
    features = np.array([[viewer_count, chat_activity, event_type]])
    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)

    ad_slot_probability = model.predict(features_scaled)[0][0]
    return "中段廣告" if ad_slot_probability > 0.75 else "開場廣告"

# 範例使用
viewer_count = 50000
chat_activity = 0.8  # 80% 參與度
event_type = 2  # 編碼事件類別（例如，2表示體育賽事，3表示音樂會）

recommended_slot = suggest_ad_slot(viewer_count, chat_activity, event_type)
print(f"建議的廣告時段: {recommended_slot}")

use actix::{Actor, StreamHandler};
use actix_web::{web, App, HttpRequest, HttpServer, HttpResponse};
use actix_web_actors::ws;

struct AdNotifier;

impl Actor for AdNotifier {
    type Context = ws::WebsocketContext<Self>;
}

impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for AdNotifier {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        if let Ok(ws::Message::Text(text)) = msg {
            ctx.text(format!("廣告廣播: {}", text));
        }
    }
}

async fn websocket_handler(req: HttpRequest, stream: web::Payload) -> actix_web::Result<HttpResponse> {
    ws::start(AdNotifier, &req, stream)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/ws/", web::get().to(websocket_handler))
    })
    .bind("127.0.0.1:8081")?
    .run()
    .await
}

import tensorflow as tf
import numpy as np
from sklearn.preprocessing import StandardScaler

# 定義模型架構
def build_ad_trigger_model():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(16, activation='relu', input_shape=(4,)),
        tf.keras.layers.Dense(8, activation='relu'),
        tf.keras.layers.Dense(1, activation='sigmoid')  # 機率輸出
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

# 訓練模型（使用預處理的使用者互動資料）
X_train = np.array([
    [120, 0.8, 1, 50],  # 觀看時間、互動率、裝置類別、網路速度
    [30, 0.5, 0, 20],  
    [180, 0.9, 1, 80],  
])

y_train = np.array([1, 0, 1])  # 1 = 顯示廣告, 0 = 跳過

model = build_ad_trigger_model()
model.fit(X_train, y_train, epochs=50, verbose=0)

# 預測廣告插入的函式
def should_trigger_ad(watch_time, interaction_rate, device_type, network_speed):
    features = np.array([[watch_time, interaction_rate, device_type, network_speed]])
    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)
    prediction = model.predict(features_scaled)
    return prediction[0][0] > 0.8

# 範例使用
watch_time = 150  # 秒
interaction_rate = 0.75  # 75% 參與度
device_type = 1  # 行動裝置
network_speed = 45  # Mbps

if should_trigger_ad(watch_time, interaction_rate, device_type, network_speed):
    print("觸發廣告")
else:
    print("跳過廣告")

import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# 載入使用者互動資料
user_data = np.array([
    [50, 1, 3],  # 觀看時間(分鐘)、互動程度(0-1)、類別偏好(ID)
    [20, 0.5, 1],
    [80, 0.9, 5],
    [15, 0.2, 2],
])

# 正規化資料
scaler = StandardScaler()
user_data_scaled = scaler.fit_transform(user_data)

# 訓練K-Means聚類別模型
num_clusters = 5
kmeans = KMeans(n_clusters=num_clusters, random_state=42, n_init=10)
user_clusters = kmeans.fit_predict(user_data_scaled)

# 根據聚類別分配推薦廣告的函式
def recommend_ads(user_profile):
    cluster = kmeans.predict([scaler.transform([user_profile])])[0]
    ad_candidates = get_ads_for_cluster(cluster)
    return ad_candidates

# 新使用者請求廣告的範例
new_user = [45, 0.8, 4]  # 新觀眾的行為側寫
recommended_ads = recommend_ads(new_user)

print(f"推薦廣告: {recommended_ads}")

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use redis::Commands;
use std::sync::Mutex;

#[derive(Serialize, Deserialize)]
struct AdRequest {
    user_id: String,
    video_id: String,
    decision: bool,  // AI產生的決策 (true = 顯示廣告)
}

struct AppState {
    redis_client: Mutex<redis::Client>,
}

async fn execute_ad_trigger(
    data: web::Data<AppState>,
    ad_request: web::Json<AdRequest>,
) -> impl Responder {
    if !ad_request.decision {
        return HttpResponse::Ok().json("廣告已跳過");
    }

    let mut conn = data.redis_client.lock().unwrap().get_connection().unwrap();
    let ad_key = format!("cached_ad:{}:{}", ad_request.user_id, ad_request.video_id);
    
    let ad_content: Option<String> = conn.get(&ad_key).ok();
    match ad_content {
        Some(ad) => HttpResponse::Ok().json(ad),
        None => HttpResponse::Ok().json("無可用的快取廣告"),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let redis_client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let shared_state = web::Data::new(AppState {
        redis_client: Mutex::new(redis_client),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(shared_state.clone())
            .route("/trigger_ad", web::post().to(execute_ad_trigger))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_ad(ad_html: &str) {
    let window: Window = web_sys::window().unwrap();
    let document: Document = window.document().unwrap();
    let body: Element = document.body().unwrap();

    let ad_element = document.create_element("div").unwrap();
    ad_element.set_inner_html(ad_html);
    body.append_child(&ad_element).unwrap();
}

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use redis::Commands;
use std::sync::Mutex;

#[derive(Serialize, Deserialize)]
struct AdRequest {
    user_id: String,
    cluster_id: u8,
}

struct AppState {
    redis_client: Mutex<redis::Client>,
}

async fn fetch_personalized_ad(
    data: web::Data<AppState>,
    ad_request: web::Json<AdRequest>,
) -> impl Responder {
    let mut conn = data.redis_client.lock().unwrap().get_connection().unwrap();
    
    let ad_key = format!("personalized_ad:{}", ad_request.cluster_id);
    let ad_content: Option<String> = conn.get(&ad_key).ok();

    match ad_content {
        Some(ad) => HttpResponse::Ok().json(ad),
        None => HttpResponse::Ok().json("No relevant ad found"),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let redis_client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let shared_state = web::Data::new(AppState {
        redis_client: Mutex::new(redis_client),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(shared_state.clone())
            .route("/get_ad", web::post().to(fetch_personalized_ad))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

use redis::{Commands, Connection, RedisResult};

fn cache_ad(cluster_id: u8, ad_content: &str, con: &mut Connection) -> RedisResult<()> {
    let ad_key = format!("personalized_ad:{}", cluster_id);
    con.set_ex(ad_key, ad_content, 3600)?;
    Ok(())
}

fn fetch_ad(cluster_id: u8, con: &mut Connection) -> RedisResult<String> {
    let ad_key = format!("personalized_ad:{}", cluster_id);
    con.get(ad_key)
}

fn main() {
    let client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let mut con = client.get_connection().unwrap();

    let cluster_id = 3;
    let ad_content = "<video src='ad.mp4' autoplay></video>";

    cache_ad(cluster_id, ad_content, &mut con).unwrap();
    let cached_ad = fetch_ad(cluster_id, &mut con).unwrap();

    println!("Fetched Ad: {}", cached_ad);
}

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_personalized_ad(ad_html: &str) {
    let window: Window = web_sys::window().unwrap();
    let document: Document = window.document().unwrap();
    let body: Element = document.body().unwrap();

    let ad_element = document.create_element("div").unwrap();
    ad_element.set_inner_html(ad_html);
    body.append_child(&ad_element).unwrap();
}

redis-cli set ad_cache_maxsize 1GB
redis-cli config set maxmemory-policy allkeys-lru

use redis::{Commands, Connection, RedisResult};
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::sync::Mutex;

#[derive(Serialize, Deserialize)]
struct AdRequest {
    ad_id: String,
    user_id: String,
}

struct AppState {
    redis_client: Mutex<redis::Client>,
}

fn cache_ad(ad_id: &str, ad_content: &str, con: &mut Connection) -> RedisResult<()> {
    con.set_ex(ad_id, ad_content, 3600)?; // 快取有效期1小時
    Ok(())
}

fn fetch_ad(ad_id: &str, con: &mut Connection) -> RedisResult<String> {
    con.get(ad_id)
}

async fn get_ad(
    data: web::Data<AppState>,
    ad_request: web::Json<AdRequest>,
) -> impl Responder {
    let mut conn = data.redis_client.lock().unwrap().get_connection().unwrap();
    let ad_key = format!("ad_cache:{}", ad_request.ad_id);

    match fetch_ad(&ad_key, &mut conn) {
        Ok(ad_content) => HttpResponse::Ok().json(ad_content),
        Err(_) => HttpResponse::NotFound().json("Ad not found in cache"),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let redis_client = redis::Client::open("redis://127.0.0.1/").unwrap();
    let shared_state = web::Data::new(AppState {
        redis_client: Mutex::new(redis_client),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(shared_state.clone())
            .route("/get_ad", web::post().to(get_ad))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

import redis
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler

# 模擬使用者資料（觀看時長、互動率、裝置類別、地區）
user_data = np.array([
    [120, 0.8, 1, 3],  
    [30, 0.5, 0, 1],  
    [180, 0.9, 1, 5],  
])

# 模擬廣告請求模式（1 = 經常請求，0 = 很少請求）
ad_demand = np.array([1, 0, 1])

# 訓練AI模型
scaler = StandardScaler()
user_data_scaled = scaler.fit_transform(user_data)
model = RandomForestClassifier(n_estimators=50)
model.fit(user_data_scaled, ad_demand)

# 預測廣告是否應該預載的函式
def should_preload_ad(watch_time, engagement, device, location):
    features = np.array([[watch_time, engagement, device, location]])
    features_scaled = scaler.transform(features)
    return model.predict(features_scaled)[0] == 1

# Redis整合
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

def cache_ad_if_needed(ad_id, ad_content, user_profile):
    if should_preload_ad(*user_profile):
        redis_client.setex(f"ad_cache:{ad_id}", 3600, ad_content)
        print(f"Ad {ad_id} preloaded in cache")

# 使用範例
user_profile = [90, 0.7, 1, 2]  # 模擬使用者
cache_ad_if_needed("ad_56789", "<video src='ad.mp4'></video>", user_profile)

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_cached_ad(ad_html: &str) {
    let window: Window = web_sys::window().unwrap();
    let document: Document = window.document().unwrap();
    let body: Element = document.body().unwrap();

    let ad_element = document.create_element("div").unwrap();
    ad_element.set_inner_html(ad_html);
    body.append_child(&ad_element).unwrap();
}

use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, Window};

#[wasm_bindgen]
pub fn render_ad(ad_html: &str) {
    let window: Window = web_sys::window().expect("No global `window` exists");
    let document: Document = window.document().expect("No global `document` exists");
    let body: Element = document.body().expect("Document has no body");

    let ad_container = document.create_element("div").expect("Failed to create element");
    ad_container.set_inner_html(ad_html);
    body.append_child(&ad_container).expect("Failed to append ad");
}

wasm-pack build --target web

import init, { render_ad } from "./pkg/ad_renderer.js";

async function loadAd() {
    await init();
    let adContent = "<video src='ad.mp4' autoplay></video>";
    render_ad(adContent);
}

loadAd();