package actor.supervisor

import akka.actor.typed.ActorRef
import akka.actor.typed.Behavior
import akka.actor.typed.javadsl.AbstractBehavior
import akka.actor.typed.javadsl.ActorContext
import akka.actor.typed.javadsl.Behaviors
import akka.actor.typed.javadsl.Receive

import actor.Hello
import actor.HelloActor
import actor.HelloActorCommand
import actor.HelloActorResponse
import akka.actor.typed.SupervisorStrategy
import akka.actor.typed.Terminated

/** SupervisorActor가 처리할 수 있는 명령들 */
sealed class SupervisorCommand

data class CreateChild(val name: String) : SupervisorCommand()
data class SendHello(
    val childName: String,
    val message: String,
    val replyTo: ActorRef<HelloActorResponse>
) : SupervisorCommand()
data class GetChildCount(val replyTo: ActorRef<Int>) : SupervisorCommand()
data class TerminateChild(val name: String) : SupervisorCommand()

class SupervisorActor private constructor(
    context: ActorContext<SupervisorCommand>
) : AbstractBehavior<SupervisorCommand>(context) {

    companion object {
        fun create(): Behavior<SupervisorCommand> {
            return Behaviors.setup { context -> SupervisorActor(context) }
        }
    }

    private val children = mutableMapOf<String, ActorRef<HelloActorCommand>>()

    override fun createReceive(): Receive<SupervisorCommand> {
        return newReceiveBuilder()
            .onMessage(CreateChild::class.java, this::onCreateChild)
            .onMessage(SendHello::class.java, this::onSendHello)
            .onMessage(GetChildCount::class.java, this::onGetChildCount)
            .onMessage(TerminateChild::class.java, this::onTerminateChild)
            .onSignal(Terminated::class.java, this::onChildTerminated)
            .build()
    }

    private fun onCreateChild(command: CreateChild): Behavior<SupervisorCommand> {
        val childName = command.name
        val childActor = context.spawn(
            Behaviors.supervise(HelloActor.create())
                .onFailure(SupervisorStrategy.restart()),
            childName
        )
        context.watch(childActor)

        children[childName] = childActor
        context.log.info("Created child actor with name: $childName")
        return this
    }

    private fun onSendHello(command: SendHello): Behavior<SupervisorCommand> {
        val child = children[command.childName]
        if (child != null) {
            child.tell(Hello(command.message, command.replyTo))
        } else {
            context.log.warn("Child actor [${command.childName}] does not exist.")
        }
        return this
    }

    private fun onGetChildCount(command: GetChildCount): Behavior<SupervisorCommand> {
        command.replyTo.tell(children.size)
        return this
    }

    private fun onChildTerminated(terminated: Terminated): Behavior<SupervisorCommand> {
        val childActor = terminated.ref
        val childName = childActor.path().name()
        children.remove(childName)
        context.log.info("Child actor terminated: $childName")
        return this
    }

    private fun onTerminateChild(command: TerminateChild): Behavior<SupervisorCommand> {
        val child = children[command.name]
        if (child != null) {
            context.stop(child)
            context.log.info("Terminated child actor: ${command.name}")
        } else {
            context.log.warn("Attempted to terminate non-existent child actor: ${command.name}")
        }
        return this
    }

}

package actor.supervisor

import actor.HelloActorResponse
import actor.HelloResponse
import akka.actor.testkit.typed.javadsl.ActorTestKit
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test

class SupervisorActorTest {

    companion object {
        private lateinit var testKit: ActorTestKit

        @BeforeAll
        @JvmStatic
        fun setup() {
            testKit = ActorTestKit.create()
        }

        @AfterAll
        @JvmStatic
        fun teardown() {
            testKit.shutdownTestKit()
        }
    }

    @Test
    fun testSupervisorCreatesChildAndResponds() {
        val responseProbe = testKit.createTestProbe<HelloActorResponse>()
        val supervisor = testKit.spawn(SupervisorActor.create())

        // 자식 액터 생성 요청
        supervisor.tell(CreateChild("child1"))

        // 자식 액터에게 메시지 전송 요청
        supervisor.tell(SendHello("child1", "Hello", responseProbe.ref()))

        // 응답 확인
        responseProbe.expectMessage(HelloResponse("Kotlin"))

        // 자식 액터 수 확인
        val countProbe = testKit.createTestProbe<Int>()
        supervisor.tell(GetChildCount(countProbe.ref()))
        countProbe.expectMessage(1)
    }

    @Test
    fun testSupervisorHandlesUnknownChild() {
        val responseProbe = testKit.createTestProbe<HelloActorResponse>()
        val supervisor = testKit.spawn(SupervisorActor.create())

        // 존재하지 않는 자식 액터에게 메시지 전송
        supervisor.tell(SendHello("unknownChild", "Hello", responseProbe.ref()))

        // 응답이 없음을 확인
        responseProbe.expectNoMessage()

        // 자식 액터 수는 0이어야 함
        val countProbe = testKit.createTestProbe<Int>()
        supervisor.tell(GetChildCount(countProbe.ref()))
        countProbe.expectMessage(0)
    }

    @Test
    fun testSupervisorRestartsChildOnFailure() {
        val responseProbe = testKit.createTestProbe<HelloActorResponse>()
        val supervisor = testKit.spawn(SupervisorActor.create())

        // 자식 액터 생성 및 의도적인 예외 발생
        supervisor.tell(CreateChild("child2"))

        // 자식 액터에게 잘못된 메시지 전송하여 예외 유발
        supervisor.tell(SendHello("child2", "InvalidMessage", responseProbe.ref()))

        // 응답이 없음을 확인 (자식 액터가 예외로 인해 재시작됨)
        responseProbe.expectNoMessage()

        // 올바른 메시지 재전송
        supervisor.tell(SendHello("child2", "Hello", responseProbe.ref()))

        // 응답 확인 (자식 액터가 재시작되어 정상 동작함)
        responseProbe.expectMessage(HelloResponse("Kotlin"))
    }

    @Test
    fun testSupervisorDetectsChildTermination() {

        val supervisor = testKit.spawn(SupervisorActor.create())

        // 자식 액터 생성
        supervisor.tell(CreateChild("child4"))

        // 자식 액터 수 확인 (1이어야 함)
        val countProbe = testKit.createTestProbe<Int>()
        supervisor.tell(GetChildCount(countProbe.ref()))
        countProbe.expectMessage(1)

        // 자식 액터 종료 요청
        supervisor.tell(TerminateChild("child4"))

        // 잠시 대기하여 종료 처리를 기다림
        Thread.sleep(500)

        // 자식 액터 수 확인 (0이어야 함)
        supervisor.tell(GetChildCount(countProbe.ref()))
        countProbe.expectMessage(0)
    }

}