// ogólny interfejs polecenia
// związanie już w tym momencie z klasą Receiver pozwala w pewnym sensie grupować polecenia
// związane np. z edytorem tekstu, grafiki czy zapytaniami HTTP
// ale nie jest to wymagane przez sam wzorzec
abstract class Command(val receiver: Receiver) {
    abstract fun execute()
}
// konketne polecenie przyjmujące Receiver w konstruktorze
class ConcreteCommand(receiver: Receiver) : Command(receiver) {
    override fun execute() {
        println("executing ConcreteCommand")
        // wywołanie odpowiedniej akcji na odbiorcy
        receiver.action()
    }
}
// rzeczywisty "wykonawca" akcji, znający szczegóły implementacji
// np. edytor tekstu lub klient HTTP
class Receiver {
    fun action() {
        println("performing action in Receiver")
    }
}
// obiekt wykonujący polecenie, które jest ustawiane setterem
// np. przycisk wywołujący polecenie po kliknięciu
class Invoker {
    private lateinit var aCommand: Command

    fun setCommand(command: Command) {
        aCommand = command
    }

    fun performAction() {
        aCommand.execute()
    }
}
// klasa łącząca odbiorcę, polecenie i obiekt wywołujący polecenie
class Client(invoker: Invoker) {
    private val receiver = Receiver()

    init {
		// ustawienie polecenia dla Invokera
        val concreteCommand = ConcreteCommand(receiver)
        invoker.setCommand(concreteCommand)
    }
}

fun main() {
    val invoker = Invoker()
	
    Client(invoker)
    invoker.performAction()
}

// wynik polecenia
// `sealed` pasuje tutaj idealnie
sealed class CommandResult {
	// zwracane wartości mogą być `object` jeśli nie mają własnych parametrów jak np. powód błędu 
    class Success : CommandResult()
    class Fail : CommandResult()
}
// tym razem `interface` a nie `abstract class` bo nie mamy tutaj wymuszonego argumentu konstruktora
interface Command {
    fun execute(): CommandResult
}
// `receiver` pojawia się dopiero tutaj
class ConcreteCommand(private val receiver: Receiver) : Command {
	// wykonanie polecenia zwraca rezultat
    override fun execute(): CommandResult {
        println("executing ConcreteCommand")
		// w zależności od wyniku z `receivera`
        return if (receiver.action()) {
            CommandResult.Success()
        } else {
            CommandResult.Fail()
        }
    }
}
// `receiver` zwraca losowo True lub False
class Receiver {
    fun action(): Boolean {
        println("performing action in Receiver")
        return Random.nextBoolean()
    }
}

fun main() {
    val receiver = Receiver()
    // pominąłem `Invoker` w tym przykładzie, wywołanie polecenia mamy po prostu w main()
    val result = ConcreteCommand(receiver).execute()
    println("Command result is: $result")
}

// pomocna funkcja do losowego opóźnienia
fun randomDelay() = Random.nextLong(1000, 3000)

interface Command {
	// Receiver jest przekazywany dopiero w momencie wykonania polecenia
    suspend fun execute(receiver: Receiver)
}
// polecenia przyjmują tylko własne parametry, bez Receivera
class FirstCommand(private val param: Int) : Command {
    override suspend fun execute(receiver: Receiver) {
        println("executing FirstCommand $param")
        receiver.action()
    }
}

class SecondCommand(private val param: String) : Command {
    override suspend fun execute(receiver: Receiver) {
        println("executing SecondCommand $param")
        receiver.action()
    }
}

class Receiver {
	// wykonanie akcji Receivera może chwilę zająć, stąd `suspend` i `delay()`
    suspend fun action() {
        println("performing action in Receiver")
        delay(randomDelay())
        println("action finished!")
    }
}
// najważniejsza klasa w tym przykładzie
// zawiera obiekt Receivera używany przy wykonaniu poleceń
// same polecenia są odkładane na kolejkę FIFO w postaci `Channel`
object CommandProcessor {
    private val commands = Channel<Command>()
	// użycie osobnych Scope na dodawanie i wykonywanie poleceń powoduje brak blokowania
    private val processScope = CoroutineScope(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
    private val executeScope = CoroutineScope(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
    private val receiver = Receiver()

    fun process(command: Command) {
        processScope.launch {
			// dodanie opóźnienia nie powoduje blokowania dodawania kolejnych poleceń
            delay(randomDelay())
            println("adding $command to the queue")
            commands.send(command)
        }
    }

    init {
		// nasłuchiwanie na nowe polecenia w kolejce i wykonywanie ich jak tylko się pojawią
        executeScope.launch {
            for (command in commands) {
                command.execute(receiver)
            }
        }
    }
}
// Invoker bez zmian
class Invoker {
    private lateinit var aCommand: Command

    fun setCommand(command: Command) {
        aCommand = command
    }

    fun performAction() {
        CommandProcessor.process(aCommand)
    }
}

fun main() {
    val firstInvoker = Invoker()
    val secondInvoker = Invoker()

	// polecenia przyjmują tylko własne parametry, bez Receivera
    firstInvoker.setCommand(FirstCommand(1))
    secondInvoker.setCommand(SecondCommand("2"))

	// wykonanie poleceń po 10x
    repeat(10) {
        firstInvoker.performAction()
        secondInvoker.performAction()
    }
}

// najprawdopodobniej byłby dostarczany przez DI, ale na potrzeby przykładu `object` wystarczy
object CommandProcessor {
	// tutaj wszystko bez zmian
    private val commands = Channel<Command>()
    private val processScope = CoroutineScope(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
    private val executeScope = CoroutineScope(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
    private val receiver = Receiver()

    fun process(command: Command) {
        processScope.launch {
            delay(randomDelay())
            println("adding $command to the queue")
            commands.send(command)
        }
    }

    init {
        executeScope.launch {
			// uruchamiamy 5 wewnętrznych procesorów operujących na tej samej kolejce
            // jednocześnie może być wykonywanych 5 poleceń, tyle ile wewnętrznych processorów
            repeat(5) {
                launchProcessor(commands)
            }
        }
    }
	// prywatna `extension function` pozwalająca wielu konsumentom ściągać polecenia z kolejki
	// polecenia są wykonywane tylko raz
	// po zakończeniu wykonania polecenia, wew. procesor ściąga z kolejki następne
    private fun CoroutineScope.launchProcessor(channel: ReceiveChannel<Command>) = launch {
        for (command in channel) {
            command.execute(receiver)
        }
    }
}

// generyczne polecenie rysowania "czegoś" na obiekcie `Canvas`
abstract class DrawCommand(private val canvas: Canvas) {
	// stan sprzed wykonania polecenia - lista już narysowanych elementów
    private var preCommandState = listOf<Shape>()

    abstract fun execute()
    // zachowanie stanu
    fun saveState() {
        preCommandState = canvas.shapes.toList()
    }

	// cofnięcie polecenia, czyli przywrócenie stanu sprzed jego wykonania
    fun undo() {
        println("undo ${this}")
        canvas.shapes = preCommandState.toMutableList()
    }
}
// interfejs i klasy kształtów
interface Shape
data class Line(val length: Int) : Shape
data class Circle(val diameter: Int) : Shape
// polecenia rysujące kształty
class DrawLine(private val length: Int, private val canvas: Canvas) : DrawCommand(canvas) {
    override fun execute() {
        saveState()
        canvas.draw(Line(length))
    }
}
class DrawCircle(private val diameter: Int, private val canvas: Canvas) : DrawCommand(canvas) {
    override fun execute() {
        saveState()
        canvas.draw(Circle(diameter))
    }
}

// Receiver
class Canvas {
	// stan rysunku
    var shapes: MutableList<Shape> = mutableListOf()
	// rysowanie elementu polega na dodaniu go do listy narysowanych
    fun draw(shape: Shape) {
        println("drawing a $shape")
        shapes.add(shape)
    }
}

fun main() {
    val canvas = Canvas()
    val commandsHistory = mutableListOf<DrawCommand>()

	// po wykonaniu polecenia jest ono dodawane do historii
    val drawLine = DrawLine(2, canvas)
    drawLine.execute()
    commandsHistory.add(drawLine)

    val drawCircle = DrawCircle(1, canvas)
    drawCircle.execute()
    commandsHistory.add(drawCircle)

    val drawLongLine = DrawLine(10, canvas)
    drawLongLine.execute()
    commandsHistory.add(drawLongLine)

    val drawBigCircle = DrawCircle(12, canvas)
    drawBigCircle.execute()
    commandsHistory.add(drawBigCircle)

    println("current shapes: ${canvas.shapes}")
    println("--- undo last 2 ---")
	// cofnięcie 2 ostatnich poleceń
    commandsHistory.removeLast().undo()
    commandsHistory.removeLast().undo()
    println("current shapes: ${canvas.shapes}")
}

fun main() {
	// polecenie przyjmuje Receiver w momencie wykonania
    val command = { receiver: Receiver ->
        println("this is a command to do stuff")
        receiver.action()
    }
    repeat(10) {
        CommandProcessor.process(command)
		
		// polecenia nie muszą być przypisane do konkretnych zmiennych
        CommandProcessor.process { receiver: Receiver ->
            println("this is a another command")
            receiver.action()
        }
    }
}

// Invoker, przujmuje polecenia w konstruktorze, ale mógłby też mieć settery
class RemoteController(
    private val firstButtonAction: Command,
    private val secondButtonAction: Command,
) {
    fun firstButton() {
        firstButtonAction.execute()
    }

    fun secondButton() {
        secondButtonAction.execute()
    }
}

interface Command {
    fun execute()
}

// Receiver
class Device(private val name: String) {
    // action
    fun switch(on: Boolean) {
        println("turning device $name ${if (on) "ON" else "OFF"}")
    }
}
// polecenie przyjmuje Receiver w konstruktorze
class TurnOnCommand(private val device: Device) : Command {
    override fun execute() {
		// i wywołuje na nim akcję zgodną ze swoim przeznaczeniem
        device.switch(true)
    }
}

class TurnOffCommand(private val device: Device) : Command {
    override fun execute() {
        device.switch(false)
    }
}

fun main() {

    // instancja Receivera
    val lightBulb = Device("living room light")

    // przekazana do poleceń
    val turnOn: Command = TurnOnCommand(lightBulb)
    val turnOff: Command = TurnOffCommand(lightBulb)

    // invoker (pilot) otrzymuje polecenia pod konkretne przyciski
    val remote = RemoteController(turnOn, turnOff)

    // ale sam invoker tylko wywołuje polecenia, nie wie co dokładnie się dzieje i z jakim urządzeniem
    remote.firstButton()

    remote.secondButton()
}