#[derive(Debug, Clone)]
pub struct Employee {
    pub id: u64,
    pub name: String,
    pub base_salary: i64,
    pub bonus: i64,
}

pub struct PayrollCalculator;

impl PayrollCalculator {
    pub fn calculate_salary(&self, employee: &Employee) -> i64 {
        employee.base_salary + employee.bonus
    }
}

pub trait EmployeeRepository {
    fn save(&self, employee: &Employee) -> Result<(), String>;
}

pub struct SqlEmployeeRepository;

impl EmployeeRepository for SqlEmployeeRepository {
    fn save(&self, employee: &Employee) -> Result<(), String> {
        println!("save employee {} to database", employee.id);
        Ok(())
    }
}

pub struct EmployeeReporter;

impl EmployeeReporter {
    pub fn generate_report(&self, employee: &Employee) -> String {
        format!(
            "Employee Report => id: {}, name: {}, base_salary: {}, bonus: {}",
            employee.id, employee.name, employee.base_salary, employee.bonus
        )
    }
}

#[derive(Debug)]
pub struct SalesCustomer {
    pub lead_id: u64,
    pub name: String,
    pub contact: String,
    pub intention_level: u8,
}

#[derive(Debug)]
pub struct SupportCustomer {
    pub user_id: u64,
    pub nickname: String,
    pub active_ticket_count: u32,
}

#[derive(Debug)]
pub struct BillingCustomer {
    pub legal_entity_id: u64,
    pub company_name: String,
    pub tax_number: String,
    pub paid_amount: i64,
}

pub fn settle(req: SettleRequest) -> Result<SettleResponse, String> {
    // 1. 参数解析
    // 2. 成绩格式化
    // 3. 按模式分支
    // 4. 计算奖励
    // 5. 更新任务
    // 6. 发布事件
    // 7. 持久化
    // 8. 构建响应
    todo!()
}

pub fn process_game_mode_1(ctx: &SettlementContext) -> Result<SettlementResult, String> {
    let r1 = step1(ctx)?;
    let r2 = step2(ctx, r1)?;
    let r3 = step3(ctx, r2)?;
    let r4 = step4(ctx, r3)?;
    let r5 = step5(ctx, r4)?;
    Ok(r5)
}

use std::collections::HashMap;

#[derive(Debug, Clone, Copy)]
pub enum GameMode {
    Mode1,
    Mode2,
}

#[derive(Debug, Clone)]
pub struct Player {
    pub id: u64,
    pub base_score: i32,
}

#[derive(Debug, Clone)]
pub struct SettleRequest {
    pub mode: GameMode,
    pub players: Vec<Player>,
}

#[derive(Debug, Clone)]
pub struct SettlementContext {
    pub mode: GameMode,
    pub players: Vec<Player>,
}

impl SettlementContext {
    pub fn from_request(req: SettleRequest) -> Result<Self, String> {
        if req.players.is_empty() {
            return Err("players cannot be empty".to_string());
        }

        Ok(Self {
            mode: req.mode,
            players: req.players,
        })
    }
}

#[derive(Debug, Clone, Default)]
pub struct Reward {
    pub coins: i32,
}

#[derive(Debug, Clone)]
pub struct PlayerReward {
    pub player_id: u64,
    pub base_reward: Reward,
    pub total_reward: Reward,
}

#[derive(Debug, Default)]
pub struct SettlementResult {
    pub player_rewards: HashMap<u64, PlayerReward>,
    pub events: Vec<String>,
}

#[derive(Debug)]
pub struct SettleResponse {
    pub rewards: HashMap<u64, PlayerReward>,
    pub events: Vec<String>,
}

impl From<SettlementResult> for SettleResponse {
    fn from(result: SettlementResult) -> Self {
        Self {
            rewards: result.player_rewards,
            events: result.events,
        }
    }
}

pub trait Processor {
    fn process(
        &self,
        ctx: &SettlementContext,
        result: &mut SettlementResult,
    ) -> Result<(), String>;
}

pub trait ScoreCalculator {
    fn calculate(&self, player: &Player, ctx: &SettlementContext) -> i32;
    fn convert_to_reward(&self, score: i32) -> Reward;
}

pub struct DefaultScoreCalculator;

impl ScoreCalculator for DefaultScoreCalculator {
    fn calculate(&self, player: &Player, _ctx: &SettlementContext) -> i32 {
        player.base_score
    }

    fn convert_to_reward(&self, score: i32) -> Reward {
        Reward { coins: score * 10 }
    }
}

pub struct ScoreCalculationProcessor<C: ScoreCalculator> {
    pub calculator: C,
}

impl<C: ScoreCalculator> Processor for ScoreCalculationProcessor<C> {
    fn process(
        &self,
        ctx: &SettlementContext,
        result: &mut SettlementResult,
    ) -> Result<(), String> {
        for player in &ctx.players {
            let score = self.calculator.calculate(player, ctx);
            let reward = self.calculator.convert_to_reward(score);

            result.player_rewards.insert(
                player.id,
                PlayerReward {
                    player_id: player.id,
                    base_reward: reward.clone(),
                    total_reward: reward,
                },
            );
        }

        Ok(())
    }
}

pub trait MasterApprenticeService {
    fn bonus_rate(&self, player_id: u64) -> f32;
}

pub struct DefaultMasterApprenticeService;

impl MasterApprenticeService for DefaultMasterApprenticeService {
    fn bonus_rate(&self, player_id: u64) -> f32 {
        if player_id % 2 == 0 { 0.2 } else { 0.0 }
    }
}

pub struct MasterApprenticeProcessor<S: MasterApprenticeService> {
    pub service: S,
}

impl<S: MasterApprenticeService> Processor for MasterApprenticeProcessor<S> {
    fn process(
        &self,
        _ctx: &SettlementContext,
        result: &mut SettlementResult,
    ) -> Result<(), String> {
        for reward in result.player_rewards.values_mut() {
            let rate = self.service.bonus_rate(reward.player_id);
            let bonus = (reward.base_reward.coins as f32 * rate) as i32;
            reward.total_reward.coins += bonus;
        }

        Ok(())
    }
}

pub struct SettlementPipeline {
    processors: Vec<Box<dyn Processor>>,
}

impl SettlementPipeline {
    pub fn new(processors: Vec<Box<dyn Processor>>) -> Self {
        Self { processors }
    }

    pub fn execute(&self, ctx: &SettlementContext) -> Result<SettleResponse, String> {
        let mut result = SettlementResult::default();

        for processor in &self.processors {
            processor.process(ctx, &mut result)?;
        }

        Ok(result.into())
    }
}

pub struct SettlementPipelineFactory;

impl SettlementPipelineFactory {
    pub fn create_mode1_pipeline(&self) -> SettlementPipeline {
        SettlementPipeline::new(vec![
            Box::new(ScoreCalculationProcessor {
                calculator: DefaultScoreCalculator,
            }),
            Box::new(MasterApprenticeProcessor {
                service: DefaultMasterApprenticeService,
            }),
        ])
    }

    pub fn create_mode2_pipeline(&self) -> SettlementPipeline {
        SettlementPipeline::new(vec![
            Box::new(ScoreCalculationProcessor {
                calculator: DefaultScoreCalculator,
            }),
        ])
    }
}

pub struct Api {
    pipeline_factory: SettlementPipelineFactory,
}

impl Api {
    pub fn new() -> Self {
        Self {
            pipeline_factory: SettlementPipelineFactory,
        }
    }

    pub fn settle(&self, req: SettleRequest) -> Result<SettleResponse, String> {
        let ctx = SettlementContext::from_request(req)?;

        let pipeline = match ctx.mode {
            GameMode::Mode1 => self.pipeline_factory.create_mode1_pipeline(),
            GameMode::Mode2 => self.pipeline_factory.create_mode2_pipeline(),
        };

        pipeline.execute(&ctx)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn score_processor_should_convert_score_to_reward() {
        let ctx = SettlementContext {
            mode: GameMode::Mode1,
            players: vec![Player { id: 1, base_score: 10 }],
        };

        let processor = ScoreCalculationProcessor {
            calculator: DefaultScoreCalculator,
        };

        let mut result = SettlementResult::default();
        processor.process(&ctx, &mut result).unwrap();

        let reward = result.player_rewards.get(&1).unwrap();
        assert_eq!(reward.base_reward.coins, 100);
        assert_eq!(reward.total_reward.coins, 100);
    }

    #[test]
    fn master_apprentice_processor_should_apply_bonus() {
        let mut result = SettlementResult::default();
        result.player_rewards.insert(
            2,
            PlayerReward {
                player_id: 2,
                base_reward: Reward { coins: 100 },
                total_reward: Reward { coins: 100 },
            },
        );

        let processor = MasterApprenticeProcessor {
            service: DefaultMasterApprenticeService,
        };

        let ctx = SettlementContext {
            mode: GameMode::Mode1,
            players: vec![],
        };

        processor.process(&ctx, &mut result).unwrap();

        let reward = result.player_rewards.get(&2).unwrap();
        assert_eq!(reward.total_reward.coins, 120);
    }
}

use std::marker::PhantomData;

struct Disconnected;
struct Connected;

struct Socket<State> {
    fd: i32,
    _state: PhantomData<State>,
}

impl Socket<Disconnected> {
    fn connect(self, addr: &str) -> Socket<Connected> {
        // ... connect logic ...
        Socket { fd: self.fd, _state: PhantomData }
    }
}

impl Socket<Connected> {
    fn send(&mut self, data: &[u8]) { /* ... */ }
    fn disconnect(self) -> Socket<Disconnected> {
        Socket { fd: self.fd, _state: PhantomData }
    }
}

// Socket<Disconnected> has no send() method — compile error if you try

struct Socket {
    is_connected: bool,
    fd: i32,
}

impl Socket {
    fn send(&self, data: &[u8]) {
        if !self.is_connected {
            panic!("还没连接呢！不能发数据！"); // 这种错误只有在程序运行时才会发现
        }
        // ...
    }
}

struct Disconnected; // 状态 A：断开
struct Connected;    // 状态 B：连接

struct Socket<State> {
    fd: i32,
    _state: PhantomData<State>, // 告诉编译器：这个 Socket 现在处于 State 状态
}

let socket = Socket { fd: 1, _state: PhantomData }; // 默认是 Disconnected

// ❌ 编译报错！
// 编译器会说：Socket<Disconnected> 没定义 send 方法
// 你在写代码阶段就能发现错误，而不是等程序跑起来崩溃
socket.send(b"hello"); 

// ✅ 必须先 connect
let mut connected_socket = socket.connect("127.0.0.1");

// ✅ 现在可以 send 了，因为类型变成了 Socket<Connected>
connected_socket.send(b"hello");

// ❌ 再次报错！
// 一旦调用 disconnect，变量会被消耗，不能再调用 send
let closed_socket = connected_socket.disconnect();
connected_socket.send(b"bye"); // 编译报错：Value used after move

use std::io;

trait IpmiCmd {
    type Response;
    fn parse_response(&self, raw: &[u8]) -> io::Result<Self::Response>;
}

// Simplified for illustration — see ch02 for the full trait with
// net_fn(), cmd_byte(), payload(), and parse_response().

struct ReadTemp { sensor_id: u8 }
impl IpmiCmd for ReadTemp {
    type Response = Celsius;
    fn parse_response(&self, raw: &[u8]) -> io::Result<Celsius> {
        Ok(Celsius(raw[0] as i8 as f64))
    }
}


fn execute<C: IpmiCmd>(cmd: &C, raw: &[u8]) -> io::Result<C::Response> {
    cmd.parse_response(raw)
}
// ReadTemp always returns Celsius — can't accidentally get Rpm

trait IpmiCmd {
    type Response; // 关联类型：每个命令必须定义它对应的返回类型
    fn parse_response(&self, raw: &[u8]) -> io::Result<Self::Response>;
}

struct ReadTemp { sensor_id: u8 }

impl IpmiCmd for ReadTemp {
    type Response = Celsius; // 绑定：ReadTemp 命令只能返回 Celsius 类型

    fn parse_response(&self, raw: &[u8]) -> io::Result<Celsius> {
        // 将原始字节解析为 Celsius 结构体
        Ok(Celsius(raw[0] as i8 as f64))
    }
}

fn execute<C: IpmiCmd>(cmd: &C, raw: &[u8]) -> io::Result<C::Response> {
    cmd.parse_response(raw)
}

#[derive(Debug, Clone)]
pub struct Order {
    pub id: u64,
    pub price: f64,
}

// 1. 定义 "契约" (What) —— 相当于 Go 的 Interface
pub trait OrderRepository: Send + Sync {
    fn save(&self, order: &Order) -> Result<(), String>;
}

// 2. "不变" 的业务逻辑
pub struct OrderService<R: OrderRepository> {
    repo: R, // 依赖于契约 R
}

impl<R: OrderRepository> OrderService<R> {
    // 构造函数，注入具体的实现
    pub fn new(repo: R) -> Self {
        Self { repo }
    }

    pub fn create_order(&self, order: Order) -> Result<(), String> {
        // 1. 核心业务逻辑 (100% 纯粹)
        if order.price < 0.0 {
            return Err("价格错误".to_string());
        }

        // 2. 调用 "契约"，不关心底层是 MySQL, PostgreSQL 还是内存
        self.repo.save(&order)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Mutex;

    // 3. 定义一个 Mock 实现
    struct MockRepo {
        saved_orders: Mutex<Vec<Order>>,
    }

    impl OrderRepository for MockRepo {
        fn save(&self, order: &Order) -> Result<(), String> {
            let mut orders = self.saved_orders.lock().unwrap();
            orders.push(order.clone());
            Ok(())
        }
    }

    #[test]
    fn test_create_order_logic() {
        // 准备 Mock 环境
        let mock_repo = MockRepo { saved_orders: Mutex::new(vec![]) };
        let service = OrderService::new(mock_repo);

        // 测试业务逻辑：价格错误
        let bad_order = Order { id: 1, price: -10.0 };
        assert!(service.create_order(bad_order).is_err());

        // 测试业务逻辑：成功保存
        let good_order = Order { id: 2, price: 100.0 };
        assert!(service.create_order(good_order).is_ok());
    }
}

struct SqliteRepository {
    // db: SqlitePool, 
}

impl OrderRepository for SqliteRepository {
    fn save(&self, order: &Order) -> Result<(), String> {
        println!("正在将订单 {} 写入 SQLite 数据库...", order.id);
        // 这里写真正的 SQL 逻辑
        Ok(())
    }
}

fn main() {
    // 在程序入口处（组合根）完成注入
    let repo = SqliteRepository {};
    let service = OrderService::new(repo);
    
    let _ = service.create_order(Order { id: 101, price: 50.0 });
}

use async_trait::async_trait;

#[derive(Debug, Clone)]
pub struct Order { pub id: u64, pub price: f64 }

#[async_trait]
pub trait OrderRepository: Send + Sync {
    async fn save(&self, order: &Order) -> Result<(), String>;
}

pub struct SqliteRepo;

#[async_trait]
impl OrderRepository for SqliteRepo {
    async fn save(&self, order: &Order) -> Result<(), String> {
        println!("  [DB层] 正在将订单 {} 存入 Sqlite...", order.id);
        Ok(())
    }
}

pub struct CachedOrderRepo<T: OrderRepository> {
    inner: T,           // "下一层"是谁？我不关心，只要它实现了 OrderRepository
    redis_addr: String, // 模拟 Redis 连接
}

impl<T: OrderRepository> CachedOrderRepo<T> {
    pub fn new(inner: T, addr: &str) -> Self {
        Self { inner, redis_addr: addr.to_string() }
    }
}

#[async_trait]
impl<T: OrderRepository> OrderRepository for CachedOrderRepo<T> {
    async fn save(&self, order: &Order) -> Result<(), String> {
        // 1. 调用下一层（底层的数据库写入）
        self.inner.save(order).await?;

        // 2. 增加"副作用"：写入缓存
        println!("  [缓存层] 正在将订单 {} 写入 Redis ({})", order.id, self.redis_addr);
        
        Ok(())
    }
}

pub struct OrderService<R: OrderRepository> {
    repo: R,
}

impl<R: OrderRepository> OrderService<R> {
    pub fn new(repo: R) -> Self { Self { repo } }

    pub async fn create_order(&self, order: Order) -> Result<(), String> {
        // 核心业务校验
        if order.price < 0.0 { return Err("价格错误".to_string()); }

        // 直接调用契约
        self.repo.save(&order).await
    }
}

#[tokio::main]
async fn main() {
    // --- 方案 A: 原始版本 ---
    // let repo = SqliteRepo;
    // let service = OrderService::new(repo);

    // --- 方案 B: 带缓存的版本 ---
    let sqlite_repo = SqliteRepo;
    // 像套娃一样，把 sqlite 塞进 cached repo
    let cached_repo = CachedOrderRepo::new(sqlite_repo, "redis://127.0.0.1");
    // 把装好的 cached_repo 塞进 service
    let service = OrderService::new(cached_repo);

    // 调用
    let my_order = Order { id: 888, price: 99.0 };
    service.create_order(my_order).await.unwrap();
}

pub struct RetryOrderRepo<T: OrderRepository> {
    inner: T,
    max_attempts: usize,
}

impl<T: OrderRepository> RetryOrderRepo<T> {
    pub fn new(inner: T, max_attempts: usize) -> Self {
        Self { inner, max_attempts }
    }
}

#[async_trait]
impl<T: OrderRepository> OrderRepository for RetryOrderRepo<T> {
    async fn save(&self, order: &Order) -> Result<(), String> {
        let mut last_error = String::new();

        for attempt in 1..=self.max_attempts {
            println!("  [重试层] 正在进行第 {} 次尝试...", attempt);
            
            match self.inner.save(order).await {
                Ok(()) => return Ok(()), // 成功了，直接返回
                Err(e) => {
                    last_error = e;
                    println!("  [重试层] 第 {} 次尝试失败: {}", attempt, last_error);
                }
            }
        }

        Err(format!("在 {} 次重试后仍然失败: {}", self.max_attempts, last_error))
    }
}

#[tokio::main]
async fn main() {
    // 1. 最底层：数据库
    let sqlite_repo = SqliteRepo;

    // 2. 中间层：加个缓存
    let cached_repo = CachedOrderRepo::new(sqlite_repo, "redis://127.0.0.1");

    // 3. 最外层包装：加个重试（比如最多尝试 3 次）
    let retry_repo = RetryOrderRepo::new(cached_repo, 3);

    // 4. 注入业务层
    let service = OrderService::new(retry_repo);

    // 运行
    let my_order = Order { id: 999, price: 150.0 };
    if let Err(e) = service.create_order(my_order).await {
        println!("最终执行失败: {}", e);
    } else {
        println!("最终执行成功！");
    }
}

use async_trait::async_trait;

// --- 1. 定义契约 (What) ---
#[async_trait]
pub trait SmsService: Send + Sync {
    async fn send(&self, phone: &str, code: &str) -> Result<(), String>;
}

// --- 2. 业务逻辑只依赖契约 ---
pub struct UserService<S: SmsService> {
    sms: S, // 也可以用 Box<dyn SmsService> 支持运行时切换
}

impl<S: SmsService> UserService<S> {
    pub fn new(sms: S) -> Self { Self { sms } }

    pub async fn register(&self, phone: &str) -> Result<(), String> {
        println!("[业务逻辑] 开始注册用户: {}", phone);
        let code = "123456"; // 模拟生成验证码
        
        // 调用契约，不关心背后是哪家云厂商
        self.sms.send(phone, code).await?;
        
        println!("[业务逻辑] 注册成功！");
        Ok(())
    }
}

// 实现 A：腾讯云 (生产环境)
pub struct TencentSms { api_key: String }
#[async_trait]
impl SmsService for TencentSms {
    async fn send(&self, phone: &str, code: &str) -> Result<(), String> {
        println!("  [腾讯云] 调用 SDK 发送短信至 {}，验证码：{}", phone, code);
        Ok(())
    }
}

// 实现 B：阿里云 (备用环境)
pub struct AliyunSms { secret_id: String }
#[async_trait]
impl SmsService for AliyunSms {
    async fn send(&self, phone: &str, code: &str) -> Result<(), String> {
        println!("  [阿里云] 调用 SDK 发送短信至 {}，验证码：{}", phone, code);
        Ok(())
    }
}

// 实现 C：日志短信 (本地开发/单元测试)
pub struct LogSms;
#[async_trait]
impl SmsService for LogSms {
    async fn send(&self, phone: &str, code: &str) -> Result<(), String> {
        // 不花钱，不连网，只打日志
        println!("  [本地模拟] 模拟发送短信至 {}，验证码：{}", phone, code);
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    // 场景 1：本地开发
    // 只需要传入 LogSms，不需要配置任何云账号，不需要联网
    let dev_service = UserService::new(LogSms);
    dev_service.register("13800138000").await.unwrap();

    // 场景 2：线上生产（使用腾讯云）
    let prod_sms = TencentSms { api_key: "TX_123".to_string() };
    let prod_service = UserService::new(prod_sms);
    prod_service.register("13911112222").await.unwrap();
}

pub struct FailoverSms {
    primary: TencentSms,
    secondary: AliyunSms,
}

#[async_trait]
impl SmsService for FailoverSms {
    async fn send(&self, phone: &str, code: &str) -> Result<(), String> {
        // 先尝试腾讯云
        match self.primary.send(phone, code).await {
            Ok(_) => Ok(()),
            Err(_) => {
                // 如果腾讯云挂了，自动切换到阿里云
                println!("!!! 腾讯云异常，正在切换到阿里云备用通道...");
                self.secondary.send(phone, code).await
            }
        }
    }
}