// Podstawowe użycie Factory Method
val creator: Creator = ConcreteCreator()
val concreteProduct: Product = creator.factoryMethod()
concreteProduct.doStuff()

// nadal można utworzyć instancję ConcreteProduct przez konstruktor
val concreteProduct2 = ConcreteProduct()

interface Product {
    fun doStuff()
}
// "konkretny" produkt implementujący interface
internal class ConcreteProduct : Product {
    override fun doStuff() {
        println("ConcreteProduct is doing stuff")
    }
}

interface Creator {
    // metoda fabryczna dostarczająca instancję obiektu implementującego interface `Product`
    fun factoryMethod() : Product
}

// "konkretna" implementacja fabryki, wytwarzająca `ConcreteProduct`
class ConcreteCreator: Creator {
    // zwracany typ musi być ogólny, 
    // zwracanie `ConcreteProduct` który jest internal powoduje błąd kompilacji
    override fun factoryMethod() : Product {
        println("ConcreteCreator is using factory method")
        return ConcreteProduct()
    }
}

// utworzenie instancji przez konstruktor
val square = Square()
// użycie manipulatora dla kwadratu, ale przez generyczny interface
square.createManipulator().drag()

val figureFactory: FigureFactory = ByTypeFactory()
// stworzenie koła przez fabrykę przyjmującą `enum` z oczekiwanym rodzajem figury
val circle: Figure = figureFactory.createFigure(FigureFactory.Type.Circle)
// analogiczna modyfikacja figury
circle.createManipulator().drag()

interface Figure {
    // Figure potrafi stworzyć dla siebie FigureManipulator, 
    // ale dla klienta jest on generyczny a nie konkretny.
    fun createManipulator(): FigureManipulator<out Figure> // metoda wytwórcza
}

// `internal` oznacza że klasa nie jest dostępna poza modułem, 
// jest dostępna tylko dla klas z którymi jest kompilowana.
// Jest to przydatne podczas tworzenia bibliotek kiedy nie chcemy wyciekać konkretnych typów
internal class Circle: Figure {
    // w razie czego manipulator może zostać zastąpiony innym, bez konieczności aktualizacji klienta
    override fun createManipulator() = CircleManipulator(this)
}

internal class Square : Figure {
    override fun createManipulator() = SquareManipulator(this)
}

internal class Line : Figure {
    override fun createManipulator() = LineManipulator(this)
}

// wykorzystanie generyków zapewnia, że konkretny FigureManipulator będzie umiał obsłużyć 
// tylko konkretny typ figury np. CircleManipulator nie przyjmie argumentu typu Square
interface FigureManipulator<T : Figure> {
    fun drag()
    fun resize(scale: Float)
}

// typ argumentu w konstruktorze musi zgadzać się z zadeklarowanym przez FigureManipulator
internal class CircleManipulator<T>(private val figure: T) : FigureManipulator<Circle> {
    override fun drag() = println("CircleManipulator is manipulating circle $figure")
    override fun resize(scale: Float) = println("CircleManipulator is resizing circle $figure")
}
internal class SquareManipulator<T>(private val figure: T) : FigureManipulator<Square> {...}
internal class LineManipulator<T>(private val figure: T) : FigureManipulator<Line> {...}

interface FigureFactory {
    // umieszczenie enuma wewnątrz klasy Factory zamiast Figure,
    // to fabryka zna typy produkowanych przez siebie obiektów, 
    // a nie sam obiekt wie w jakich formach występuje
    enum class Type { Circle, Square, Line, Undefined }

    fun createFigure(type: Type): Figure
}

// Częste wykorzystanie factory do zwracania obiektu danego typu z wykorzystaniem enuma
class ByTypeFactory : FigureFactory {
    override fun createFigure(type: FigureFactory.Type): Figure =
        when (type) { // wystąpi błąd kompilacji jeśli nie obsłużymy wszystkich typów
            FigureFactory.Type.Circle -> Circle()
            FigureFactory.Type.Square -> Square()
            FigureFactory.Type.Line -> Line()
            // typ Undefined nie jest obsłużony, ale wpadnie w `else`
            else -> throw Exception("unknown figure, don't know how to create it")
        }
}

// fabryka może dostarczać obiekty anonimowe, dla klienta to bez znaczenia
class UndefinedFigureFactory : FigureFactory {
    // niezależnie od parametru `type` zwrócony będzie taki sam obiekt
    override fun createFigure(type: FigureFactory.Type) = object: Figure {
        // z takim samym manipulatorem
        override fun createManipulator() = object: FigureManipulator<Figure> {
            override fun drag() = println("UndefinedFigure dragging")
            override fun resize(scale: Float) = println("UndefinedFigure resizing")
        }
    }
}

// użycie
UndefinedFigureFactory()
        .createFigure(FigureFactory.Type.Circle) // w tym przypadku typ nie ma znaczenia
        .createManipulator() // ale API obiektu jest takie samo
        .drag()

// w testach czasami przydaje się zastąpienie prawdziwego factory jakąś zaślepką
class FakeFactory : FigureFactory {
    override fun createFigure(type: FigureFactory.Type): Figure {
        return FakeFigure()
    }
}
// dla klienta to nadal bez znaczenia jaki dostaje obiekt, tak długo jak implementuje `Figure`
class FakeFigure : Figure {
    override fun createManipulator(): FigureManipulator<out Figure> {
        return FakeFigureManipulator()
    }
}

class FakeFigureManipulator : FigureManipulator<FakeFigure> {
    override fun drag() = println("FakeFigure dragging")
    override fun resize(scale: Float) = println("FakeFigure resizing")
}

// użycie
val figure = FakeFactory()
                .createFigure(FigureFactory.Type.Circle) // to raczej nie będzie kółko...
figure.createManipulator().drag() // ale działa jak kółko :)

// losowo zwraca ByTypeFactory lub FakeFactory, 
// dla klienta to bez różnicy bo i tak zna tylko interface FigureFactory
object RandomFigureFactory {
    fun getFigureFactory(): FigureFactory = if (Random.nextBoolean()) ByTypeFactory() else FakeFactory()
}

// użycie
RandomFigureFactory.getFigureFactory() // losowo wybrane FigureFactory, albo Fake albo ByType
        .createFigure(FigureFactory.Type.Circle)
        // nie mamy pewności jaki obiekt dostaniemy, ale zawsze będzie to Figure
        .createManipulator().drag() // więc można ten obiekt zmieniać zgodnie z jego API

// różne konfiguracje baz danych
val mySqlConfig = MySqlConfig("dbAddress", "port")
val realmConfig = RealmConfig // object czyli Singleton nie ma konstruktora
val mongoDbConfig = MongoDbConfig("fileUri", "table")

// nie wiemy jaką instancję bazy dostaniemy z fabryki
val db: Database = DatabaseFactory.getDatabaseForConfig(mySqlConfig)
// znamy tylko generyczny interfejs
db.save("Save me!")

// wspólny interface bazy udostępniany klientowi
interface Database {
    fun save(item: Any)
    fun getItem(id: Int)
}

// konkretna implementacja bazy przyjmująca konfigurację w konstruktorze
internal class MySql(val config: MySqlConfig) : Database {
    override fun save(item: Any) = println("saving $item in MySQL")
    override fun getItem(id: Int) = println("getting item at $id from MySQL")
}
internal class Realm(val config: RealmConfig) : Database {...}
internal class MongoDB(val config: MongoDbConfig) : Database {...}

sealed class DatabaseConfig

// od Kotlin 1.1 można używać `data class` i tworzyć je poza `sealed` klasą, 
// ale tylko w tym samym pliku
data class MySqlConfig(val address: String, val port: String) : DatabaseConfig()
object RealmConfig : DatabaseConfig() // z klasy `sealed` często dziedziczą Singletony

// po tej klasie `open` można dziedziczyć również poza plikiem z klasą `sealed`
open class MongoDbConfig(val fileUri: String, val tableName: String) : DatabaseConfig()

// Fabryka dostarczająca implementację Database pod konkretną konfigurację
object DatabaseFactory {
    // metoda przyjmuje generyczny interface i zwraca generyczną instancję Database
    fun getDatabaseForConfig(config: DatabaseConfig): Database {
        // when w połączeniu z sealed class daje pewność obsłużenia wszystkich przypadków,
        // lub błąd kompilacji
        return when (config) {
            is MongoDbConfig -> MongoDB(config)
            is MySqlConfig -> MySql(config)
            is RealmConfig -> Realm(config)
            
            // `BadConfig` rozszerza `MongoDbConfig` ale brak tego przypadku nie spowoduje błędu, 
            // bo `BadConfig` jest `MongoDbConfig`, więc ten przypadek zostanie obsłużony
            is BadConfig -> MongoDB(config) 
        }
    }
}

// błąd, nie można rozszerzać klasy sealed poza plikiem gdzie się znajduje
data class BadConfig(val badData: String): DatabaseConfig()
// klasa MongoDbConfig jest open, więc można z niej dziedziczyć
data class BadConfig(val badData: String): MongoDbConfig("", "")

// AirFilter ma companion object z metodą `create()` czyli Static Factory Method
val airFilter: Part = AirFilter.create()
val fuelFilter: Part = FuelFilter.create()
val fuelFilter: Part = FuelFilter() // błąd, prywatny konstruktor na to nie pozwala

// rejestrowanie factory, nazwa klasy wskazuje na companion object
RandomPartCreator.registerFactory(AirFilter)
RandomPartCreator.registerFactory(FuelFilter)
RandomPartCreator.registerFactory(OilFilter)
// zarejestrować można też fabrykę nie będącą companion object
RandomPartCreator.registerFactory(EngineFactory())

// tworzymy 10 instancji
repeat(10) {
    // losowe tworzenie instancji, nie znamy tutaj konkretnego typu
    val randomPart = RandomPartCreator.createRandomPart()
    println(randomPart.description())
    // no chyba że sprawdzimy
    println("is it an AirFilter? ${randomPart is AirFilter}")
}

// interface implementowany przez każdą część dostarczaną przez nadrzędną Fabrykę
interface Part {
    fun description(): String
}

// interface dla companion object, dostarczający konkretny typ części rozszerzający `Part`
interface PartFactory<T : Part> {
    fun create(): T
}

// implementacja konkretnej części z prywatnym konstruktorem
internal class FuelFilter private constructor() : Part {
    // companion object implementujący interface
    companion object Factory : PartFactory<FuelFilter> {
        // Static Factory Method dostarczająca instancję zgodną z zadeklarowanym typem
        override fun create(): FuelFilter = FuelFilter()
    }
    override fun description() = "I'm a Fuel Filter"
}
internal class AirFilter private constructor() : Part {...}
internal class OilFilter private constructor() : Part {...}

// klasa bez companion object nadal może być użyta
class Engine: Part {
    override fun description() = "I'm an Engine!"
}
// fabryka poza obiektem
class EngineFactory : PartFactory<Engine>{
    override fun create(): Engine {
        // klasa Engine nie może mieć jednak prywatnego konstruktora
        return Engine()
    }
}
object RandomPartCreator {
    // rejestr wewnętrznych fabryk, czyli Static Factory Method
    // Set zapewnia brak duplikatów
    // typ tworzony przez PartFactory musi rozszerzać `Part`
    private val partFactories = mutableSetOf<PartFactory<out Part>>()

    // dodanie nowej fabryki do rejestru
    fun registerFactory(factory: PartFactory<out Part>) {
        partFactories.add(factory)
    }

    fun createRandomPart(): Part { // tzw. generator - tworzy instancję bez podawania parametrów
        // losowa liczba z zakresu ograniczonego rozmiarem rejestru
        val randomFactory = Random.nextInt(partFactories.size)
        // wywołanie metody `create()` na wylosowanej fabryce
        // niestety nie da się wyciągnąć n-tego elementu z Set-u bez zmiany typu na listę
        return partFactories.toList()[randomFactory].create()
    }
}