# JDK 버전 확인 (JFR은 JDK 11+에서 기본 제공)
java -version
# 출력 예: openjdk version "17.0.8"

# VisualVM 설치 (macOS)
brew install --cask visualvm

# 실행 중인 애플리케이션에 JFR 연결
# 1. 먼저 PID 확인
jps -l
# 출력 예: 12345 com.example.MyApp

# 2. JFR 레코딩 시작 (60초)
jcmd 12345 JFR.start duration=60s filename=recording.jfr

# 3. 레코딩 확인
jcmd 12345 JFR.check

# 4. 레코딩 중지 (duration 전에 수동 종료)
jcmd 12345 JFR.stop

# sbt에서 JFR 활성화
sbt -J-XX:StartFlightRecording=duration=120s,filename=app.jfr run

# 또는 build.sbt에서 설정
javaOptions += "-XX:StartFlightRecording=duration=120s,filename=app.jfr"

# JDK Mission Control (JMC)로 분석
jmc  # GUI 도구 실행 후 .jfr 파일 열기

# CLI로 간단히 확인
jfr summary recording.jfr

# 이벤트 필터링
jfr print --events jdk.CPULoad recording.jfr
jfr print --events jdk.ObjectAllocationSample recording.jfr

# 실행 중인 프로세스의 힙 덤프
jmap -dump:format=b,file=heap.hprof 12345

# OOM 발생 시 자동 덤프
sbt -J-XX:+HeapDumpOnOutOfMemoryError -J-XX:HeapDumpPath=./heap.hprof run

# VisualVM 실행
visualvm

# 1. File > Load... > heap.hprof 선택
# 2. Summary 탭에서 가장 큰 객체 확인
# 3. Classes 탭에서 인스턴스 수가 많은 클래스 확인

// 잘못된 예: 클로저가 외부 객체 전체를 참조
class DataProcessor {
  val largeData: Array[Byte] = new Array[Byte](100 * 1024 * 1024) // 100MB

  def getProcessor(): () => Unit = {
    // 이 클로저는 DataProcessor 전체(largeData 포함)를 참조함
    () => println("Processing...")
  }
}

// 올바른 예: 필요한 데이터만 캡처
class DataProcessor {
  val largeData: Array[Byte] = new Array[Byte](100 * 1024 * 1024)

  def getProcessor(): () => Unit = {
    val message = "Processing..."  // 필요한 값만 로컬에 복사
    () => println(message)
  }
}

// 1. 앞에서 추가/제거가 많은 경우 -> List
val stack = List(1, 2, 3)
val pushed = 0 :: stack        // O(1) prepend
val (head, tail) = (stack.head, stack.tail)  // O(1)

// 2. 랜덤 접근이 필요한 경우 -> Vector 또는 Array
val indexed = Vector(1, 2, 3)
indexed(1)                     // O(log n), 사실상 O(1)에 가까움

// 3. 성능이 가장 중요한 수치 연산 -> Array
val numbers = Array(1.0, 2.0, 3.0)
numbers(0)                     // O(1), 박싱 없음(primitive)

// 4. 가변 컬렉션이 필요한 경우 -> ArrayBuffer
import scala.collection.mutable.ArrayBuffer
val buffer = ArrayBuffer(1, 2, 3)
buffer += 4                    // O(1) amortized append

// project/plugins.sbt
addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.7")

// build.sbt
enablePlugins(JmhPlugin)

import org.openjdk.jmh.annotations._
import java.util.concurrent.TimeUnit

@BenchmarkMode(Array(Mode.AverageTime))
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
class CollectionBenchmark {
  val size = 10000
  val list: List[Int] = (1 to size).toList
  val vector: Vector[Int] = (1 to size).toVector
  val array: Array[Int] = (1 to size).toArray

  @Benchmark
  def listIndexAccess(): Int = list(size / 2)

  @Benchmark
  def vectorIndexAccess(): Int = vector(size / 2)

  @Benchmark
  def arrayIndexAccess(): Int = array(size / 2)
}

# 벤치마크 실행
sbt "jmh:run -i 10 -wi 5 -f 2 CollectionBenchmark"

// 박싱이 발생하는 코드
def sum[A](list: List[A])(implicit num: Numeric[A]): A = {
  list.foldLeft(num.zero)(num.plus)
  // Int가 java.lang.Integer로 박싱/언박싱 반복
}

// 원시 타입을 직접 사용하면 박싱 없음
def sumInts(list: Array[Int]): Int = {
  var total = 0
  var i = 0
  while (i < list.length) {
    total += list(i)
    i += 1
  }
  total
}

// @specialized 없이: 모든 타입이 Object로 박싱
class Container[A](val value: A)

// @specialized 사용: Int, Double 등에 대해 별도 클래스 생성
class Container[@specialized(Int, Double, Long) A](val value: A)

// 사용 시 박싱이 발생하지 않음
val intContainer = new Container[Int](42)       // Container$mcI$sp 사용
val doubleContainer = new Container[Double](3.14) // Container$mcD$sp 사용

import scala.annotation.tailrec

// 잘못된 예: 꼬리 재귀가 아님 (스택 오버플로 위험)
def factorial(n: Long): Long = {
  if (n <= 1) 1
  else n * factorial(n - 1)  // 재귀 호출 후 곱셈이 있음
}

// 올바른 예: 꼬리 재귀 (컴파일러가 루프로 변환)
@tailrec
def factorial(n: Long, acc: Long = 1): Long = {
  if (n <= 1) acc
  else factorial(n - 1, n * acc)  // 마지막 연산이 재귀 호출
}

factorial(100000)  // 스택 오버플로 없음

import scala.annotation.tailrec

// 컴파일 에러: could not optimize @tailrec annotated method
// 이유: 재귀 호출이 마지막 연산이 아님
// @tailrec
// def sum(list: List[Int]): Int = list match {
//   case Nil => 0
//   case head :: tail => head + sum(tail)  // + 연산이 마지막
// }

// 해결: 누산기(accumulator) 패턴 사용
@tailrec
def sum(list: List[Int], acc: Int = 0): Int = list match {
  case Nil => acc
  case head :: tail => sum(tail, acc + head)  // 재귀 호출이 마지막
}

import scala.util.control.TailCalls._

def isEven(n: Long): TailRec[Boolean] = {
  if (n == 0) done(true)
  else tailcall(isOdd(n - 1))
}

def isOdd(n: Long): TailRec[Boolean] = {
  if (n == 0) done(false)
  else tailcall(isEven(n - 1))
}

// 스택 오버플로 없이 실행
isEven(1000000).result  // true

// 잘못된 예: 중간 컬렉션이 3개 생성됨
val result = (1 to 1000000)
  .map(_ * 2)       // 중간 컬렉션 1
  .filter(_ > 100)  // 중간 컬렉션 2
  .take(10)          // 중간 컬렉션 3

// 올바른 예: view로 지연 평가
val result = (1 to 1000000).view
  .map(_ * 2)
  .filter(_ > 100)
  .take(10)
  .toList  // 최종 결과만 생성

// 또는 iterator 사용
val result = (1 to 1000000).iterator
  .map(_ * 2)
  .filter(_ > 100)
  .take(10)
  .toList

// 잘못된 예: O(n^2) - 매 연결마다 새 String 생성
var result = ""
for (i <- 1 to 10000) {
  result += s"item-$i,"  // 매번 복사 발생
}

// 올바른 예: StringBuilder 사용 - O(n)
val sb = new StringBuilder
for (i <- 1 to 10000) {
  sb.append(s"item-$i,")
}
val result = sb.toString()

// 또는 mkString 사용
val result = (1 to 10000).map(i => s"item-$i").mkString(",")

// 성능에 영향이 있을 수 있는 깊은 중첩
def process(data: Any): String = data match {
  case list: List[_] => list.headOption match {
    case Some(map: Map[_, _]) => map.headOption match {
      case Some((k, v)) => s"$k -> $v"
      case None => "empty map"
    }
    case _ => "not a map list"
  }
  case _ => "unknown"
}

// 타입을 명확히 하여 패턴 매칭 단순화
case class ProcessInput(data: List[Map[String, String]])

def process(input: ProcessInput): String = {
  input.data.headOption
    .flatMap(_.headOption)
    .map { case (k, v) => s"$k -> $v" }
    .getOrElse("empty")
}