// 첫 번째 테스트: 가장 기본적인 기능
@Test
fun `유효한 좌표로 Position을 생성할 수 있다`() {
    // Given: 유효한 체스 좌표
    val file = 'e'
    val rank = 4
    
    // When: Position 객체 생성
    val position = Position(file, rank)
    
    // Then: 올바른 값이 저장됨
    position.file shouldBe 'e'
    position.rank shouldBe 4
}

// 테스트가 요구하는 인터페이스
class Position(val file: Char, val rank: Int) {
    // 이것만으로도 테스트가 통과된다!
}

// 물리적 현실: 8x8 나무 보드의 특정 칸
// ↓ 추상화
// 논리적 모델: Position('e', 4)

// 가장 간단한 구현
data class Position(val file: Char, val rank: Int)

// 이런 무효한 좌표도 허용됨!
Position('z', 9)  // 체스판을 벗어남
Position('@', 0)  // 잘못된 문자
Position('a', -1) // 음수 rank

context("Position 생성 테스트") {
    // Positive Test: 올바른 경우
    test("유효한 좌표로 Position을 생성할 수 있다") {
        val position = Position('e', 4)
        position.file shouldBe 'e'
        position.rank shouldBe 4
    }
    
    // Negative Test: 잘못된 경우들
    test("유효하지 않은 file로 Position 생성 시 예외가 발생한다") {
        shouldThrow<IllegalArgumentException> {
            Position('z', 4)  // file 범위 초과
        }
        
        shouldThrow<IllegalArgumentException> {
            Position('@', 4)  // 잘못된 문자
        }
    }
    
    test("유효하지 않은 rank로 Position 생성 시 예외가 발생한다") {
        shouldThrow<IllegalArgumentException> {
            Position('e', 0)   // rank 범위 미만
        }
        
        shouldThrow<IllegalArgumentException> {
            Position('e', 9)   // rank 범위 초과
        }
    }
}

test("경계값에서 Position이 올바르게 동작한다") {
    // 최소 경계값
    shouldNotThrow<Exception> { Position('a', 1) }
    
    // 최대 경계값  
    shouldNotThrow<Exception> { Position('h', 8) }
    
    // 경계 바로 밖
    shouldThrow<IllegalArgumentException> { Position('`', 1) } // 'a' - 1
    shouldThrow<IllegalArgumentException> { Position('i', 1) } // 'h' + 1
    shouldThrow<IllegalArgumentException> { Position('a', 0) } // 1 - 1
    shouldThrow<IllegalArgumentException> { Position('a', 9) } // 8 + 1
}

data class Position(val file: Char, val rank: Int) {
    init {
        require(file in 'a'..'h') { 
            "File must be between 'a' and 'h', but was '$file'" 
        }
        require(rank in 1..8) { 
            "Rank must be between 1 and 8, but was $rank" 
        }
    }
}

// Value Object로서의 Position
val pos1 = Position('e', 4)
val pos2 = Position('e', 4)

pos1 == pos2  // true (값 기반 동등성)
pos1 === pos2 // false (다른 인스턴스)

// 불변성 보장
// pos1.file = 'f'  // 컴파일 오류!

// 사용자가 잘못된 입력을 할 때
val input = "z9z9"  // 체스판을 벗어나는 좌표

try {
    val move = Move.parse(input)  // 내부에서 Position 생성
} catch (e: IllegalArgumentException) {
    println("⚠️ 유효하지 않은 좌표이다: ${e.message}")
    // 사용자에게 친절한 오류 메시지 제공
}

@Test
fun `Position 동등성이 올바르게 작동한다`() {
    // 준비(Arrange)
    val pos1 = Position('e', 4)
    val pos2 = Position('e', 4)
    val pos3 = Position('d', 4)
    
    // 실행 & 검증(Act & Assert)
    pos1 shouldBe pos2      // 값이 같으면 동등
    pos1 shouldNotBe pos3   // 값이 다르면 다름
    
    // 해시코드 일관성
    pos1.hashCode() shouldBe pos2.hashCode()
}

@Test
fun `Position을 문자열로 표현할 수 있다`() {
    val position = Position('e', 4)
    position.toString() shouldBe "Position(file=e, rank=4)"
}

val position = Position('e', 4)

// 이 모든 호출이 position의 상태를 변경하지 않음
position.file     // 부작용 없음
position.rank     // 부작용 없음  
position.toString() // 부작용 없음
position.equals(other) // 부작용 없음
position.hashCode() // 부작용 없음

// Mock이 필요한 복잡한 객체
class ComplexService(
    private val database: Database,
    private val httpClient: HttpClient,
    private val logger: Logger
) {
    fun process() {
        // 외부 의존성과 상호작용
    }
}

// Mock이 불필요한 단순한 값 객체
class Position(val file: Char, val rank: Int) {
    // 외부 의존성 없음
}

test("두 Position 간 맨해튼 거리를 계산할 수 있다") {
    val from = Position('a', 1)
    val to = Position('h', 8)
    
    val distance = from.manhattanDistanceTo(to)
    
    distance shouldBe 14  // |h-a| + |8-1| = 7 + 7 = 14
}

// 컴파일 오류 발생: manhattanDistanceTo 메서드 없음
val distance = from.manhattanDistanceTo(to)

data class Position(val file: Char, val rank: Int) {
    init { /* 기존 검증 로직 */ }
    
    fun manhattanDistanceTo(other: Position): Int {
        val fileDiff = kotlin.math.abs(this.file.code - other.file.code)
        val rankDiff = kotlin.math.abs(this.rank - other.rank)
        return fileDiff + rankDiff
    }
}

fun manhattanDistanceTo(other: Position): Int {
    val fileDifference = kotlin.math.abs(this.file - other.file)
    val rankDifference = kotlin.math.abs(this.rank - other.rank)
    return fileDifference + rankDifference
}

// 연산자 오버로딩으로 더 읽기 쉽게
private operator fun Char.minus(other: Char): Int = this.code - other.code

// 기물 이동 검증
fun isValidMove(from: Position, to: Position): Boolean

// 보드 상태 관리  
fun getPiece(position: Position): Piece?

// 이동 명령 파싱
fun parse(notation: String): Move  // 내부에서 Position 생성

// 체크 상태 확인
fun isPositionUnderAttack(position: Position, attackingColor: Color): Boolean

// 도메인 전문가(체스 플레이어)의 언어
"백색 킹을 e1에서 g1로 이동"  

// 코드에서의 표현
val from = Position('e', 1)
val to = Position('g', 1)
val move = Move(from, to)