pub struct TransferEngine {
    config: TransferConfig,
}

pub struct TransferConfig {
    pub max_rounds: i64,           // 最大轮次 (8)
    pub min_roster_size: i64,      // 最小阵容 (5)
    pub max_roster_size: i64,      // 最大阵容 (8)
    pub contract_duration: i64,    // 默认合同年限 (3)
    pub salary_cap_ratio: f64,     // 薪资占比上限 (0.6)
}

pub struct TransferWindowResponse {
    pub window_id: i64,
    pub season_id: i64,
    pub status: String,          // "IN_PROGRESS" | "COMPLETED"
    pub current_round: i64,
}

pub struct RoundResult {
    pub round: i64,
    pub round_name: String,
    pub events: Vec<TransferEvent>,
    pub summary: String,
}

pub struct TransferEvent {
    pub id: i64,
    pub window_id: i64,
    pub round: i64,
    pub event_type: String,
    pub player_id: Option<i64>,
    pub player_name: Option<String>,
    pub from_team_id: Option<i64>,
    pub from_team_name: Option<String>,
    pub to_team_id: Option<i64>,
    pub to_team_name: Option<String>,
    pub transfer_fee: Option<i64>,
    pub salary: Option<i64>,
    pub contract_years: Option<i64>,
    pub level: String,           // "MAJOR" | "MINOR" | "INFO"
    pub description: String,
}

pub enum AITeamPersonality {
    Aggressive,   // 激进型 - 高风险高回报
    Balanced,     // 平衡型 - 稳健经营
    Conservative, // 保守型 - 稳定优先
    Youth,        // 青训型 - 培养新人
    StarHunter,   // 追星型 - 追逐明星
    Bargain,      // 淘金型 - 寻找性价比
}

impl AITeamPersonality {
    pub fn default_weights(&self) -> PersonalityWeights {
        match self {
            Aggressive => PersonalityWeights {
                short_term_focus: 0.8,
                risk_tolerance: 0.9,
                star_chasing: 0.7,
                ..
            },
            Youth => PersonalityWeights {
                youth_preference: 0.9,
                long_term_focus: 0.8,
                bargain_hunting: 0.6,
                ..
            },
            // ...
        }
    }
}

pub struct TeamPersonalityConfig {
    pub id: i64,
    pub team_id: i64,
    pub save_id: String,
    pub personality: String,
    pub short_term_focus: f64,   // 短期目标权重
    pub long_term_focus: f64,    // 长期目标权重
    pub risk_tolerance: f64,     // 风险容忍度
    pub youth_preference: f64,   // 年轻球员偏好
    pub star_chasing: f64,       // 明星追逐度
    pub bargain_hunting: f64,    // 性价比导向
}

pub struct TeamReputation {
    pub team_id: i64,
    pub reputation_score: f64,    // 声望分 (0-100)
    pub reputation_tier: String,  // 档次
    pub recent_titles: i64,       // 近期冠军数
    pub historical_titles: i64,   // 历史冠军数
    pub average_ability: f64,     // 平均能力值
    pub financial_health: f64,    // 财务健康度
}

fn calculate_willingness(
    &self,
    _ability: u8,
    loyalty: u8,
    _age: u8,
    offered_salary: i64,
    current_salary: i64,
    home_region_id: Option<i64>,   // 选手出生赛区
    target_region_id: Option<i64>, // 目标球队赛区
    region_loyalty: i64,           // 赛区偏好值
    rng: &mut impl Rng,
) -> f64 {
    // ... 薪资、忠诚度计算 ...
    let base_willingness = (base + random_factor).clamp(0.0, 100.0);

    // 跨赛区惩罚
    let cross_region_factor = match (home_region_id, target_region_id) {
        (Some(home), Some(target)) if home != target => {
            // 跨赛区转会，意愿度乘以 (100 - region_loyalty) / 100
            (100.0 - region_loyalty as f64) / 100.0
        }
        _ => 1.0  // 本赛区无惩罚
    };

    base_willingness * cross_region_factor
}

pub struct TransferOffer {
    pub team_id: i64,
    pub player_id: i64,
    pub offered_salary: i64,
    pub contract_years: i64,
    pub transfer_fee: i64,
    pub signing_bonus: i64,
    pub match_score: f64,
    pub priority: f64,
    pub target_region_id: Option<i64>,  // 目标球队赛区ID（用于跨赛区转会意愿计算）
}

let region_loyalty: i64 = match region_id {
    1 => 75 + (rand::random::<u8>() % 16) as i64,  // LPL: 75-90
    2 => 55 + (rand::random::<u8>() % 21) as i64,  // LCK: 55-75
    3 => 45 + (rand::random::<u8>() % 21) as i64,  // LEC: 45-65
    4 => 40 + (rand::random::<u8>() % 21) as i64,  // LCS: 40-60
    _ => 60,
};

-- 添加字段
ALTER TABLE players ADD COLUMN home_region_id INTEGER;
ALTER TABLE players ADD COLUMN region_loyalty INTEGER NOT NULL DEFAULT 70;

-- 初始化现有选手的 home_region_id（根据当前球队的赛区）
UPDATE players SET home_region_id = (
    SELECT t.region_id FROM teams t WHERE t.id = players.team_id
) WHERE team_id IS NOT NULL AND home_region_id IS NULL;

-- 根据赛区设置 region_loyalty
UPDATE players SET region_loyalty = CASE
    WHEN home_region_id = 1 THEN 75 + ABS(RANDOM() % 16)  -- LPL
    WHEN home_region_id = 2 THEN 55 + ABS(RANDOM() % 21)  -- LCK
    WHEN home_region_id = 3 THEN 45 + ABS(RANDOM() % 21)  -- LEC
    WHEN home_region_id = 4 THEN 40 + ABS(RANDOM() % 21)  -- LCS
    ELSE 60
END WHERE home_region_id IS NOT NULL;

// 开始转会期
export async function startTransferWindow(): Promise<TransferWindowResponse>

// 执行单轮
export async function executeTransferRound(windowId: number, round: number): Promise<RoundExecutionResponse>

// 快进
export async function fastForwardTransfer(windowId: number, fromRound?: number): Promise<FastForwardResponse>

// 获取事件
export async function getTransferEvents(windowId: number, round?: number, level?: string): Promise<TransferEvent[]>

// 获取报告
export async function getTransferReport(windowId: number): Promise<TransferReport>

// 获取/更新球队性格
export async function getTeamPersonality(teamId: number): Promise<TeamPersonalityConfig>
export async function updateTeamPersonality(teamId: number, request: UpdatePersonalityRequest): Promise<boolean>

// 获取球队声望
export async function getTeamReputation(teamId: number): Promise<TeamReputation>

// 年龄增长
new_age = age + 1;

// 能力成长 (30岁前)
if age <= 30 && ability < potential {
    new_ability = min(ability + tag_growth, potential, 100);
}

// 能力衰退 (30岁后)
if age > 30 {
    new_ability = max(ability - 1, 50);
}

// 退役检查
if age >= 35 && ability < 51 {
    status = "RETIRED";
}

sell_prob = 财务动机 × 签位留存 × 阵容系数 × 球队实力系数

const response = await startTransferWindow()
console.log(`转会期ID: ${response.window_id}`)

for (let round = 1; round <= 8; round++) {
    const result = await executeTransferRound(windowId, round)
    console.log(`第${round}轮: ${result.round_name}`)
    console.log(`事件数: ${result.events.length}`)
}

const result = await fastForwardTransfer(windowId, 1)
console.log(`完成${result.completed_rounds}轮`)
console.log(`总事件: ${result.total_events}`)

await updateTeamPersonality(teamId, {
    personality: "YOUTH",
    youth_preference: 0.9,
    long_term_focus: 0.8,
})

CREATE TABLE transfer_windows (
    id INTEGER PRIMARY KEY,
    save_id TEXT NOT NULL,
    season_id INTEGER NOT NULL,
    status TEXT DEFAULT 'IN_PROGRESS',
    current_round INTEGER DEFAULT 0,
    started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    completed_at TIMESTAMP
);

CREATE TABLE transfer_events (
    id INTEGER PRIMARY KEY,
    window_id INTEGER NOT NULL,
    round INTEGER NOT NULL,
    event_type TEXT NOT NULL,
    player_id INTEGER,
    from_team_id INTEGER,
    to_team_id INTEGER,
    transfer_fee INTEGER,
    salary INTEGER,
    contract_years INTEGER,
    level TEXT DEFAULT 'MINOR',
    description TEXT
);

CREATE TABLE team_personality_configs (
    id INTEGER PRIMARY KEY,
    team_id INTEGER UNIQUE,
    save_id TEXT,
    personality TEXT,
    short_term_focus REAL,
    long_term_focus REAL,
    risk_tolerance REAL,
    youth_preference REAL,
    star_chasing REAL,
    bargain_hunting REAL
);