/src/Parameters.elm at 4652d530b5c39ed63c36e71c7ac1c9bb99189115

-- 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
    , flap : Length
    }


type alias FixedLoop =
    { width : Length
    , play : Length
    , offset : Length
    }


type alias FreeLoop =
    { width : Length
    , play : 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
    , thickness : Length
    }


type alias BuckleTongue =
    { thickness : Length
    , width : Length
    }


{-| Clasp / Buckle.
-}
type alias Buckle =
    { springBarDiameter : Length
    , tongue : Maybe BuckleTongue
    }


{-| 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
    , caseSideFlap : Length
    , claspSideFlap : Length
    , buckle : Buckle
    }


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 alias Parameters =
    { lugWidth : Length
    , longPiece : LongPiece
    , shortPiece : ShortPiece
    , thickness : Length
    , lining : Length
    , taper : Length
    , rendering : Rendering
    }


defaultFixedLoop : FixedLoop
defaultFixedLoop =
    { offset = mm 8
    , width = mm 6
    , play = mm 1
    }


defaultFreeLoop : FreeLoop
defaultFreeLoop =
    { width = mm 5
    , play = mm 2
    , overlap = mm 5
    }


defaultBuckleTongue : BuckleTongue
defaultBuckleTongue =
    { thickness = mm 2
    , width = mm 2.6
    }


default : Parameters
default =
    { lugWidth = mm 20
    , longPiece =
        { length = mm 112
        , tip = Round
        , buckleHole =
            { offset = mm 50
            , count = 7
            , interval = mm 6
            , diameter = mm 2
            }
        , flap = mm 15
        }
    , shortPiece =
        { length = mm 80
        , loops =
            { fixed = Just defaultFixedLoop
            , free = Just defaultFreeLoop
            , style = Simple
            , thickness = mm 1.0
            }
        , caseSideFlap = mm 15
        , claspSideFlap = mm 20
        , buckle =
            { springBarDiameter = mm 1.4
            , tongue = Just defaultBuckleTongue
            }
        }
    , thickness = mm 2.5
    , lining = mm 0.5
    , taper = mm 0
    , rendering =
        { size = A4
        , margin = mm 3
        , gap = mm 10
        , lineWidth = mm 0.3
        , colorSchema = BlackOnWhite
        , qrCode = False
        }
    }


type alias ParametersDict =
    Dict String String


toDict : Parameters -> ParametersDict
toDict params =
    [ ( "version", "1.0" )
    , ( Key.toString LugWidth, String.fromFloat (toMM params.lugWidth) )
    , ( Key.toString SurfaceThickness, String.fromFloat (toMM params.thickness) )
    , ( Key.toString LiningThickness, String.fromFloat (toMM params.lining) )
    , ( Key.toString LongPieceLength, String.fromFloat (toMM params.longPiece.length) )
    , ( Key.toString LoopThickness, String.fromFloat (toMM params.shortPiece.loops.thickness) )
    , ( Key.toString LoopStyle, loopStyleToString params.shortPiece.loops.style )
    , ( Key.toString BuckleSpringBarDiameter, String.fromFloat (toMM params.shortPiece.buckle.springBarDiameter) )
    , ( 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) )
    ]
        |> (++)
            (if toMM params.taper > 0 then
                [ ( Key.toString Taper, String.fromFloat (toMM params.taper) ) ]

             else
                []
            )
        |> (++)
            (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 FixedLoopPlay, String.fromFloat (toMM fixed.play) )
                    ]

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

                Nothing ->
                    []
            )
        |> (++)
            (case params.shortPiece.buckle.tongue of
                Just tongue ->
                    [ ( Key.toString HasBuckleTongue, "" )
                    , ( Key.toString BuckleTongueThickness, String.fromFloat (toMM tongue.thickness) )
                    , ( Key.toString BuckleTongueWidth, String.fromFloat (toMM tongue.width) )
                    ]

                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 Taper, "0" )
    , ( Key.toString FixedLoopWidth, String.fromFloat (toMM defaultFixedLoop.width) )
    , ( Key.toString FixedLoopPlay, String.fromFloat (toMM defaultFixedLoop.play) )
    , ( Key.toString FreeLoopWidth, String.fromFloat (toMM defaultFreeLoop.width) )
    , ( Key.toString FreeLoopPlay, String.fromFloat (toMM defaultFreeLoop.play) )
    , ( Key.toString FreeLoopOverlap, String.fromFloat (toMM defaultFreeLoop.overlap) )
    , ( Key.toString BuckleTongueThickness, String.fromFloat (toMM defaultBuckleTongue.thickness) )
    , ( Key.toString BuckleTongueWidth, String.fromFloat (toMM defaultBuckleTongue.width) )
    , ( 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)