FLYWEIGHT

// 체스 말의 종류를 정의하는 열거형
enum class ChessPieceType {
    KING, QUEEN, ROOK, BISHOP, KNIGHT, PAWN
}

// 체스 말의 색상을 정의하는 열거형
enum class ChessPieceColor {
    BLACK, RED
}

// 체스 말의 위치를 정의하는 클래스
data class Position(val x: Int, val y: Int)

// 플라이웨이트 인터페이스 - 체스 말
interface ChessPiece {
    fun getType(): ChessPieceType
    fun getColor(): ChessPieceColor
    fun display(position: Position) // 외부 상태(position)를 매개변수로 받음
}

// 구체적 플라이웨이트 - 실제 체스 말 구현
class ConcretePiece(
    private val type: ChessPieceType,
    private val color: ChessPieceColor
) : ChessPiece {
    override fun getType(): ChessPieceType = type
    override fun getColor(): ChessPieceColor = color
    
    override fun display(position: Position) {
        // 실제 구현에서는 체스 말을 화면에 표시하는 로직이 들어갈 것
        println("${color} ${type} at position (${position.x}, ${position.y})")
    }
}

// 플라이웨이트 팩토리 - 체스 말 객체 생성 및 공유 관리
class ChessPieceFactory {
    private val pieces = mutableMapOf<String, ChessPiece>()
    
    fun getChessPiece(type: ChessPieceType, color: ChessPieceColor): ChessPiece {
        // 키 생성: 타입과 색상을 조합
        val key = "${type}_${color}"
        
        // 기존 객체가 없으면 새로 생성
        if (!pieces.containsKey(key)) {
            pieces[key] = ConcretePiece(type, color)
            println("Creating new chess piece: $key")
        } else {
            println("Reusing existing chess piece: $key")
        }
        
        return pieces[key]!!
    }
    
    fun getPieceCount(): Int = pieces.size
}

// 체스판 - 클라이언트 역할
class ChessBoard(private val id: Int, private val factory: ChessPieceFactory) {
    // 체스판에 배치된 말들의 정보를 저장 (말의 참조와 위치)
    private val piecesWithPositions = mutableMapOf<Position, ChessPiece>()
    
    // 체스판 초기화
    fun initialize() {
        // 폰 배치
        for (i in 0..7) {
            addPiece(ChessPieceType.PAWN, ChessPieceColor.BLACK, Position(i, 1))
            addPiece(ChessPieceType.PAWN, ChessPieceColor.RED, Position(i, 6))
        }
        
        // 룩 배치
        addPiece(ChessPieceType.ROOK, ChessPieceColor.BLACK, Position(0, 0))
        addPiece(ChessPieceType.ROOK, ChessPieceColor.BLACK, Position(7, 0))
        addPiece(ChessPieceType.ROOK, ChessPieceColor.RED, Position(0, 7))
        addPiece(ChessPieceType.ROOK, ChessPieceColor.RED, Position(7, 7))
        
        // 나이트 배치
        addPiece(ChessPieceType.KNIGHT, ChessPieceColor.BLACK, Position(1, 0))
        addPiece(ChessPieceType.KNIGHT, ChessPieceColor.BLACK, Position(6, 0))
        addPiece(ChessPieceType.KNIGHT, ChessPieceColor.RED, Position(1, 7))
        addPiece(ChessPieceType.KNIGHT, ChessPieceColor.RED, Position(6, 7))
        
        // 비숍 배치
        addPiece(ChessPieceType.BISHOP, ChessPieceColor.BLACK, Position(2, 0))
        addPiece(ChessPieceType.BISHOP, ChessPieceColor.BLACK, Position(5, 0))
        addPiece(ChessPieceType.BISHOP, ChessPieceColor.RED, Position(2, 7))
        addPiece(ChessPieceType.BISHOP, ChessPieceColor.RED, Position(5, 7))
        
        // 퀸 배치
        addPiece(ChessPieceType.QUEEN, ChessPieceColor.BLACK, Position(3, 0))
        addPiece(ChessPieceType.QUEEN, ChessPieceColor.RED, Position(3, 7))
        
        // 킹 배치
        addPiece(ChessPieceType.KING, ChessPieceColor.BLACK, Position(4, 0))
        addPiece(ChessPieceType.KING, ChessPieceColor.RED, Position(4, 7))
    }
    
    private fun addPiece(type: ChessPieceType, color: ChessPieceColor, position: Position) {
        // 팩토리로부터 공유된 체스 말 객체를 가져옴
        val piece = factory.getChessPiece(type, color)
        // 위치 정보(외부 상태)와 함께 체스 말을 저장
        piecesWithPositions[position] = piece
    }
    
    fun display() {
        println("Displaying chess board #$id")
        for (entry in piecesWithPositions) {
            val position = entry.key
            val piece = entry.value
            piece.display(position)
        }
        println("----------------------------")
    }
    
    fun movePiece(from: Position, to: Position) {
        if (piecesWithPositions.containsKey(from)) {
            val piece = piecesWithPositions[from]!!
            piecesWithPositions.remove(from)
            piecesWithPositions[to] = piece
            println("Moved piece from (${from.x}, ${from.y}) to (${to.x}, ${to.y})")
        } else {
            println("No piece at position (${from.x}, ${from.y})")
        }
    }
}

// 대기실 - 다수의 체스 방(체스판) 관리
class ChessLobby {
    private val factory = ChessPieceFactory()
    private val boards = mutableMapOf<Int, ChessBoard>()
    
    fun createBoard(id: Int): ChessBoard {
        val board = ChessBoard(id, factory)
        board.initialize()
        boards[id] = board
        return board
    }
    
    fun getBoardCount(): Int = boards.size
    
    fun getPieceInstanceCount(): Int = factory.getPieceCount()
}

// 메인 함수 - 플라이웨이트 패턴 테스트
fun main() {
    val lobby = ChessLobby()
    
    // 1000개의 체스판 생성
    for (i in 1..1000) {
        lobby.createBoard(i)
    }
    
    println("Total chess boards created: ${lobby.getBoardCount()}")
    println("Total chess piece objects in memory: ${lobby.getPieceInstanceCount()}")
    
    // 임의의 체스판에서 말 이동 테스트
    val board = lobby.createBoard(1001)
    board.display()
    board.movePiece(Position(4, 0), Position(4, 1))
    board.display()
}