/src/Parameters.elm at df67c33f096d05768a5769e2554ca9844c845d84

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

import Dict exposing (Dict)
import Length exposing (Length, mm, toMM)
import Parameters.Key as Key exposing (Key(..))


type TipShape
    = Round


type alias BuckleHole =
    -- Offset from the case side (lug side.)
    { offset : Length

    -- Number of buckle holes, can be 0.
    , count : Int

    -- Center-to-center.
    , interval : Length

    -- TODO: Support non circular holes.
    , diameter : Length
    }


{-| Parameters for the long piece, which has buckle holes.
This does not have to be longer than `ShortPiece`.
-}
type alias LongPiece =
    { length : Length
    , tip : TipShape
    , buckleHole : BuckleHole
    }


type alias FixedLoop =
    { width : Length
    , length : Length
    }


type alias FreeLoop =
    { width : Length
    , length : Length
    , overlap : Length
    }


type LoopStyle
    = Simple
    | Folded


loopStyleToString : LoopStyle -> String
loopStyleToString style =
    case style of
        Simple ->
            "simple"

        Folded ->
            "folded"


type alias Loops =
    { fixed : Maybe FixedLoop
    , free : Maybe FreeLoop
    , style : LoopStyle
    }


{-| Parameters for the short piece, which has clasp at the end.
This does not have to be shorter than `LongPiece`.
-}
type alias ShortPiece =
    { length : Length
    , loops : Loops
    }


type CanvasSize
    = A4


canvasSizeDimension : CanvasSize -> ( Length, Length )
canvasSizeDimension size =
    case size of
        A4 ->
            ( mm 210, mm 297 )


type ColorSchema
    = BlackOnWhite
    | WhiteOnBlack


colorSchemaToString : ColorSchema -> String
colorSchemaToString schema =
    case schema of
        BlackOnWhite ->
            "black-on-white"

        WhiteOnBlack ->
            "white-on-black"


type alias Rendering =
    { size : CanvasSize
    , margin : Length
    , gap : Length
    , lineWidth : Length
    , colorSchema : ColorSchema
    , qrCode : Bool
    }


type Profile
    = Straight
    | Tapered Length


profileKind : Profile -> String
profileKind profile =
    case profile of
        Straight ->
            "straight"

        Tapered _ ->
            "tapered"


type alias Parameters =
    { shoulderWidth : Length
    , longPiece : LongPiece
    , shortPiece : ShortPiece
    , profile : Profile
    , rendering : Rendering
    }


defaultFixedLoop : FixedLoop
defaultFixedLoop =
    { length = mm 55
    , width = mm 6
    }


defaultFreeLoop : FreeLoop
defaultFreeLoop =
    { width = mm 5
    , length = mm 55
    , overlap = mm 5
    }


default : Parameters
default =
    { shoulderWidth = mm 20
    , longPiece =
        { length = mm 112
        , tip = Round
        , buckleHole =
            { offset = mm 50
            , count = 7
            , interval = mm 6
            , diameter = mm 2
            }
        }
    , shortPiece =
        { length = mm 80
        , loops =
            { fixed = Just defaultFixedLoop
            , free = Just defaultFreeLoop
            , style = Simple
            }
        }
    , profile = Straight
    , rendering =
        { size = A4
        , margin = mm 3
        , gap = mm 10
        , lineWidth = mm 0.2
        , colorSchema = BlackOnWhite
        , qrCode = False
        }
    }


type alias ParametersDict =
    Dict String String


toDict : Parameters -> ParametersDict
toDict params =
    [ ( "version", "1.0" )
    , ( Key.toString ShoulderWidth, String.fromFloat (toMM params.shoulderWidth) )
    , ( Key.toString LongPieceLength, String.fromFloat (toMM params.longPiece.length) )
    , ( Key.toString LoopStyle, loopStyleToString params.shortPiece.loops.style )
    , ( Key.toString ShortPieceLength, String.fromFloat (toMM params.shortPiece.length) )
    , ( Key.toString CanvasMargin, String.fromFloat (toMM params.rendering.margin) )
    , ( Key.toString LineWidth, String.fromFloat (toMM params.rendering.lineWidth) )
    , ( Key.toString ColorSchema, colorSchemaToString params.rendering.colorSchema )
    , ( Key.toString BuckleHoleCount, String.fromInt params.longPiece.buckleHole.count )
    , ( Key.toString BuckleHoleOffset, String.fromFloat (toMM params.longPiece.buckleHole.offset) )
    , ( Key.toString BuckleHoleInterval, String.fromFloat (toMM params.longPiece.buckleHole.interval) )
    , ( Key.toString Profile, profileKind params.profile )
    ]
        |> (++)
            (case params.profile of
                Straight ->
                    []

                Tapered to ->
                    [ ( Key.toString TaperTo, String.fromFloat (toMM to) ) ]
            )
        |> (++)
            (if params.longPiece.buckleHole.count > 0 then
                [ ( Key.toString BuckleHoleDiameter, String.fromFloat (toMM params.longPiece.buckleHole.diameter) )
                ]

             else
                []
            )
        |> (++)
            (case params.shortPiece.loops.fixed of
                Just fixed ->
                    [ ( Key.toString HasFixedLoop, "" )
                    , ( Key.toString FixedLoopWidth, String.fromFloat (toMM fixed.width) )
                    , ( Key.toString FixedLoopLength, String.fromFloat (toMM fixed.length) )
                    ]

                Nothing ->
                    []
            )
        |> (++)
            (case params.shortPiece.loops.free of
                Just free ->
                    [ ( Key.toString HasFreeLoop, "" )
                    , ( Key.toString FreeLoopWidth, String.fromFloat (toMM free.width) )
                    , ( Key.toString FreeLoopLength, String.fromFloat (toMM free.length) )
                    , ( Key.toString FreeLoopOverlap, String.fromFloat (toMM free.overlap) )
                    ]

                Nothing ->
                    []
            )
        |> (++)
            (if params.rendering.qrCode then
                [ ( Key.toString QRCode, "" ) ]

             else
                []
            )
        |> Dict.fromList


{-| Fields under `Maybe` record may be empty when the parsed parent is
`Nothing`. These values sets default values for those fields.
-}
fallbackValues : ParametersDict
fallbackValues =
    [ ( Key.toString TaperTo, "18" )
    , ( Key.toString FixedLoopWidth, String.fromFloat (toMM defaultFixedLoop.width) )
    , ( Key.toString FixedLoopLength, String.fromFloat (toMM defaultFixedLoop.length) )
    , ( Key.toString FreeLoopWidth, String.fromFloat (toMM defaultFreeLoop.width) )
    , ( Key.toString FreeLoopLength, String.fromFloat (toMM defaultFreeLoop.length) )
    , ( Key.toString FreeLoopOverlap, String.fromFloat (toMM defaultFreeLoop.overlap) )
    , ( Key.toString BuckleHoleDiameter, String.fromFloat (toMM default.longPiece.buckleHole.diameter) )
    ]
        |> Dict.fromList


getKey : Key -> ParametersDict -> Maybe String
getKey key fields =
    Dict.get (Key.toString key) fields


hasKey : Key -> ParametersDict -> Bool
hasKey key fields =
    not (getKey key fields == Nothing)