/src/Template/Cuts.elm at cdc8eb0afb1c54a534ab35084978fc59417f50b1

-- 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.Cuts exposing (cuts)

import Length exposing (Length, toMM)
import Parameters exposing (LoopStyle(..), Parameters, Profile(..))
import Parameters.Key exposing (Key(..))
import Svg exposing (..)
import Svg.Attributes exposing (..)
import Svg.Path as Path exposing (..)
import Template.Layout.Container as Container exposing (aligned, columns, gapped, noGrow, padded, rows, sized)
import Template.Layout.Coordinate exposing (Request(..))
import Template.Layout.Item exposing (Item)


highlightStroke : Bool -> Svg.Attribute msg
highlightStroke enabled =
    if enabled then
        class "highlight-stroke"

    else
        class "highlight-none"


cuts : Parameters -> Maybe Key -> Item msg
cuts params highlighting =
    -- TODO: Pack items more smartly, so it won't push infoArea out
    rows
        |> sized (AtLeast 0) (AtLeast 0)
        |> aligned Container.Start
        |> padded (toMM params.rendering.gap / 2)
        |> gapped (toMM params.rendering.gap)
        |> Container.build
            ([ columns
                |> gapped (toMM params.rendering.gap)
                |> Container.build
                    [ surfacePieces params highlighting |> noGrow ]
                |> Just
             , loops params highlighting
             ]
                |> List.filterMap identity
                |> List.map noGrow
            )


surfacePieces : Parameters -> Maybe Key -> Item msg
surfacePieces params highlighting =
    rows
        |> aligned Container.Center
        |> gapped (toMM params.rendering.gap / 2)
        |> Container.build
            [ Item
                { width = Exactly 50, height = Exactly 5 }
                (\p size ->
                    text_
                        [ x (String.fromFloat (p.x + size.width / 2))
                        , y (String.fromFloat p.y)
                        , fontSize "5"
                        , fontWeight "100"
                        , textAnchor "middle"
                        , dominantBaseline "hanging"
                        , fill "currentColor"
                        ]
                        [ text "Main pieces" ]
                )
            , columns
                |> gapped (toMM params.rendering.gap)
                |> Container.build
                    [ longPiece params highlighting, shortPiece params highlighting ]
            ]


guideStroke : List (Svg.Attribute msg)
guideStroke =
    [ fill "none"
    , stroke "currentColor"
    , strokeWidth "0.1"
    , strokeDasharray "0.5 1"
    ]


longPieceShape : ( Float, Float ) -> Parameters -> Maybe Key -> List Path.PathCommand -> Svg msg
longPieceShape ( x, y ) params highlighting commands =
    let
        lugWidth =
            toMM params.lugWidth

        length =
            toMM params.longPiece.length

        taperUntil =
            Basics.min
                (toMM params.longPiece.buckleHole.offset - toMM params.longPiece.buckleHole.interval)
                (length / 2)

        taper =
            case params.profile of
                Straight ->
                    0.0

                Tapered to ->
                    lugWidth - toMM to

        buckleWidth =
            lugWidth - taper
    in
    Svg.g
        []
        [ Svg.path
            [ Path.d
                (MoveTo Absolute ( x, y )
                    :: LineTo Relative ( taper / 2, taperUntil )
                    :: VerticalLineTo Relative (length - buckleWidth / 2 - taperUntil)
                    :: EllipticalArcCurve Relative
                        { rx = buckleWidth / 2
                        , ry = buckleWidth / 2
                        , angle = 0.0
                        , largeArcFlag = LargeArc
                        , sweepFlag = Counterclockwise
                        , x = buckleWidth
                        , y = 0
                        }
                        []
                    :: VerticalLineTo Relative -(length - buckleWidth / 2 - taperUntil)
                    :: LineTo Relative ( taper / 2, -taperUntil )
                    :: commands
                )
            , fill "none"
            , stroke "currentColor"
            , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
            , highlightStroke
                (highlighting
                    == Just LongPieceLength
                    || highlighting
                    == Just LugWidth
                    || highlighting
                    == Just Profile
                    || highlighting
                    == Just TaperTo
                    || (case params.profile of
                            Straight ->
                                False

                            Tapered _ ->
                                highlighting
                                    == Just BuckleHoleOffset
                                    || highlighting
                                    == Just BuckleHoleInterval
                       )
                )
            ]
            []
        , Svg.path
            (Path.d
                [ MoveTo Absolute ( x + lugWidth / 2, y )
                , VerticalLineTo Relative length
                ]
                :: highlightStroke (highlighting == Just LongPieceLength)
                :: guideStroke
            )
            []
        , case params.profile of
            Straight ->
                g [] []

            Tapered _ ->
                Svg.path
                    (Path.d
                        [ MoveTo Absolute ( x + taper / 2, y + taperUntil )
                        , HorizontalLineTo Relative buckleWidth
                        ]
                        :: highlightStroke
                            (highlighting
                                == Just LugWidth
                                || highlighting
                                == Just TaperTo
                                || highlighting
                                == Just BuckleHoleOffset
                                || highlighting
                                == Just BuckleHoleDiameter
                            )
                        :: guideStroke
                    )
                    []
        ]


longPiece : Parameters -> Maybe Key -> Item msg
longPiece params highlighting =
    let
        lugWidth =
            toMM params.lugWidth

        length =
            toMM params.longPiece.length
    in
    { size = { width = Exactly lugWidth, height = Exactly length }
    , element =
        \p _ ->
            g
                []
                (longPieceShape
                    ( p.x, p.y )
                    params
                    highlighting
                    [ ClosePath ]
                    :: (List.range 0 (params.longPiece.buckleHole.count - 1)
                            |> List.map
                                (\index ->
                                    let
                                        { buckleHole } =
                                            params.longPiece

                                        offset =
                                            toMM buckleHole.offset

                                        interval =
                                            toMM buckleHole.interval
                                    in
                                    hole
                                        params
                                        buckleHole.diameter
                                        ( p.x + lugWidth / 2
                                        , p.y + offset + interval * toFloat index
                                        )
                                        [ highlightStroke
                                            (highlighting
                                                == Just BuckleHoleDiameter
                                                || highlighting
                                                == Just BuckleHoleCount
                                                || highlighting
                                                == Just BuckleHoleInterval
                                                || highlighting
                                                == Just BuckleHoleOffset
                                            )
                                        ]
                                )
                       )
                )
    }


hole : Parameters -> Length -> ( Float, Float ) -> List (Svg.Attribute msg) -> Svg msg
hole params diameter ( cx, cy ) attrs =
    let
        radius =
            toMM diameter / 2
    in
    g
        []
        [ circle
            (Svg.Attributes.cx (String.fromFloat cx)
                :: Svg.Attributes.cy (String.fromFloat cy)
                :: r (String.fromFloat radius)
                :: fill "none"
                :: stroke "currentColor"
                :: strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                :: attrs
            )
            []
        , g
            [ fill "none"
            , stroke "currentColor"
            , strokeWidth "0.1"
            ]
            [ Svg.path
                [ Path.d
                    [ MoveTo Absolute ( cx - radius / 2, cy )
                    , HorizontalLineTo Relative radius
                    ]
                ]
                []
            , Svg.path
                [ Path.d
                    [ MoveTo Absolute ( cx, cy - radius / 2 )
                    , VerticalLineTo Relative radius
                    ]
                ]
                []
            ]
        ]


shortPieceShape : Parameters -> Maybe Key -> ( Float, Float ) -> Svg msg
shortPieceShape params highlighting at =
    let
        lugWidth =
            toMM params.lugWidth

        length =
            toMM params.shortPiece.length

        taperUntil =
            Basics.min
                (toMM params.longPiece.buckleHole.offset - toMM params.longPiece.buckleHole.interval)
                (length - 10)

        taper =
            case params.profile of
                Straight ->
                    0.0

                Tapered to ->
                    lugWidth - toMM to

        ( x, y ) =
            at
    in
    g
        []
        [ Svg.path
            [ Path.d
                ([ Just (MoveTo Absolute ( x, y ))
                 , Just (LineTo Relative ( taper / 2, taperUntil ))
                 , Just (VerticalLineTo Relative (length - taperUntil))
                 , Just (HorizontalLineTo Relative (lugWidth - taper))
                 , Just (VerticalLineTo Relative -(length - taperUntil))
                 , Just (LineTo Relative ( taper / 2, -taperUntil ))
                 , Just ClosePath
                 ]
                    |> List.filterMap identity
                )
            , fill "none"
            , stroke "currentColor"
            , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
            , highlightStroke
                (highlighting
                    == Just ShortPieceLength
                    || highlighting
                    == Just LugWidth
                    || highlighting
                    == Just Profile
                    || highlighting
                    == Just TaperTo
                    || (case params.profile of
                            Straight ->
                                False

                            Tapered _ ->
                                highlighting
                                    == Just BuckleHoleOffset
                                    || highlighting
                                    == Just BuckleHoleInterval
                       )
                )
            ]
            []
        , Svg.path
            (Path.d
                [ MoveTo Absolute ( x + lugWidth / 2, y )
                , VerticalLineTo Relative length
                ]
                :: highlightStroke (highlighting == Just ShortPieceLength)
                :: guideStroke
            )
            []
        , case params.profile of
            Straight ->
                g [] []

            Tapered _ ->
                Svg.path
                    (Path.d
                        [ MoveTo Absolute ( x + taper / 2, y + taperUntil )
                        , HorizontalLineTo Relative (lugWidth - taper)
                        ]
                        :: guideStroke
                    )
                    []
        ]


shortPiece : Parameters -> Maybe Key -> Item msg
shortPiece params highlighting =
    let
        lugWidth =
            toMM params.lugWidth

        length =
            toMM params.shortPiece.length
    in
    { size =
        { width = Exactly lugWidth, height = Exactly length }
    , element =
        \p _ ->
            g [] [ shortPieceShape params highlighting ( p.x, p.y ) ]
    }


loops : Parameters -> Maybe Key -> Maybe (Item msg)
loops params highlighting =
    let
        root =
            params.shortPiece.loops
    in
    case ( root.fixed, root.free ) of
        ( Nothing, Nothing ) ->
            Nothing

        _ ->
            rows
                |> aligned Container.Center
                |> gapped (toMM params.rendering.gap / 2)
                |> Container.build
                    [ Item
                        { width = Exactly 40, height = Exactly 5 }
                        (\p size ->
                            text_
                                [ x (String.fromFloat (p.x + size.width / 2))
                                , y (String.fromFloat p.y)
                                , fontSize "5"
                                , fontWeight "100"
                                , textAnchor "middle"
                                , dominantBaseline "hanging"
                                , fill "currentColor"
                                ]
                                [ text "Loops" ]
                        )
                    , columns
                        |> gapped (toMM params.rendering.gap)
                        |> aligned Container.Center
                        |> Container.build
                            ([ fixedLoop params highlighting
                             , freeLoop params highlighting
                             ]
                                |> List.filterMap identity
                            )
                    ]
                |> Just


fixedLoop : Parameters -> Maybe Key -> Maybe (Item msg)
fixedLoop params highlighting =
    Maybe.map
        (\{ width, length } ->
            { size =
                { width = Exactly (toMM length)
                , height =
                    Exactly
                        (case params.shortPiece.loops.style of
                            Simple ->
                                toMM width

                            Folded ->
                                toMM width * 2
                        )
                }
            , element =
                \p size ->
                    g
                        []
                        [ Svg.path
                            [ Path.d
                                [ MoveTo Absolute ( p.x, p.y )
                                , HorizontalLineTo Relative size.width
                                , VerticalLineTo Relative size.height
                                , HorizontalLineTo Relative -size.width
                                , ClosePath
                                ]
                            , fill "none"
                            , stroke "currentColor"
                            , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                            , highlightStroke (highlighting == Just FixedLoopWidth || highlighting == Just FixedLoopLength)
                            ]
                            []
                        , case params.shortPiece.loops.style of
                            Simple ->
                                g [] []

                            Folded ->
                                g
                                    [ fill "none"
                                    , stroke "currentColor"
                                    , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                                    , strokeDasharray "1 0.5"
                                    ]
                                    [ Svg.path
                                        [ Path.d
                                            [ MoveTo Absolute ( p.x, p.y + toMM width / 2 )
                                            , HorizontalLineTo Relative size.width
                                            ]
                                        ]
                                        []
                                    , Svg.path
                                        [ Path.d
                                            [ MoveTo Absolute ( p.x, p.y + toMM width * 1.5 )
                                            , HorizontalLineTo Relative size.width
                                            ]
                                        ]
                                        []
                                    ]
                        ]
            }
        )
        params.shortPiece.loops.fixed


freeLoop : Parameters -> Maybe Key -> Maybe (Item msg)
freeLoop params highlighting =
    Maybe.map
        (\{ width, length, overlap } ->
            { size =
                { width = Exactly (toMM length + toMM overlap)
                , height =
                    Exactly
                        (case params.shortPiece.loops.style of
                            Simple ->
                                toMM width

                            Folded ->
                                toMM width * 2
                        )
                }
            , element =
                \p size ->
                    g
                        []
                        [ Svg.path
                            [ Path.d
                                [ MoveTo Absolute ( p.x, p.y )
                                , HorizontalLineTo Relative size.width
                                , VerticalLineTo Relative size.height
                                , HorizontalLineTo Relative -size.width
                                , ClosePath
                                ]
                            , fill "none"
                            , stroke "currentColor"
                            , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                            , highlightStroke
                                (highlighting
                                    == Just FreeLoopWidth
                                    || highlighting
                                    == Just FreeLoopLength
                                    || highlighting
                                    == Just FreeLoopOverlap
                                )
                            ]
                            []
                        , g
                            [ fill "none"
                            , stroke "currentColor"
                            , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                            , strokeDasharray "1 0.5"
                            ]
                            [ Svg.path
                                [ Path.d
                                    [ MoveTo Absolute ( p.x + toMM overlap, p.y )
                                    , VerticalLineTo Relative size.height
                                    ]
                                ]
                                []
                            , Svg.path
                                [ Path.d
                                    [ MoveTo Absolute ( p.x + size.width - toMM overlap, p.y )
                                    , VerticalLineTo Relative size.height
                                    ]
                                ]
                                []
                            ]
                        , case params.shortPiece.loops.style of
                            Simple ->
                                g [] []

                            Folded ->
                                g
                                    [ fill "none"
                                    , stroke "currentColor"
                                    , strokeWidth (toMM params.rendering.lineWidth |> String.fromFloat)
                                    , strokeDasharray "1 0.5"
                                    ]
                                    [ Svg.path
                                        [ Path.d
                                            [ MoveTo Absolute ( p.x, p.y + toMM width / 2 )
                                            , HorizontalLineTo Relative size.width
                                            ]
                                        ]
                                        []
                                    , Svg.path
                                        [ Path.d
                                            [ MoveTo Absolute ( p.x, p.y + toMM width * 1.5 )
                                            , HorizontalLineTo Relative size.width
                                            ]
                                        ]
                                        []
                                    ]
                        ]
            }
        )
        params.shortPiece.loops.free