/src/Template/Layout/Container.elm at trunk

-- Copyright 2026 Shota FUJI
--
-- This Source Code Form is subject to the terms of the Mozilla Public
-- License, v. 2.0. If a copy of the MPL was not distributed with this
-- file, You can obtain one at https://mozilla.org/MPL/2.0/.
--
-- SPDX-License-Identifier: MPL-2.0


module Template.Layout.Container exposing
    ( Container
    , ContainerChildAlignment(..)
    , ContainerDirection(..)
    , ContainerSizing(..)
    , aligned
    , build
    , columns
    , debugOutline
    , gapped
    , noGrow
    , padded
    , rows
    , sized
    , withContentOutline
    , withElement
    , withOutline
    )

import Html.Attributes exposing (align)
import Svg exposing (..)
import Svg.Attributes as Attrs
import Template.Layout.Coordinate exposing (..)
import Template.Layout.Item exposing (Item)


isHorizontallyGrowable : Item msg -> Bool
isHorizontallyGrowable item =
    case item.size.width of
        AtLeast _ ->
            True

        _ ->
            False


isVerticallyGrowable : Item msg -> Bool
isVerticallyGrowable item =
    case item.size.height of
        AtLeast _ ->
            True

        _ ->
            False


type ContainerChildAlignment
    = Stretch
    | Start
    | Center
    | End


type ContainerSizing
    = Intrinsic
    | Sized (Request Float) (Request Float)


type alias ContainerRenderingContext =
    { containerOrigin : Point2D
    , containerSize : Size
    , renderingAreaOrigin : Point2D
    , renderingAreaSize : Size
    }


type ContainerDirection
    = Row
    | Column


type alias Container msg =
    { size : ContainerSizing
    , gap : Float
    , padding : Float
    , align : ContainerChildAlignment
    , elements : List (ContainerRenderingContext -> Svg msg)
    , direction : ContainerDirection
    }


rows : Container msg
rows =
    { size = Intrinsic
    , gap = 0
    , padding = 0
    , align = Stretch
    , elements = []
    , direction = Row
    }


columns : Container msg
columns =
    { size = Intrinsic
    , gap = 0
    , padding = 0
    , align = Stretch
    , elements = []
    , direction = Column
    }


sized : Request Float -> Request Float -> Container msg -> Container msg
sized width height props =
    { props | size = Sized width height }


gapped : Float -> Container msg -> Container msg
gapped gap props =
    { props | gap = gap }


padded : Float -> Container msg -> Container msg
padded padding props =
    { props | padding = padding }


aligned : ContainerChildAlignment -> Container msg -> Container msg
aligned align props =
    { props | align = align }


withElement : (ContainerRenderingContext -> Svg msg) -> Container msg -> Container msg
withElement f props =
    { props | elements = f :: props.elements }


type alias Outline =
    { color : String
    , width : Float
    , radius : Float
    }


debugOutline : Outline
debugOutline =
    { color = "#f00"
    , width = 0.1
    , radius = 0.0
    }


withOutline : Outline -> Container msg -> Container msg
withOutline { color, width, radius } props =
    { props
        | elements =
            (\ctx ->
                g
                    []
                    [ rect
                        [ Attrs.x (String.fromFloat ctx.containerOrigin.x)
                        , Attrs.y (String.fromFloat ctx.containerOrigin.y)
                        , Attrs.width (String.fromFloat ctx.containerSize.width)
                        , Attrs.height (String.fromFloat ctx.containerSize.height)
                        , Attrs.fill "none"
                        , Attrs.stroke color
                        , Attrs.strokeWidth (String.fromFloat width)
                        , Attrs.rx (String.fromFloat radius)
                        , Attrs.ry (String.fromFloat radius)
                        ]
                        []
                    ]
            )
                :: props.elements
    }


withContentOutline : Outline -> Container msg -> Container msg
withContentOutline { color, width, radius } props =
    { props
        | elements =
            (\ctx ->
                g
                    []
                    [ rect
                        [ Attrs.x (String.fromFloat ctx.renderingAreaOrigin.x)
                        , Attrs.y (String.fromFloat ctx.renderingAreaOrigin.y)
                        , Attrs.width (String.fromFloat ctx.renderingAreaSize.width)
                        , Attrs.height (String.fromFloat ctx.renderingAreaSize.height)
                        , Attrs.fill "none"
                        , Attrs.stroke color
                        , Attrs.strokeWidth (String.fromFloat width)
                        , Attrs.rx (String.fromFloat radius)
                        , Attrs.ry (String.fromFloat radius)
                        ]
                        []
                    ]
            )
                :: props.elements
    }


noGrow : Item msg -> Item msg
noGrow item =
    { item
        | size =
            { width =
                case item.size.width of
                    AtLeast n ->
                        Exactly n

                    Exactly n ->
                        Exactly n
            , height =
                case item.size.height of
                    AtLeast n ->
                        Exactly n

                    Exactly n ->
                        Exactly n
            }
    }


build : List (Item msg) -> Container msg -> Item msg
build items { size, gap, padding, align, elements, direction } =
    let
        getCtx : Point2D -> Size -> ContainerRenderingContext
        getCtx p s =
            { containerOrigin = p
            , containerSize = s
            , renderingAreaOrigin =
                { x = p.x + padding
                , y = p.y + padding
                }
            , renderingAreaSize =
                { width = s.width - padding * 2
                , height = s.height - padding * 2
                }
            }
    in
    case items of
        [] ->
            { size = SizeRequest (Exactly 0) (Exactly 0)
            , element =
                \p s ->
                    let
                        ctx =
                            getCtx p s
                    in
                    g [] (List.map (\e -> e ctx) elements)
            }

        _ ->
            let
                ( innerMinWidth, innerMinHeight ) =
                    case direction of
                        Row ->
                            ( items
                                |> List.map (\item -> minSizeOf item.size |> .width)
                                |> List.maximum
                                |> Maybe.withDefault 0.0
                            , items
                                |> List.map (\item -> minSizeOf item.size |> .height)
                                |> List.intersperse gap
                                |> List.foldl (+) 0.0
                            )

                        Column ->
                            ( items
                                |> List.map (\item -> minSizeOf item.size |> .width)
                                |> List.intersperse gap
                                |> List.foldl (+) 0.0
                            , items
                                |> List.map (\item -> minSizeOf item.size |> .height)
                                |> List.maximum
                                |> Maybe.withDefault 0.0
                            )
            in
            { size =
                case size of
                    Intrinsic ->
                        case direction of
                            Row ->
                                { width = AtLeast (innerMinWidth + padding * 2)
                                , height = Exactly (innerMinHeight + padding * 2)
                                }

                            Column ->
                                { width = Exactly (innerMinWidth + padding * 2)
                                , height = AtLeast (innerMinHeight + padding * 2)
                                }

                    Sized w h ->
                        { width =
                            case w of
                                Exactly v ->
                                    Exactly v

                                AtLeast v ->
                                    AtLeast (max v (innerMinWidth + padding * 2))
                        , height =
                            case h of
                                Exactly v ->
                                    Exactly v

                                AtLeast v ->
                                    AtLeast (max v (innerMinHeight + padding * 2))
                        }
            , element =
                \p s ->
                    let
                        ctx =
                            getCtx p s

                        children =
                            case direction of
                                Row ->
                                    let
                                        freeHeight =
                                            max 0 (ctx.renderingAreaSize.height - innerMinHeight)

                                        grow =
                                            freeHeight / (items |> List.filter isVerticallyGrowable |> List.length |> toFloat)
                                    in
                                    items
                                        |> List.foldl
                                            (\item ( yOffset, els ) ->
                                                let
                                                    height =
                                                        case item.size.height of
                                                            Exactly h ->
                                                                h

                                                            AtLeast h ->
                                                                h + grow

                                                    width =
                                                        case align of
                                                            Stretch ->
                                                                ctx.renderingAreaSize.width

                                                            _ ->
                                                                case item.size.width of
                                                                    Exactly w ->
                                                                        min w ctx.renderingAreaSize.width

                                                                    AtLeast _ ->
                                                                        ctx.renderingAreaSize.width

                                                    ( y, yAdvance ) =
                                                        case els of
                                                            [] ->
                                                                ( yOffset, yOffset + height )

                                                            _ ->
                                                                ( yOffset + gap, yOffset + gap + height )

                                                    x =
                                                        case align of
                                                            Center ->
                                                                ctx.renderingAreaOrigin.x + (ctx.renderingAreaSize.width / 2 - width / 2)

                                                            End ->
                                                                ctx.renderingAreaOrigin.x + (ctx.renderingAreaSize.width - width)

                                                            _ ->
                                                                ctx.renderingAreaOrigin.x
                                                in
                                                ( yAdvance
                                                , item.element (Point2D x y) (Size width height) :: els
                                                )
                                            )
                                            ( ctx.renderingAreaOrigin.y, [] )
                                        |> Tuple.second

                                Column ->
                                    let
                                        freeWidth =
                                            max 0 (ctx.renderingAreaSize.width - innerMinWidth)

                                        grow =
                                            freeWidth / (items |> List.filter isHorizontallyGrowable |> List.length |> toFloat)
                                    in
                                    items
                                        |> List.foldl
                                            (\item ( xOffset, els ) ->
                                                let
                                                    width =
                                                        case item.size.width of
                                                            Exactly w ->
                                                                w

                                                            AtLeast w ->
                                                                w + grow

                                                    height =
                                                        case align of
                                                            Stretch ->
                                                                ctx.renderingAreaSize.height

                                                            _ ->
                                                                case item.size.height of
                                                                    Exactly h ->
                                                                        min h ctx.renderingAreaSize.height

                                                                    AtLeast _ ->
                                                                        ctx.renderingAreaSize.height

                                                    ( x, xAdvance ) =
                                                        case els of
                                                            [] ->
                                                                ( xOffset, xOffset + width )

                                                            _ ->
                                                                ( xOffset + gap, xOffset + gap + width )

                                                    y =
                                                        case align of
                                                            Center ->
                                                                ctx.renderingAreaOrigin.y + (ctx.renderingAreaSize.height / 2 - height / 2)

                                                            End ->
                                                                ctx.renderingAreaOrigin.y + (ctx.renderingAreaSize.height - height)

                                                            _ ->
                                                                ctx.renderingAreaOrigin.y
                                                in
                                                ( xAdvance
                                                , item.element (Point2D x y) (Size width height) :: els
                                                )
                                            )
                                            ( ctx.renderingAreaOrigin.x, [] )
                                        |> Tuple.second
                    in
                    g [] (children ++ List.map (\e -> e ctx) elements)
            }