// 메멘토(스냅샷): 에디터 상태의 복사본
// data class: 불변 복사본 생성에 적합, copy()도 지원
data class EditorMemento(val content: String, val cursorPosition: Int)

// 원본(Originator): 실제 편집 기능을 담당
class TextEditor {
    var content: String = ""
    var cursorPosition: Int = 0

    // 현재 커서 위치에 텍스트 삽입
    fun type(text: String) {
        content = content.substring(0, cursorPosition) + text + content.substring(cursorPosition)
        cursorPosition += text.length  // 커서를 삽입한 텍스트 끝으로 이동
    }

    // 커서 앞의 텍스트를 count만큼 삭제 (백스페이스와 동일)
    fun delete(count: Int) {
        if (cursorPosition < count) return
        content = content.substring(0, cursorPosition - count) + content.substring(cursorPosition)
        cursorPosition -= count  // 커서를 삭제한 만큼 앞으로 이동
    }

    // 현재 상태의 스냅샷(메멘토) 생성
    fun save() = EditorMemento(content, cursorPosition)

    // 저장된 스냅샷으로 상태 복원
    fun restore(memento: EditorMemento) {
        content = memento.content
        cursorPosition = memento.cursorPosition
    }

    fun show() = println("\"$content\" (커서: $cursorPosition)")
}

// 보관자(Caretaker): Undo/Redo 스택으로 메멘토를 관리
class EditorHistory {
    private val undoStack = ArrayDeque<EditorMemento>()
    private val redoStack = ArrayDeque<EditorMemento>()

    // 작업 후 현재 상태를 저장 (redo 스택은 초기화 — 새 작업 시 redo 불가)
    fun save(editor: TextEditor) {
        undoStack.addLast(editor.save())
        redoStack.clear()  // 새 작업이 발생하면 redo 히스토리 삭제
    }

    // Undo: 가장 최근 상태를 redo 스택으로 이동하고, 그 전 상태로 복원
    fun undo(editor: TextEditor) {
        if (undoStack.size <= 1) { println("되돌릴 기록 없음"); return }
        redoStack.addLast(undoStack.removeLast())  // 현재 상태를 redo 스택으로
        editor.restore(undoStack.last())           // 이전 상태로 복원
    }

    // Redo: redo 스택에서 꺼내 다시 적용
    fun redo(editor: TextEditor) {
        if (redoStack.isEmpty()) { println("다시 실행할 기록 없음"); return }
        val memento = redoStack.removeLast()       // redo 스택에서 꺼냄
        undoStack.addLast(memento)                 // undo 스택에도 추가
        editor.restore(memento)                    // 해당 상태로 복원
    }
}

// 사용 예시
val editor = TextEditor()
val history = EditorHistory()

history.save(editor)                              // 초기 상태 저장 (빈 문서)
editor.type("Hello"); history.save(editor)
editor.show()  // "Hello" (커서: 5)

editor.type(" World"); history.save(editor)
editor.show()  // "Hello World" (커서: 11)

editor.delete(5); history.save(editor)
editor.show()  // "Hello " (커서: 6)

history.undo(editor); editor.show()  // "Hello World" 복원 (커서: 11)
history.undo(editor); editor.show()  // "Hello" 복원 (커서: 5)
history.redo(editor); editor.show()  // "Hello World" 재실행 (커서: 11)

// 게임 상태 — data class이므로 copy()로 불변 스냅샷 즉시 생성
data class GameState(
    val level: Int,
    val health: Int,
    val score: Int,
    val position: Pair<Int, Int>  // (x, y) 좌표
)

class Game {
    var state = GameState(level = 1, health = 100, score = 0, position = 0 to 0)
        private set  // 외부에서 직접 변경 불가

    private val saveSlots = mutableMapOf<String, GameState>()

    // 세이브: 현재 상태를 슬롯 이름으로 저장
    // copy()는 값 복사 → 이후 state가 바뀌어도 저장된 스냅샷은 불변
    fun save(slotName: String) {
        saveSlots[slotName] = state.copy()
        println("저장됨: $slotName")
    }

    // 로드: 슬롯에서 상태 복원
    fun load(slotName: String) {
        state = saveSlots[slotName] ?: run { println("슬롯 없음: $slotName"); return }
        println("불러옴: $slotName → $state")
    }

    // 게임 진행: 원하는 필드만 변경 (copy의 named parameters 활용)
    fun progress(levelUp: Int = 0, damage: Int = 0, points: Int = 0, dx: Int = 0, dy: Int = 0) {
        state = state.copy(
            level    = state.level + levelUp,
            health   = (state.health - damage).coerceAtLeast(0),  // 0 이하로 내려가지 않음
            score    = state.score + points,
            position = state.position.first + dx to state.position.second + dy
        )
    }
}

val game = Game()

game.progress(points = 500, dx = 10, dy = 5)
game.save("체크포인트1")   // 현재 상태 저장

game.progress(levelUp = 1, damage = 30, points = 1000, dx = 20)
game.save("체크포인트2")   // 또 다른 지점 저장

game.progress(damage = 80)  // 큰 피해 발생!
println("현재: ${game.state}")  // health 감소 확인

game.load("체크포인트1")    // 피해 없는 지점으로 복원
println("복원: ${game.state}")  // 체크포인트1 상태 출력

// 변경 이력을 sealed class로 표현
sealed class Change {
    // 어느 위치(position)에 무슨 텍스트(text)를 삽입했는지 기록
    data class TextInserted(val position: Int, val text: String) : Change()
    // 어느 위치에서 몇 글자(count)를 삭제했는지 기록
    data class TextDeleted(val position: Int, val count: Int) : Change()
}

class EfficientEditor {
    private var content = ""
    // 전체 스냅샷 대신 변경 이력만 저장
    private val changes = ArrayDeque<Change>()

    fun insert(pos: Int, text: String) {
        content = content.substring(0, pos) + text + content.substring(pos)
        changes.addLast(Change.TextInserted(pos, text))  // 삽입 이력 기록
    }

    fun delete(pos: Int, count: Int) {
        changes.addLast(Change.TextDeleted(pos, count))  // 삭제 이력 기록 (삭제 전에!)
        content = content.substring(0, pos) + content.substring(pos + count)
    }

    // 마지막 변경을 되돌림 (변경 이력의 역연산)
    fun undo() {
        val change = changes.removeLastOrNull() ?: return
        when (change) {
            // 삽입을 undo → 삽입했던 만큼 삭제
            is Change.TextInserted ->
                content = content.substring(0, change.position) +
                    content.substring(change.position + change.text.length)
            // 삭제를 undo → 삭제했던 위치에 다시 삽입
            // (실제로는 삭제 전 내용도 Change에 저장해야 복원 가능)
            is Change.TextDeleted  ->
                content = content.substring(0, change.position) +
                    "?".repeat(change.count) + content.substring(change.position)
        }
    }

    fun getContent() = content
}