package net.granseal.koLambda

import java.awt.Graphics2D
import java.awt.geom.AffineTransform
import java.awt.geom.Point2D

open class Entity(var pos: Point2D.Float = Point2D.Float()) {
    var parent: Entity? = null
    val props = mutableMapOf<String,Any>()
    val children = mutableListOf<Entity>()
    val updaters = mutableListOf<Entity.(Float) -> Unit>()
    val drawers = mutableListOf<Entity.(Graphics2D) -> Unit>()
    var scale = 1.0
    var rotation = 0.0
    var transform = AffineTransform()

    fun getLocalTransform(): AffineTransform {
        transform.setToIdentity()
        transform.translate(pos.x.toDouble(), pos.y.toDouble())
        transform.rotate(rotation)
        transform.scale(scale, scale)
        return transform
    }

    fun getWorldTransform(): AffineTransform {
        return if (parent == null) {
            getLocalTransform()
        } else {
            val trans = parent!!.getWorldTransform()
            trans.concatenate(getLocalTransform())
            trans
        }
    }

    fun update(delta: Float) {
        updaters.forEach { it(delta) }
        children.forEach { it.update(delta) }
    }

    fun draw(g: Graphics2D) {
        val saved = g.transform
        g.transform = getWorldTransform()
        drawers.forEach { it(g) }
        children.forEach { it.draw(g) }
        g.transform = saved
    }

    fun add(e: Entity): Entity {
        e.parent = this
        children.add(e)
        return e
    }

    fun add(e: Entity.() -> Unit) = add(Entity().apply(e))

    fun getAll(): List<Entity> {
        val entities = mutableListOf<Entity>()
        entities.add(this)
        children.forEach {
            entities.addAll(it.getAll())
        }
        return entities
    }
}