#include <iostream>
#include <vector>
#include <string>
#include <random>
#include <algorithm>
#include <fstream>
#include <ctime>
#include <memory>
#include <map>
#include <bits/stdc++.h>
using namespace std;

// 球员类
class Player {
private:
    string name;        // 姓名
    int age;            // 年龄
    string position;    // 位置
    int overall;        // 综合能力
    int potential;      // 潜力
    int contractYears;  // 合同年数
    double salary;      // 薪水
    bool isInjured;     // 是否受伤
    bool isOnTradeBlock;// 是否在交易名单上

public:
    Player(string name, int age, string position, int overall, int potential, int contractYears, double salary)
        : name(name), age(age), position(position), overall(overall), potential(potential),
          contractYears(contractYears), salary(salary), isInjured(false), isOnTradeBlock(false) {}

    string getName() const { return name; }
    int getAge() const { return age; }
    string getPosition() const { return position; }
    int getOverall() const { return overall; }
    int getPotential() const { return potential; }
    int getContractYears() const { return contractYears; }
    double getSalary() const { return salary; }
    bool getIsInjured() const { return isInjured; }
    bool getIsOnTradeBlock() const { return isOnTradeBlock; }

    void setOverall(int newOverall) { overall = newOverall; }
    void setPotential(int newPotential) { potential = newPotential; }
    void setContractYears(int years) { contractYears = years; }
    void setSalary(double newSalary) { salary = newSalary; }
    void setIsInjured(bool injured) { isInjured = injured; }
    void setIsOnTradeBlock(bool onTradeBlock) { isOnTradeBlock = onTradeBlock; }

    void agePlayer() {
        age++;
        // 随机提升或下降能力值，取决于潜力和年龄
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> dis(-3, 3);
        int change = dis(gen);
        
        // 年龄较大的球员更可能下降
        if (age > 30) {
            if (change > 0) change = 0;
            change -= 1;
        } else if (age < 25 && potential > 80) {
            if (change < 0) change = 0;
            change += 1;
        }
        
        overall = max(50, min(99, overall + change));
    }

    void simulateInjury() {
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> dis(1, 100);
        int injuryChance = dis(gen);
        
        // 年龄较大的球员更容易受伤
        if (age > 30 && injuryChance < 15) {
            isInjured = true;
        } else if (injuryChance < 5) {
            isInjured = true;
        } else {
            isInjured = false;
        }
    }

    string getPositionShort() const {
        if (position == "控球后卫") return "PG";
        if (position == "得分后卫") return "SG";
        if (position == "小前锋") return "SF";
        if (position == "大前锋") return "PF";
        return "C"; // 中锋
    }

    void displayInfo() const {
        cout << name << " (" << getPositionShort() << ") | 年龄: " << age
             << " | 能力值: " << overall << " | 潜力: " << potential
             << " | 合同: " << contractYears << "年, $" << salary / 1000000 << "百万/年";
        if (isInjured) cout << " | 受伤";
        if (isOnTradeBlock) cout << " | 交易名单";
        cout << endl;
    }
};

// 球队类
class Team {
private:
    string name;            // 队名
    string city;            // 所在城市
    vector<shared_ptr<Player>> roster; // 球员名单
    double salaryCap;       // 工资帽
    double currentSalary;   // 当前工资总额
    int wins;               // 胜场数
    int losses;             // 负场数
    int draftPick;          // 选秀顺位
    map<string, int> teamChemistry; // 球队化学反应

public:
    Team(string name, string city, double salaryCap)
        : name(name), city(city), salaryCap(salaryCap), currentSalary(0), wins(0), losses(0), draftPick(15) {
        // 初始化球队化学反应
        teamChemistry["PG"] = 70;
        teamChemistry["SG"] = 70;
        teamChemistry["SF"] = 70;
        teamChemistry["PF"] = 70;
        teamChemistry["C"] = 70;
    }

    string getName() const { return name; }
    string getCity() const { return city; }
    vector<shared_ptr<Player>> getRoster() const { return roster; }
    double getSalaryCap() const { return salaryCap; }
    double getCurrentSalary() const { return currentSalary; }
    int getWins() const { return wins; }
    int getLosses() const { return losses; }
    int getDraftPick() const { return draftPick; }
    double getWinPercentage() const {
        if (wins + losses == 0) return 0.0;
        return static_cast<double>(wins) / (wins + losses);
    }

    void addPlayer(shared_ptr<Player> player) {
        roster.push_back(player);
        currentSalary += player->getSalary();
    }

    void removePlayer(shared_ptr<Player> player) {
        for (auto it = roster.begin(); it != roster.end(); ++it) {
            if (*it == player) {
                currentSalary -= player->getSalary();
                roster.erase(it);
                break;
            }
        }
    }

    void updateChemistry() {
        // 简单模拟化学反应变化
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> dis(-3, 3);
        
        for (auto& pair : teamChemistry) {
            pair.second = max(50, min(99, pair.second + dis(gen)));
        }
    }

    void displayRoster() const {
        cout << "\n" << city << " " << name << " 球员名单:" << endl;
        cout << "----------------------------------------" << endl;
        for (const auto& player : roster) {
            player->displayInfo();
        }
        cout << "\n球队薪资: $" << currentSalary / 1000000 << "百万 / $" << salaryCap / 1000000 << "百万" << endl;
        cout << "战绩: " << wins << "-" << losses << endl;
    }

    void simulateSeason() {
        // 模拟82场比赛的赛季
        for (int i = 0; i < 82; i++) {
            random_device rd;
            mt19937 gen(rd());
            uniform_int_distribution<> dis(1, 100);
            int result = dis(gen);
            
            // 根据球队实力决定胜负
            int teamStrength = calculateTeamStrength();
            if (result <= teamStrength) {
                wins++;
            } else {
                losses++;
            }
        }
        
        // 更新选秀顺位
        updateDraftPick();
    }

    int calculateTeamStrength() const {
        int strength = 0;
        for (const auto& player : roster) {
            if (!player->getIsInjured()) {
                strength += player->getOverall();
            }
        }
        
        // 添加化学反应因素
        for (const auto& pair : teamChemistry) {
            strength += pair.second;
        }
        
        // 调整为百分比
        return min(95, max(5, strength / 25));
    }

    void updateDraftPick() {
        // 模拟乐透抽签，战绩越差抽中高顺位概率越高
        double winPct = getWinPercentage();
        random_device rd;
        mt19937 gen(rd());
        uniform_real_distribution<> dis(0.0, 1.0);
        double lotteryResult = dis(gen);
        
        // 简单的概率模型
        if (winPct < 0.3) {
            if (lotteryResult < 0.25) draftPick = 1;
            else if (lotteryResult < 0.55) draftPick = 2;
            else if (lotteryResult < 0.8) draftPick = 3;
            else draftPick = 4 + (rand() % 4); // 4-7
        } else if (winPct < 0.45) {
            draftPick = 5 + (rand() % 5); // 5-9
        } else if (winPct < 0.6) {
            draftPick = 10 + (rand() % 7); // 10-16
        } else {
            draftPick = 15 + (rand() % 10); // 15-24
        }
    }

    void ageRoster() {
        for (const auto& player : roster) {
            player->agePlayer();
        }
    }

    void simulateInjuries() {
        for (const auto& player : roster) {
            player->simulateInjury();
        }
    }

    void resetSeason() {
        wins = 0;
        losses = 0;
        updateChemistry();
    }

    void setDraftPick(int pick) { draftPick = pick; }

    // 为交易做准备，返回球员列表（不包括不可交易的球员）
    vector<shared_ptr<Player>> getTradeablePlayers() const {
        vector<shared_ptr<Player>> tradeable;
        for (const auto& player : roster) {
            if (!player->getIsInjured()) {
                tradeable.push_back(player);
            }
        }
        return tradeable;
    }
};

// 选秀类
class Draft {
private:
    vector<shared_ptr<Player>> prospects; // 新秀列表

public:
    Draft() {
        // 生成60名新秀
        generateProspects();
    }

    void generateProspects() {
        prospects.clear();
        
        vector<string> firstNames = {"约翰", "迈克尔", "大卫", "詹姆斯", "罗伯特", "丹尼尔", "马修", "安德鲁", "约瑟夫", "瑞安", 
                                     "贾斯汀", "布兰登", "克里斯托弗", "托马斯", "乔纳森", "凯文", "布莱恩", "爱德华", "贾森", "蒂莫西"};
        vector<string> lastNames = {"史密斯", "约翰逊", "威廉姆斯", "琼斯", "布朗", "戴维斯", "米勒", "威尔逊", "摩尔", "泰勒", 
                                    "安德森", "托马斯", "杰克逊", "怀特", "哈里斯", "马丁", "汤普森", "加西亚", "马丁内斯", "罗宾逊"};
        vector<string> positions = {"控球后卫", "得分后卫", "小前锋", "大前锋", "中锋"};

        random_device rd;
        mt19937 gen(rd());
        
        // 乐透秀
        for (int i = 0; i < 14; i++) {
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            string position = positions[rand() % positions.size()];
            int age = 19 + (rand() % 3);
            
            // 乐透秀能力值范围
            uniform_int_distribution<> overallDis(75, 88);
            uniform_int_distribution<> potentialDis(85, 95);
            
            int overall = overallDis(gen);
            int potential = potentialDis(gen);
            
            prospects.push_back(make_shared<Player>(name, age, position, overall, potential, 4, (overall - 60) * 1000000));
        }
        
        // 首轮中段
        for (int i = 0; i < 10; i++) {
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            string position = positions[rand() % positions.size()];
            int age = 20 + (rand() % 3);
            
            // 首轮中段能力值范围
            uniform_int_distribution<> overallDis(68, 77);
            uniform_int_distribution<> potentialDis(75, 85);
            
            int overall = overallDis(gen);
            int potential = potentialDis(gen);
            
            prospects.push_back(make_shared<Player>(name, age, position, overall, potential, 4, (overall - 60) * 750000));
        }
        
        // 首轮末段
        for (int i = 0; i < 8; i++) {
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            string position = positions[rand() % positions.size()];
            int age = 21 + (rand() % 3);
            
            // 首轮末段能力值范围
            uniform_int_distribution<> overallDis(63, 72);
            uniform_int_distribution<> potentialDis(70, 80);
            
            int overall = overallDis(gen);
            int potential = potentialDis(gen);
            
            prospects.push_back(make_shared<Player>(name, age, position, overall, potential, 4, (overall - 60) * 500000));
        }
        
        // 次轮
        for (int i = 0; i < 28; i++) {
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            string position = positions[rand() % positions.size()];
            int age = 22 + (rand() % 4);
            
            // 次轮能力值范围
            uniform_int_distribution<> overallDis(55, 67);
            uniform_int_distribution<> potentialDis(60, 75);
            
            int overall = overallDis(gen);
            int potential = potentialDis(gen);
            
            prospects.push_back(make_shared<Player>(name, age, position, overall, potential, 2, (overall - 55) * 300000));
        }
    }

    void displayProspects() const {
        cout << "\n2025年NBA选秀球员:" << endl;
        cout << "----------------------------------------" << endl;
        for (size_t i = 0; i < prospects.size(); i++) {
            cout << i + 1 << ". ";
            prospects[i]->displayInfo();
        }
    }

    shared_ptr<Player> draftPlayer(int pick) {
        if (pick >= 1 && pick <= static_cast<int>(prospects.size())) {
            shared_ptr<Player> selected = prospects[pick - 1];
            prospects.erase(prospects.begin() + pick - 1);
            return selected;
        }
        return nullptr;
    }

    vector<shared_ptr<Player>> getProspects() const {
        return prospects;
    }
};

// 游戏类
class NBAGame {
private:
    vector<shared_ptr<Team>> teams;     // 所有球队
    shared_ptr<Team> userTeam;          // 用户球队
    int currentYear;                    // 当前年份
    bool gameOver;                      // 游戏是否结束

public:
    NBAGame() : currentYear(2025), gameOver(false) {
        initializeTeams();
        selectUserTeam();
        cout << "\n欢迎来到2025年NBA经理游戏!" << endl;
        cout << "你现在是" << userTeam->getCity() << " " << userTeam->getName() << "的总经理。" << endl;
        cout << "你的目标是通过交易、自由球员签约和选秀来组建一支冠军球队。" << endl;
    }

    void initializeTeams() {
        // 创建30支球队
        vector<pair<string, string>> teamInfo = {
            {"公牛", "芝加哥"}, {"凯尔特人", "波士顿"}, {"篮网", "布鲁克林"}, {"黄蜂", "夏洛特"},
            {"雄鹿", "密尔沃基"}, {"骑士", "克利夫兰"}, {"独行侠", "达拉斯"}, {"掘金", "丹佛"},
            {"活塞", "底特律"}, {"勇士", "金州"}, {"火箭", "休斯顿"}, {"步行者", "印第安纳"},
            {"快船", "洛杉矶"}, {"湖人", "洛杉矶"}, {"灰熊", "孟菲斯"}, {"热火", "迈阿密"},
            {"雄鹿", "密尔沃基"}, {"森林狼", "明尼苏达"}, {"鹈鹕", "新奥尔良"}, {"尼克斯", "纽约"},
            {"雷霆", "俄克拉荷马城"}, {"魔术", "奥兰多"}, {"76人", "费城"}, {"太阳", "菲尼克斯"},
            {"开拓者", "波特兰"}, {"国王", "萨克拉门托"}, {"马刺", "圣安东尼奥"}, {"猛龙", "多伦多"},
            {"爵士", "犹他"}, {"奇才", "华盛顿"}
        };

        double salaryCap = 222000000; // 2025年工资帽（单位：美元）

        for (const auto& info : teamInfo) {
            auto team = make_shared<Team>(info.first, info.second, salaryCap);
            generateRoster(team);
            teams.push_back(team);
        }
    }

    void generateRoster(shared_ptr<Team> team) {
        vector<string> positions = {"控球后卫", "得分后卫", "小前锋", "大前锋", "中锋"};
        random_device rd;
        mt19937 gen(rd());
        
        // 生成15人阵容
        for (int i = 0; i < 15; i++) {
            string position;
            if (i < 5) {
                position = positions[i]; // 确保每个位置至少有一名球员
            } else {
                position = positions[rand() % positions.size()];
            }
            
            // 主力球员能力值更高
            int overall;
            int potential;
            if (i < 5) {
                uniform_int_distribution<> dis(70, 90);
                overall = dis(gen);
                potential = overall + (rand() % 10);
            } else if (i < 10) {
                uniform_int_distribution<> dis(60, 75);
                overall = dis(gen);
                potential = overall + (rand() % 8);
            } else {
                uniform_int_distribution<> dis(55, 65);
                overall = dis(gen);
                potential = overall + (rand() % 5);
            }
            
            potential = min(99, potential);
            
            // 年龄分布
            int age;
            if (i < 3) {
                age = 25 + (rand() % 7); // 核心球员年龄在25-31岁
            } else if (i < 8) {
                age = 22 + (rand() % 8); // 角色球员年龄在22-29岁
            } else {
                age = 20 + (rand() % 10); // 替补球员年龄在20-29岁
            }
            
            // 合同年数和薪资
            int contractYears = 1 + (rand() % 5);
            double salary = (overall - 55) * 1000000; // 简单的薪资计算
            
            // 随机生成名字
            vector<string> firstNames = {"约翰", "迈克尔", "大卫", "詹姆斯", "罗伯特", "丹尼尔", "马修", "安德鲁", "约瑟夫", "瑞安", 
                                        "贾斯汀", "布兰登", "克里斯托弗", "托马斯", "乔纳森", "凯文", "布莱恩", "爱德华", "贾森", "蒂莫西"};
            vector<string> lastNames = {"史密斯", "约翰逊", "威廉姆斯", "琼斯", "布朗", "戴维斯", "米勒", "威尔逊", "摩尔", "泰勒", 
                                        "安德森", "托马斯", "杰克逊", "怀特", "哈里斯", "马丁", "汤普森", "加西亚", "马丁内斯", "罗宾逊"};
            
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            
            // 创建球员并添加到球队
            auto player = make_shared<Player>(name, age, position, overall, potential, contractYears, salary);
            team->addPlayer(player);
        }
    }

    void selectUserTeam() {
        cout << "选择你的球队:" << endl;
        for (size_t i = 0; i < teams.size(); i++) {
            cout << i + 1 << ". " << teams[i]->getCity() << " " << teams[i]->getName() << endl;
        }
        
        int choice;
        do {
            cout << "输入球队编号 (1-30): ";
            cin >> choice;
            cin.ignore(); // 忽略换行符
        } while (choice < 1 || choice > 30);
        
        userTeam = teams[choice - 1];
    }

    void displayStandings() const {
        // 复制球队列表并按胜率排序
        vector<shared_ptr<Team>> sortedTeams = teams;
        sort(sortedTeams.begin(), sortedTeams.end(), 
             [](const shared_ptr<Team>& a, const shared_ptr<Team>& b) {
                 return a->getWinPercentage() > b->getWinPercentage();
             });
        
        cout << "\n" << currentYear << "年NBA排名:" << endl;
        cout << "----------------------------------------" << endl;
        cout << "排名 | 球队                | 胜负    | 胜率" << endl;
        cout << "----------------------------------------" << endl;
        
        for (size_t i = 0; i < sortedTeams.size(); i++) {
            cout << setw(4) << i + 1 << " | ";
            cout << setw(20) << left << sortedTeams[i]->getCity() + " " + sortedTeams[i]->getName() << " | ";
            cout << setw(6) << sortedTeams[i]->getWins() << "-" << sortedTeams[i]->getLosses() << " | ";
            cout << fixed << setprecision(3) << sortedTeams[i]->getWinPercentage() << endl;
        }
    }

    void simulateSeason() {
        cout << "\n模拟" << currentYear << "赛季..." << endl;
        
        // 重置所有球队的赛季数据
        for (const auto& team : teams) {
            team->resetSeason();
        }
        
        // 模拟每个球队的赛季
        for (const auto& team : teams) {
            team->simulateSeason();
        }
        
        // 显示常规赛结果
        displayStandings();
        
        // 模拟季后赛
        simulatePlayoffs();
        
        // 增加年份
        currentYear++;
        
        // 老化球员
        ageAllPlayers();
        
        // 处理合同到期
        handleExpiringContracts();
        
        // 生成选秀
        Draft draft;
        cout << "\n" << currentYear << "年NBA选秀即将到来..." << endl;
        
        // 显示乐透抽签结果
        conductLottery();
        
        // 显示用户球队的选秀权
        cout << "\n你的球队拥有第" << userTeam->getDraftPick() << "号选秀权。" << endl;
        
        // 执行选秀
        conductDraft(draft);
        
        // 显示更新后的阵容
        userTeam->displayRoster();
        
        cout << "\n" << currentYear << "赛季准备开始!" << endl;
    }

    void simulatePlayoffs() {
        cout << "\n模拟季后赛..." << endl;
        
        // 复制球队列表并按胜率排序
        vector<shared_ptr<Team>> easternConference;
        vector<shared_ptr<Team>> westernConference;
        
        // 简单划分东西部
        for (size_t i = 0; i < teams.size(); i++) {
            if (i < 15) {
                easternConference.push_back(teams[i]);
            } else {
                westernConference.push_back(teams[i]);
            }
        }
        
        // 东西部按胜率排序
        sort(easternConference.begin(), easternConference.end(), 
             [](const shared_ptr<Team>& a, const shared_ptr<Team>& b) {
                 return a->getWinPercentage() > b->getWinPercentage();
             });
        
        sort(westernConference.begin(), westernConference.end(), 
             [](const shared_ptr<Team>& a, const shared_ptr<Team>& b) {
                 return a->getWinPercentage() > b->getWinPercentage();
             });
        
        // 模拟东部季后赛
        shared_ptr<Team> easternChampion = simulateConferencePlayoffs(easternConference, "东部");
        
        // 模拟西部季后赛
        shared_ptr<Team> westernChampion = simulateConferencePlayoffs(westernConference, "西部");
        
        // 模拟总决赛
        simulateFinals(easternChampion, westernChampion);
    }

    shared_ptr<Team> simulateConferencePlayoffs(vector<shared_ptr<Team>> conference, string conferenceName) {
        cout << "\n" << conferenceName << "联盟季后赛:" << endl;
        cout << "----------------------------------------" << endl;
        
        // 首轮
        vector<shared_ptr<Team>> round1Winners;
        for (int i = 0; i < 4; i++) {
            shared_ptr<Team> higherSeed = conference[i];
            shared_ptr<Team> lowerSeed = conference[7 - i];
            
            cout << "\n第一轮: #" << i + 1 << " " << higherSeed->getCity() << " " << higherSeed->getName() 
                 << " 对阵 #" << 8 - i << " " << lowerSeed->getCity() << " " << lowerSeed->getName() << endl;
            
            shared_ptr<Team> winner = simulateSeries(higherSeed, lowerSeed, 7);
            round1Winners.push_back(winner);
            cout << winner->getCity() << " " << winner->getName() << " 晋级下一轮!" << endl;
        }
        
        // 次轮
        vector<shared_ptr<Team>> round2Winners;
        for (int i = 0; i < 2; i++) {
            shared_ptr<Team> team1 = round1Winners[i];
            shared_ptr<Team> team2 = round1Winners[3 - i];
            
            cout << "\n第二轮: " << team1->getCity() << " " << team1->getName() 
                 << " 对阵 " << team2->getCity() << " " << team2->getName() << endl;
            
            shared_ptr<Team> winner = simulateSeries(team1, team2, 7);
            round2Winners.push_back(winner);
            cout << winner->getCity() << " " << winner->getName() << " 晋级分区决赛!" << endl;
        }
        
        // 分区决赛
        shared_ptr<Team> conferenceChampion;
        cout << "\n分区决赛: " << round2Winners[0]->getCity() << " " << round2Winners[0]->getName() 
             << " 对阵 " << round2Winners[1]->getCity() << " " << round2Winners[1]->getName() << endl;
        
        conferenceChampion = simulateSeries(round2Winners[0], round2Winners[1], 7);
        cout << conferenceChampion->getCity() << " " << conferenceChampion->getName() 
             << " 是" << conferenceName << "联盟冠军!" << endl;
        
        return conferenceChampion;
    }

    shared_ptr<Team> simulateSeries(shared_ptr<Team> team1, shared_ptr<Team> team2, int maxGames) {
        int team1Wins = 0;
        int team2Wins = 0;
        
        while (team1Wins < (maxGames + 1) / 2 && team2Wins < (maxGames + 1) / 2) {
            // 模拟一场比赛
            random_device rd;
            mt19937 gen(rd());
            uniform_real_distribution<> dis(0.0, 1.0);
            
            // 基于球队实力和主场优势
            double team1Strength = team1->calculateTeamStrength() * 1.05; // 主场优势
            double team2Strength = team2->calculateTeamStrength();
            
            double totalStrength = team1Strength + team2Strength;
            double team1WinProbability = team1Strength / totalStrength;
            
            if (dis(gen) < team1WinProbability) {
                team1Wins++;
            } else {
                team2Wins++;
            }
            
            // 轮换主场优势
            swap(team1Strength, team2Strength);
        }
        
        if (team1Wins > team2Wins) {
            return team1;
        } else {
            return team2;
        }
    }

    void simulateFinals(shared_ptr<Team> easternChampion, shared_ptr<Team> westernChampion) {
        cout << "\nNBA总决赛: " << easternChampion->getCity() << " " << easternChampion->getName() 
             << " 对阵 " << westernChampion->getCity() << " " << westernChampion->getName() << endl;
        
        shared_ptr<Team> nbaChampion = simulateSeries(easternChampion, westernChampion, 7);
        cout << "\n" << nbaChampion->getCity() << " " << nbaChampion->getName() 
             << " 是" << currentYear << "年NBA总冠军!" << endl;
        
        if (nbaChampion == userTeam) {
            cout << "恭喜你! 你赢得了NBA总冠军!" << endl;
        }
    }

    void conductLottery() {
        cout << "\n进行" << currentYear << "年NBA选秀乐透抽签..." << endl;
        
        // 按战绩排序（战绩差的在前）
        vector<shared_ptr<Team>> lotteryTeams = teams;
        sort(lotteryTeams.begin(), lotteryTeams.end(), 
             [](const shared_ptr<Team>& a, const shared_ptr<Team>& b) {
                 return a->getWinPercentage() < b->getWinPercentage();
             });
        
        // 只取乐透区球队（14支）
        vector<shared_ptr<Team>> lotteryPicks;
        for (int i = 0; i < 14 && i < static_cast<int>(lotteryTeams.size()); i++) {
            lotteryPicks.push_back(lotteryTeams[i]);
        }
        
        // 随机分配乐透顺位
        vector<int> draftOrder;
        for (int i = 1; i <= 14; i++) {
            draftOrder.push_back(i);
        }
        random_shuffle(draftOrder.begin(), draftOrder.end());
        
        // 分配顺位
        for (int i = 0; i < 14 && i < static_cast<int>(lotteryPicks.size()); i++) {
            lotteryPicks[i]->setDraftPick(draftOrder[i]);
        }
        
        // 剩余顺位（非乐透）
        for (size_t i = 14; i < teams.size(); i++) {
            teams[i]->setDraftPick(i + 1);
        }
        
        // 显示乐透结果
        cout << "\n乐透抽签结果:" << endl;
        cout << "----------------------------------------" << endl;
        for (int i = 0; i < 14 && i < static_cast<int>(lotteryPicks.size()); i++) {
            cout << "第" << draftOrder[i] << "号签: " 
                 << lotteryPicks[i]->getCity() << " " << lotteryPicks[i]->getName() << endl;
        }
    }

    void conductDraft(Draft& draft) {
        cout << "\n" << currentYear << "年NBA选秀:" << endl;
        cout << "----------------------------------------" << endl;
        
        // 按选秀顺位排序
        vector<shared_ptr<Team>> draftOrder = teams;
        sort(draftOrder.begin(), draftOrder.end(), 
             [](const shared_ptr<Team>& a, const shared_ptr<Team>& b) {
                 return a->getDraftPick() < b->getDraftPick();
             });
        
        // 模拟首轮
        cout << "\n第一轮:" << endl;
        for (int i = 0; i < 30 && i < static_cast<int>(draftOrder.size()); i++) {
            shared_ptr<Team> team = draftOrder[i];
            int pick = team->getDraftPick();
            
            shared_ptr<Player> draftedPlayer;
            if (team == userTeam) {
                // 用户选择
                cout << "\n轮到你选秀 (#" << pick << "):" << endl;
                draft.displayProspects();
                
                int selection;
                do {
                    cout << "选择要选中的球员 (1-" << draft.getProspects().size() << "): ";
                    cin >> selection;
                    cin.ignore();
                } while (selection < 1 || selection > static_cast<int>(draft.getProspects().size()));
                
                draftedPlayer = draft.draftPlayer(selection);
            } else {
                // AI选择（简单模拟：选择最高能力值的球员）
                vector<shared_ptr<Player>> prospects = draft.getProspects();
                if (prospects.empty()) break;
                
                int bestIndex = 0;
                int bestOverall = prospects[0]->getOverall();
                
                for (size_t j = 1; j < prospects.size(); j++) {
                    if (prospects[j]->getOverall() > bestOverall) {
                        bestOverall = prospects[j]->getOverall();
                        bestIndex = j;
                    }
                }
                
                draftedPlayer = draft.draftPlayer(bestIndex + 1);
                cout << "第" << pick << "号签: " << team->getCity() << " " << team->getName() 
                     << " 选中 " << draftedPlayer->getName() << " (" << draftedPlayer->getPosition() 
                     << ", 能力值: " << draftedPlayer->getOverall() << ")" << endl;
            }
            
            if (draftedPlayer) {
                // 添加球员到球队
                team->addPlayer(draftedPlayer);
                cout << team->getCity() << " " << team->getName() << " 选中了 " 
                     << draftedPlayer->getName() << " (" << draftedPlayer->getPosition() 
                     << ", 能力值: " << draftedPlayer->getOverall() << ", 潜力: " 
                     << draftedPlayer->getPotential() << ")" << endl;
            }
        }
        
        // 模拟次轮
        cout << "\n第二轮:" << endl;
        for (int i = 0; i < 30 && i < static_cast<int>(draftOrder.size()); i++) {
            shared_ptr<Team> team = draftOrder[i];
            
            vector<shared_ptr<Player>> prospects = draft.getProspects();
            if (prospects.empty()) {
                cout << "次轮没有更多新秀可供选择。" << endl;
                break;
            }
            
            shared_ptr<Player> draftedPlayer;
            if (team == userTeam) {
                // 用户选择
                cout << "\n轮到你选秀 (#" << (i + 31) << "):" << endl;
                draft.displayProspects();
                
                int selection;
                do {
                    cout << "选择要选中的球员 (1-" << prospects.size() << "): ";
                    cin >> selection;
                    cin.ignore();
                } while (selection < 1 || selection > static_cast<int>(prospects.size()));
                
                draftedPlayer = draft.draftPlayer(selection);
            } else {
                // AI选择（简单模拟）
                int randomIndex = rand() % prospects.size();
                draftedPlayer = draft.draftPlayer(randomIndex + 1);
            }
            
            if (draftedPlayer) {
                // 添加球员到球队
                team->addPlayer(draftedPlayer);
                cout << team->getCity() << " " << team->getName() << " 选中了 " 
                     << draftedPlayer->getName() << " (" << draftedPlayer->getPosition() 
                     << ", 能力值: " << draftedPlayer->getOverall() << ")" << endl;
            }
        }
    }

    void ageAllPlayers() {
        for (const auto& team : teams) {
            team->ageRoster();
        }
    }

    void handleExpiringContracts() {
        cout << "\n处理即将到期的合同..." << endl;
        
        for (const auto& team : teams) {
            vector<shared_ptr<Player>> expiringPlayers;
            vector<shared_ptr<Player>> roster = team->getRoster();
            
            for (const auto& player : roster) {
                if (player->getContractYears() == 1) {
                    expiringPlayers.push_back(player);
                } else {
                    // 减少合同年数
                    player->setContractYears(player->getContractYears() - 1);
                }
            }
            
            // 处理用户球队的续约决定
            if (team == userTeam) {
                cout << "\n你球队即将到期的合同:" << endl;
                for (const auto& player : expiringPlayers) {
                    player->displayInfo();
                    
                    char choice;
                    do {
                        cout << "你想续约" << player->getName() << "吗? (y/n): ";
                        cin >> choice;
                        cin.ignore();
                    } while (choice != 'y' && choice != 'n');
                    
                    if (choice == 'y') {
                        // 续约逻辑
                        int newYears;
                        double newSalary;
                        
                        cout << "输入合同年数 (1-5): ";
                        cin >> newYears;
                        cin.ignore();
                        
                        // 根据球员能力计算合理薪资
                        double baseSalary = (player->getOverall() - 55) * 1000000;
                        
                        cout << "建议薪资: $" << baseSalary / 1000000 << "百万/年" << endl;
                        cout << "输入新薪资 (单位: 百万): ";
                        cin >> newSalary;
                        cin.ignore();
                        
                        newSalary *= 1000000; // 转换为美元
                        
                        // 检查薪资帽
                        if (team->getCurrentSalary() - player->getSalary() + newSalary <= team->getSalaryCap()) {
                            player->setContractYears(newYears);
                            player->setSalary(newSalary);
                            cout << player->getName() << " 以" << newYears 
                                 << "年 $" << newSalary / 1000000 << "百万/年的合同续约。" << endl;
                        } else {
                            cout << "薪资帽违规! 合同报价被拒绝。" << endl;
                            team->removePlayer(player);
                            cout << player->getName() << " 已离开球队。" << endl;
                        }
                    } else {
                        team->removePlayer(player);
                        cout << player->getName() << " 已离开球队。" << endl;
                    }
                }
            } else {
                // AI球队处理续约
                for (const auto& player : expiringPlayers) {
                    // 简单AI逻辑：根据球员能力和球队需求决定是否续约
                    random_device rd;
                    mt19937 gen(rd());
                    uniform_real_distribution<> dis(0.0, 1.0);
                    
                    double resignProbability = 0.5;
                    
                    // 能力强的球员更可能被续约
                    if (player->getOverall() > 80) {
                        resignProbability += 0.3;
                    } else if (player->getOverall() > 70) {
                        resignProbability += 0.15;
                    }
                    
                    // 检查球队位置需求（简化）
                    int positionCount = 0;
                    for (const auto& p : roster) {
                        if (p->getPosition() == player->getPosition() && p != player) {
                            positionCount++;
                        }
                    }
                    
                    if (positionCount >= 2) {
                        resignProbability -= 0.2;
                    }
                    
                    // 薪资帽考虑
                    double newSalary = (player->getOverall() - 55) * 1000000;
                    if (team->getCurrentSalary() - player->getSalary() + newSalary > team->getSalaryCap()) {
                        resignProbability -= 0.3;
                    }
                    
                    resignProbability = max(0.0, min(1.0, resignProbability));
                    
                    if (dis(gen) < resignProbability) {
                        // 续约
                        int newYears = 2 + (rand() % 4); // 2-5年
                        player->setContractYears(newYears);
                        player->setSalary(newSalary);
                    } else {
                        // 不续约
                        team->removePlayer(player);
                    }
                }
            }
        }
    }

    void displayUserTeamRoster() const {
        userTeam->displayRoster();
    }

    void tradePlayers() {
        cout << "\n交易中心" << endl;
        cout << "----------------------------------------" << endl;
        
        // 显示用户球队可交易球员
        cout << "\n你球队的可交易球员:" << endl;
        vector<shared_ptr<Player>> yourTradeablePlayers = userTeam->getTradeablePlayers();
        for (size_t i = 0; i < yourTradeablePlayers.size(); i++) {
            cout << i + 1 << ". ";
            yourTradeablePlayers[i]->displayInfo();
        }
        
        // 选择交易对象球队
        cout << "\n选择要交易的球队:" << endl;
        for (size_t i = 0; i < teams.size(); i++) {
            if (teams[i] != userTeam) {
                cout << i + 1 << ". " << teams[i]->getCity() << " " << teams[i]->getName() 
                     << " (战绩: " << teams[i]->getWins() << "-" << teams[i]->getLosses() << ")" << endl;
            }
        }
        
        int teamChoice;
        do {
            cout << "输入球队编号 (1-30, 不包括你自己的球队): ";
            cin >> teamChoice;
            cin.ignore();
        } while (teamChoice < 1 || teamChoice > 30 || teams[teamChoice - 1] == userTeam);
        
        shared_ptr<Team> tradePartner = teams[teamChoice - 1];
        
        // 显示交易对象球队可交易球员
        cout << "\n" << tradePartner->getCity() << " " << tradePartner->getName() << "的可交易球员:" << endl;
        vector<shared_ptr<Player>> partnerTradeablePlayers = tradePartner->getTradeablePlayers();
        for (size_t i = 0; i < partnerTradeablePlayers.size(); i++) {
            cout << i + 1 << ". ";
            partnerTradeablePlayers[i]->displayInfo();
        }
        
        // 选择要交易的球员
        vector<shared_ptr<Player>> playersToTrade;
        char addMore;
        
        do {
            int playerChoice;
            do {
                cout << "\n从你的球队中选择要交易的球员 (1-" << yourTradeablePlayers.size() << "), 0 结束: ";
                cin >> playerChoice;
                cin.ignore();
            } while (playerChoice < 0 || playerChoice > static_cast<int>(yourTradeablePlayers.size()));
            
            if (playerChoice > 0) {
                playersToTrade.push_back(yourTradeablePlayers[playerChoice - 1]);
                cout << yourTradeablePlayers[playerChoice - 1]->getName() << " 已添加到交易包中。" << endl;
            }
            
            if (playerChoice > 0) {
                cout << "添加另一名球员? (y/n): ";
                cin >> addMore;
                cin.ignore();
            } else {
                addMore = 'n';
            }
        } while (addMore == 'y');
        
        // 计算交易球员的总薪资
        double yourPlayersSalary = 0;
        for (const auto& player : playersToTrade) {
            yourPlayersSalary += player->getSalary();
        }
        
        // 选择想要得到的球员
        vector<shared_ptr<Player>> playersToReceive;
        
        do {
            int playerChoice;
            do {
                cout << "\n从" << tradePartner->getCity() << " " 
                     << tradePartner->getName() << "选择想要得到的球员 (1-" << partnerTradeablePlayers.size() << "), 0 结束: ";
                cin >> playerChoice;
                cin.ignore();
            } while (playerChoice < 0 || playerChoice > static_cast<int>(partnerTradeablePlayers.size()));
            
            if (playerChoice > 0) {
                playersToReceive.push_back(partnerTradeablePlayers[playerChoice - 1]);
                cout << partnerTradeablePlayers[playerChoice - 1]->getName() << " 已添加到接收包中。" << endl;
            }
            
            if (playerChoice > 0) {
                cout << "添加另一名球员? (y/n): ";
                cin >> addMore;
                cin.ignore();
            } else {
                addMore = 'n';
            }
        } while (addMore == 'y');
        
        // 计算接收球员的总薪资
        double receivePlayersSalary = 0;
        for (const auto& player : playersToReceive) {
            receivePlayersSalary += player->getSalary();
        }
        
        // 显示交易摘要
        cout << "\n交易摘要:" << endl;
        cout << "你交易出:" << endl;
        for (const auto& player : playersToTrade) {
            cout << "- " << player->getName() << " ($" << player->getSalary() / 1000000 << "百万/年)" << endl;
        }
        cout << "总薪资: $" << yourPlayersSalary / 1000000 << "百万/年" << endl;
        
        cout << "\n你交易得到:" << endl;
        for (const auto& player : playersToReceive) {
            cout << "- " << player->getName() << " ($" << player->getSalary() / 1000000 << "百万/年)" << endl;
        }
        cout << "总薪资: $" << receivePlayersSalary / 1000000 << "百万/年" << endl;
        
        // 简单的薪资匹配检查（NBA规则：交易薪资需大致匹配）
        bool salaryMatch = true;
        if (yourPlayersSalary > 0 && receivePlayersSalary > 0) {
            double ratio = max(yourPlayersSalary, receivePlayersSalary) / min(yourPlayersSalary, receivePlayersSalary);
            if (ratio > 1.25) { // 简化规则：薪资差异不超过25%
                salaryMatch = false;
                cout << "\n警告: 薪资不匹配! 根据NBA规则，这笔交易可能不被允许。" << endl;
            }
        }
        
        // 检查薪资帽
        double newUserSalary = userTeam->getCurrentSalary() - yourPlayersSalary + receivePlayersSalary;
        if (newUserSalary > userTeam->getSalaryCap()) {
            cout << "\n警告: 这笔交易会使你的球队超过薪资帽!" << endl;
        }
        
        char confirm;
        do {
            cout << "\n确认交易? (y/n): ";
            cin >> confirm;
            cin.ignore();
        } while (confirm != 'y' && confirm != 'n');
        
        if (confirm == 'y' && salaryMatch) {
            // 执行交易
            for (const auto& player : playersToTrade) {
                userTeam->removePlayer(player);
                tradePartner->addPlayer(player);
            }
            
            for (const auto& player : playersToReceive) {
                tradePartner->removePlayer(player);
                userTeam->addPlayer(player);
            }
            
            cout << "\n交易完成!" << endl;
            cout << "你更新后的阵容:" << endl;
            displayUserTeamRoster();
        } else {
            cout << "\n交易取消。" << endl;
        }
    }

    void freeAgency() {
        cout << "\n自由球员市场" << endl;
        cout << "----------------------------------------" << endl;
        
        // 生成自由球员池
        vector<shared_ptr<Player>> freeAgents;
        
        // 从其他球队中随机选择一些球员作为自由球员
        for (const auto& team : teams) {
            if (team == userTeam) continue;
            
            vector<shared_ptr<Player>> roster = team->getRoster();
            for (const auto& player : roster) {
                // 随机概率成为自由球员
                random_device rd;
                mt19937 gen(rd());
                uniform_int_distribution<> dis(1, 100);
                
                if (dis(gen) <= 10) { // 10%的概率
                    freeAgents.push_back(player);
                }
            }
        }
        
        // 添加一些新秀级别的自由球员
        vector<string> firstNames = {"约翰", "迈克尔", "大卫", "詹姆斯", "罗伯特", "丹尼尔", "马修", "安德鲁", "约瑟夫", "瑞安", 
                                     "贾斯汀", "布兰登", "克里斯托弗", "托马斯", "乔纳森", "凯文", "布莱恩", "爱德华", "贾森", "蒂莫西"};
        vector<string> lastNames = {"史密斯", "约翰逊", "威廉姆斯", "琼斯", "布朗", "戴维斯", "米勒", "威尔逊", "摩尔", "泰勒", 
                                    "安德森", "托马斯", "杰克逊", "怀特", "哈里斯", "马丁", "汤普森", "加西亚", "马丁内斯", "罗宾逊"};
        vector<string> positions = {"控球后卫", "得分后卫", "小前锋", "大前锋", "中锋"};
        
        for (int i = 0; i < 10; i++) {
            string name = firstNames[rand() % firstNames.size()] + " " + lastNames[rand() % lastNames.size()];
            string position = positions[rand() % positions.size()];
            int age = 22 + (rand() % 6);
            int overall = 55 + (rand() % 15);
            int potential = overall + (rand() % 10);
            
            auto player = make_shared<Player>(name, age, position, overall, potential, 0, 0);
            freeAgents.push_back(player);
        }
        
        // 显示自由球员
        cout << "\n可用的自由球员:" << endl;
        for (size_t i = 0; i < freeAgents.size(); i++) {
            cout << i + 1 << ". ";
            freeAgents[i]->displayInfo();
        }
        
        // 签约自由球员
        char continueSigning = 'y';
        while (continueSigning == 'y') {
            int choice;
            do {
                cout << "\n选择要签约的自由球员 (1-" << freeAgents.size() << "), 0 退出: ";
                cin >> choice;
                cin.ignore();
            } while (choice < 0 || choice > static_cast<int>(freeAgents.size()));
            
            if (choice == 0) break;
            
            shared_ptr<Player> selectedPlayer = freeAgents[choice - 1];
            
            // 确定合同条款
            int years;
            double salary;
            
            cout << "\n输入合同年数 (1-5): ";
            cin >> years;
            cin.ignore();
            
            // 根据球员能力建议薪资
            double suggestedSalary = (selectedPlayer->getOverall() - 55) * 1000000;
            cout << "建议薪资: $" << suggestedSalary / 1000000 << "百万/年" << endl;
            
            cout << "输入薪资 (单位: 百万): ";
            cin >> salary;
            cin.ignore();
            
            salary *= 1000000; // 转换为美元
            
            // 检查薪资帽
            if (userTeam->getCurrentSalary() + salary > userTeam->getSalaryCap()) {
                cout << "薪资帽违规! 你负担不起这名球员的薪水。" << endl;
            } else {
                // 检查球员是否属于其他球队
                bool fromOtherTeam = false;
                for (const auto& team : teams) {
                    if (team == userTeam) continue;
                    
                    vector<shared_ptr<Player>> roster = team->getRoster();
                    for (const auto& player : roster) {
                        if (player == selectedPlayer) {
                            team->removePlayer(player);
                            fromOtherTeam = true;
                            break;
                        }
                    }
                    if (fromOtherTeam) break;
                }
                
                // 设置球员合同
                selectedPlayer->setContractYears(years);
                selectedPlayer->setSalary(salary);
                
                // 添加到用户球队
                userTeam->addPlayer(selectedPlayer);
                
                // 从自由球员列表中移除
                freeAgents.erase(freeAgents.begin() + choice - 1);
                
                cout << selectedPlayer->getName() << " 已与" 
                     << userTeam->getCity() << " " << userTeam->getName() 
                     << "签约，合同为" << years << "年，年薪为$" << salary / 1000000 << "百万!" << endl;
            }
            
            if (!freeAgents.empty()) {
                cout << "\n继续签约自由球员? (y/n): ";
                cin >> continueSigning;
                cin.ignore();
            } else {
                cout << "\n没有更多自由球员可用。" << endl;
                continueSigning = 'n';
            }
        }
        
        // 显示更新后的阵容
        cout << "\n你更新后的阵容:" << endl;
        displayUserTeamRoster();
    }

    void gameMenu() {
        int choice;
        do {
            cout << "\n===== NBA经理游戏菜单 =====" << endl;
            cout << "1. 显示球队阵容" << endl;
            cout << "2. 模拟赛季" << endl;
            cout << "3. 交易球员" << endl;
            cout << "4. 签约自由球员" << endl;
            cout << "5. 查看联盟排名" << endl;
            cout << "0. 退出游戏" << endl;
            cout << "===========================" << endl;
            cout << "请选择: ";
            cin >> choice;
            cin.ignore();
            
            switch (choice) {
                case 1:
                    displayUserTeamRoster();
                    break;
                case 2:
                    simulateSeason();
                    break;
                case 3:
                    tradePlayers();
                    break;
                case 4:
                    freeAgency();
                    break;
                case 5:
                    displayStandings();
                    break;
                case 0:
                    cout << "感谢游玩NBA经理游戏!" << endl;
                    gameOver = true;
                    break;
                default:
                    cout << "无效选择，请重试。" << endl;
            }
        } while (!gameOver);
    }
};

int main() {
    // 设置随机数种子
    srand(static_cast<unsigned int>(time(nullptr)));
    
    // 创建并开始游戏
    NBAGame game;
    game.gameMenu();
    
    return 0;
}