// Java: ExecutionContext를 매번 전달
public class OrderService {
    public CompletableFuture<Order> createOrder(OrderRequest req, ExecutionContext ec) {
        return validateOrder(req, ec)
            .thenCompose(valid -> saveOrder(valid, ec))
            .thenCompose(saved -> notifyUser(saved, ec));
    }

    private CompletableFuture<Order> validateOrder(OrderRequest req, ExecutionContext ec) { ... }
    private CompletableFuture<Order> saveOrder(Order order, ExecutionContext ec) { ... }
    private CompletableFuture<Void> notifyUser(Order order, ExecutionContext ec) { ... }
}

// Scala: ExecutionContext를 암시적으로 전달
class OrderService(using ec: ExecutionContext):
  def createOrder(req: OrderRequest): Future[Order] =
    validateOrder(req)
      .flatMap(saveOrder)
      .flatMap(notifyUser)

  private def validateOrder(req: OrderRequest): Future[Order] = ...
  private def saveOrder(order: Order): Future[Order] = ...
  private def notifyUser(order: Order): Future[Unit] = ...

// 사용 시 한 번만 제공
given ExecutionContext = ExecutionContext.global
val service = OrderService()
service.createOrder(request)  // ec 자동 주입

// Java: String에 toSlug 메서드를 추가하고 싶다면
public class StringUtils {
    public static String toSlug(String s) {
        return s.toLowerCase().replaceAll(" ", "-");
    }
}
// 사용: StringUtils.toSlug(title) — 어색함

// 또는 래퍼 클래스
public class RichString {
    private final String value;
    public RichString(String value) { this.value = value; }
    public String toSlug() { return value.toLowerCase().replaceAll(" ", "-"); }
}
// 사용: new RichString(title).toSlug() — 더 어색함

// Scala 3: String에 직접 메서드 추가
extension (s: String)
  def toSlug: String = s.toLowerCase.replace(" ", "-")
  def words: List[String] = s.split("\\s+").toList

// 사용: 마치 String의 원래 메서드인 것처럼
"Hello World".toSlug   // "hello-world"
"Hello World".words    // List("Hello", "World")

// Java: 타입별로 다른 직렬화 로직
public class JsonSerializer {
    public String toJson(Object obj) {
        if (obj instanceof String) {
            return "\"" + obj + "\"";
        } else if (obj instanceof Integer) {
            return obj.toString();
        } else if (obj instanceof List) {
            List<?> list = (List<?>) obj;
            return list.stream()
                .map(this::toJson)
                .collect(Collectors.joining(",", "[", "]"));
        }
        throw new IllegalArgumentException("Unsupported type");
    }
}
// 문제: 새 타입 추가 시 이 메서드를 수정해야 함 (Open-Closed 원칙 위반)

// Scala: 타입 클래스 패턴
trait JsonEncoder[A]:
  def encode(a: A): String

given JsonEncoder[String] with
  def encode(a: String): String = s"\"$a\""

given JsonEncoder[Int] with
  def encode(a: Int): String = a.toString

given [A](using enc: JsonEncoder[A]): JsonEncoder[List[A]] with
  def encode(list: List[A]): String =
    list.map(enc.encode).mkString("[", ",", "]")

def toJson[A](a: A)(using enc: JsonEncoder[A]): String = enc.encode(a)

// 새 타입 추가 - 기존 코드 수정 없이 확장
case class User(name: String, age: Int)
given JsonEncoder[User] with
  def encode(u: User): String = s"""{"name":"${u.name}","age":${u.age}}"""

toJson(List("a", "b"))  // ["a","b"]
toJson(User("Kim", 30)) // {"name":"Kim","age":30}

// ❌ 안티패턴 1: 너무 일반적인 타입
given String = "default"  // 모든 String 파라미터에 주입됨!
given Int = 0             // 위험!

// ✅ 올바른 방법: 래퍼 타입 사용
case class ApiKey(value: String)
given ApiKey = ApiKey("default-key")

// ❌ 안티패턴 2: 비즈니스 로직 숨기기
def processOrder(orderId: String)(using discount: Double): Order = ...
// 할인율이 어디서 오는지 추적 어려움

// ✅ 올바른 방법: 명시적 파라미터
def processOrder(orderId: String, discount: Double): Order = ...

// ❌ 안티패턴 3: 암시적 변환 남용
given Conversion[String, Int] = _.toInt
val x: Int = "123"  // 컴파일되지만 위험

// ✅ 올바른 방법: 명시적 변환 또는 extension
extension (s: String)
  def toIntSafe: Option[Int] = s.toIntOption

// 암시적 값 정의
implicit val defaultName: String = "Guest"

// 암시적 매개변수 사용
def greet(implicit name: String): String = s"Hello, $name!"

greet              // "Hello, Guest!" (암시적으로 전달)
greet("Alice")     // "Hello, Alice!" (명시적 전달)

case class Config(url: String, timeout: Int)

implicit val defaultConfig: Config = Config("localhost", 5000)

def connect(implicit config: Config): Unit =
  println(s"Connecting to ${config.url} with timeout ${config.timeout}")

connect  // 암시적 Config 사용

// Int에서 String으로 암시적 변환
implicit def intToString(i: Int): String = i.toString

val s: String = 42  // 자동으로 "42"로 변환

// 위험할 수 있으므로 주의해서 사용!

implicit class RichString(s: String) {
  def exclaim: String = s + "!"
  def words: List[String] = s.split(" ").toList
}

"Hello".exclaim          // "Hello!"
"Hello World".words      // List("Hello", "World")

// 이름 없는 given
given String = "Guest"

// 타입만으로 참조
summon[String]  // "Guest"

case class Config(url: String, timeout: Int)

given Config = Config("localhost", 5000)

def connect(using config: Config): Unit =
  println(s"Connecting to ${config.url}")

connect  // Config를 암시적으로 사용

// 컨텍스트 경계 문법
def print[A: Show](a: A): Unit = {
  val s = summon[Show[A]]  // Scala 3
  // val s = implicitly[Show[A]]  // Scala 2
  println(s.show(a))
}

case class User(name: String)

object User {
  // 컴패니언 객체에 암시적 정의
  implicit val ordering: Ordering[User] =
    Ordering.by(_.name)
}

// 자동으로 User.ordering을 찾음
List(User("Bob"), User("Alice")).sorted
// List(User("Alice"), User("Bob"))

object Givens:
  given Int = 42
  given String = "hello"
  val normalValue = 100

// 특정 타입의 given만 import (중괄호 사용)
import Givens.{given Int}

// 모든 given import
import Givens.given

// 일반 멤버와 given 모두 import
import Givens.*       // normalValue만 import
import Givens.given   // given Int, given String만 import

// 둘 다 필요하면
import Givens.{*, given}

// Scala 3에서도 동작
implicit val x: Int = 42
def f(implicit n: Int): Int = n * 2

// 타입 클래스에 사용
given Ordering[MyClass] = ???

// 설정/컨텍스트 전달
def process(data: Data)(using config: Config): Result = ???

// 확장 메서드
extension (s: String)
  def toSlug: String = s.toLowerCase.replace(" ", "-")

// 무분별한 암시적 변환 (피하세요)
given Conversion[Int, String] = _.toString

// 너무 일반적인 타입의 암시적 (피하세요)
given String = "default"  // 어디서나 String이 필요하면 사용됨

// 1. 너무 일반적인 타입의 암시적 정의
implicit val defaultString: String = "hello"
// 모든 곳에서 String이 필요하면 이 값이 주입됨!

// 2. 무분별한 암시적 변환
implicit def stringToInt(s: String): Int = s.toInt
val x: Int = "123"  // 암시적으로 변환됨 - 위험!
val y: Int = "abc"  // NumberFormatException!

// 3. 암시적 범위 충돌
import library1._
import library2._  // 둘 다 같은 타입의 implicit 정의
// "ambiguous implicit values" 에러!

// 4. 복잡한 암시적 체인
// A → B → C → D 변환이 필요하면 컴파일 시간이 급격히 증가

// 1. 구체적인 래퍼 타입 사용
case class AppConfig(dbUrl: String, timeout: Int)
given AppConfig = AppConfig("localhost", 5000)

// 2. 암시적 변환 대신 extension 메서드
extension (s: String)
  def toIntSafe: Option[Int] = s.toIntOption

"123".toIntSafe  // Some(123)
"abc".toIntSafe  // None

// 3. 명시적 import로 충돌 해결
import library1.{given OrderingInstance}  // 특정 given만 import

// 4. 단순한 타입 클래스 계층 유지
trait Show[A]:
  def show(a: A): String

// 파생 인스턴스는 한 단계로 제한
given [A: Show]: Show[List[A]] = ...

// 어떤 implicit이 선택되었는지 확인
// scalac: -Xprint:typer
// sbt: set scalacOptions += "-Xprint:typer"

// Scala 3에서 summon 사용
val ord = summon[Ordering[Int]]
println(ord)  // scala.math.Ordering$Int$@...