3. 플레이어 간 아이템 직거래(트레이드)

// ============================================================================
// [코드리뷰 문제] C++ - 플레이어 간 아이템 직거래(트레이드)
// ----------------------------------------------------------------------------
// 시나리오:
//   - 두 플레이어가 거래창을 열고 각자 아이템을 올린 뒤(Offer),
//     양쪽이 Confirm 을 누르면 거래가 체결(Commit)된다.
//   - 거래 도중 한쪽이 접속을 끊거나(취소), 다른 거래를 동시에 열 수 있다.
//   - 아이템은 고유 인스턴스 ID(itemUid)를 가진다(장비 등 비스택 아이템).
//
// 요구사항:
//   - 거래 체결은 원자적이어야 한다(둘 다 받거나, 둘 다 못 받거나).
//   - 같은 아이템을 두 거래에 동시에 올릴 수 없다(중복 거래 금지).
//   - 거래 도중 한쪽 로그아웃/취소 시 올린 아이템은 원래 주인에게 돌아간다.
//   - 여러 IO 스레드가 거래 패킷을 동시에 처리한다.
//
// 과제:
//   이 코드의 잠재적 문제를 모두 찾고, 왜 문제인지 설명하고,
//   수정안과 더 나은 설계를 제시하라.
//   (먼저 직접 리뷰를 적은 뒤 answer.md 와 대조할 것)
// ============================================================================

#include <cstdint>
#include <vector>
#include <map>
#include <unordered_map>
#include <mutex>

struct Item {
    int64_t uid;
    int32_t itemId;
};

struct Player {
    int64_t id;
    std::mutex lock;
    std::unordered_map<int64_t, Item> inventory;   // uid -> Item
};

struct Trade {
    Player* a = nullptr;
    Player* b = nullptr;
    std::vector<int64_t> offerA;   // a 가 올린 itemUid
    std::vector<int64_t> offerB;
    bool confirmA = false;
    bool confirmB = false;
    bool committed = false;
};

class TradeService {
public:
    explicit TradeService(std::unordered_map<int64_t, Player*>& players)
        : players_(players) {}

    Trade* OpenTrade(int64_t aId, int64_t bId) {
        Trade* t = new Trade();
        t->a = players_.at(aId);
        t->b = players_.at(bId);
        {
            std::lock_guard<std::mutex> lk(lock_);
            trades_[{aId, bId}] = t;                   // (A)
        }
        return t;
    }

    // 플레이어가 거래창에 아이템을 올림
    bool Offer(Trade* t, int64_t playerId, int64_t itemUid) {
        Player* p = (t->a->id == playerId) ? t->a : t->b;
        // (B) 본인 인벤토리에 있는지 확인
        if (p->inventory.find(itemUid) == p->inventory.end())
            return false;

        if (t->a->id == playerId) t->offerA.push_back(itemUid);   // (C)
        else                      t->offerB.push_back(itemUid);
        // 한쪽이 새로 아이템을 올리면 기존 확인은 무효화돼야 하지만...
        return true;
    }

    void Confirm(Trade* t, int64_t playerId) {
        if (t->a->id == playerId) t->confirmA = true;             // (D)
        else                      t->confirmB = true;

        if (t->confirmA && t->confirmB)
            Commit(t);
    }

    // 한쪽이 로그아웃/취소
    void Cancel(Trade* t) {
        {
            std::lock_guard<std::mutex> lk(lock_);
            trades_.erase({t->a->id, t->b->id});                  // (G)
        }
        // 올린 아이템은 인벤토리에서 빠진 적이 없으니 그냥 둔다 (H)
        delete t;
    }

private:
    void Commit(Trade* t) {
        if (t->committed) return;
        t->committed = true;

        // (E) A 의 아이템을 B 에게
        for (int64_t uid : t->offerA) {
            Item item = t->a->inventory[uid];
            t->a->inventory.erase(uid);
            t->b->inventory[uid] = item;
        }
        // (F) B 의 아이템을 A 에게
        for (int64_t uid : t->offerB) {
            Item item = t->b->inventory[uid];
            t->b->inventory.erase(uid);
            t->a->inventory[uid] = item;
        }
    }

    std::unordered_map<int64_t, Player*>& players_;
    std::mutex lock_;
    std::map<std::pair<int64_t, int64_t>, Trade*> trades_;
};