/src/Models/PWS01/Parameters.elm at bbda233aed0f959bfac848ce49428b4c0f69a9ec

-- Copyright 2026 Shota FUJI
--
-- This source code and the design it expresses are licensed under
-- the Creative Commons Attribution 4.0 International License.
--
-- SPDX-License-Identifier: CC-BY-4.0


module Models.PWS01.Parameters exposing (..)

import Dict exposing (Dict)
import Length exposing (Length, mm, toMM)
import Models.PWS01.Parameters.Key as Key exposing (Key(..))
import Preferences exposing (DictKeyMode(..))


type TipStyle
    = Round
    | Pointed Int


tipStyleToString : TipStyle -> String
tipStyleToString shape =
    case shape of
        Round ->
            "round"

        Pointed _ ->
            "pointed"


tipStyleToCompactString : TipStyle -> String
tipStyleToCompactString style =
    case style of
        Round ->
            "r"

        Pointed _ ->
            "p"


type alias BuckleHole =
    -- Distance between a base hole (center hole) and case-side strap end.
    { distance : Length

    -- Adjustment level. The number of holes will be `1 + adjustments * 2`.
    , adjustments : Int

    -- Center-to-center.
    , interval : Length
    , 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 : TipStyle
    , 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"


loopStyleToCompactString : LoopStyle -> String
loopStyleToCompactString style =
    case style of
        Simple ->
            "s"

        Folded ->
            "f"


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"


colorSchemaToCompactString : ColorSchema -> String
colorSchemaToCompactString schema =
    case schema of
        BlackOnWhite ->
            "w"

        WhiteOnBlack ->
            "b"


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"


profileToCompactString : Profile -> String
profileToCompactString profile =
    case profile of
        Straight ->
            "s"

        Tapered _ ->
            "t"


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


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


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


defaultTipSharpness : Int
defaultTipSharpness =
    25


default : Parameters
default =
    { shoulderWidth = mm 20
    , longPiece =
        { length = mm 112
        , tip = Pointed defaultTipSharpness
        , buckleHole =
            { distance = mm 70
            , adjustments = 3
            , interval = mm 6
            , diameter = mm 2
            }
        }
    , shortPiece =
        { length = mm 80
        , loops =
            { fixed = Just defaultFixedLoop
            , free = Just defaultFreeLoop
            , style = Simple
            }
        }
    , paddingOffset = mm 5
    , 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 : DictKeyMode -> Parameters -> ParametersDict
toDict mode params =
    let
        toString =
            case mode of
                Regular ->
                    Key.toString

                Compact ->
                    Key.toCompactID
    in
    [ ( "version", "1.0" )
    , ( toString TipStyle
      , case mode of
            Regular ->
                tipStyleToString params.longPiece.tip

            Compact ->
                tipStyleToCompactString params.longPiece.tip
      )
    , ( toString ShoulderWidth, String.fromFloat (toMM params.shoulderWidth) )
    , ( toString PaddingOffset, String.fromFloat (toMM params.paddingOffset) )
    , ( toString LongPieceLength, String.fromFloat (toMM params.longPiece.length) )
    , ( toString LoopStyle
      , case mode of
            Regular ->
                loopStyleToString params.shortPiece.loops.style

            Compact ->
                loopStyleToCompactString params.shortPiece.loops.style
      )
    , ( toString ShortPieceLength, String.fromFloat (toMM params.shortPiece.length) )
    , ( toString CanvasMargin, String.fromFloat (toMM params.rendering.margin) )
    , ( toString LineWidth, String.fromFloat (toMM params.rendering.lineWidth) )
    , ( toString ColorSchema
      , case mode of
            Regular ->
                colorSchemaToString params.rendering.colorSchema

            Compact ->
                colorSchemaToCompactString params.rendering.colorSchema
      )
    , ( toString BuckleHoleAdjustments, String.fromInt params.longPiece.buckleHole.adjustments )
    , ( toString BuckleHoleDistance, String.fromFloat (toMM params.longPiece.buckleHole.distance) )
    , ( toString BuckleHoleInterval, String.fromFloat (toMM params.longPiece.buckleHole.interval) )
    , ( toString BuckleHoleDiameter, String.fromFloat (toMM params.longPiece.buckleHole.diameter) )
    , ( toString Profile
      , case mode of
            Regular ->
                profileKind params.profile

            Compact ->
                profileToCompactString params.profile
      )
    ]
        |> (++)
            (case params.longPiece.tip of
                Round ->
                    []

                Pointed sharpness ->
                    [ ( toString TipSharpness, String.fromInt sharpness ) ]
            )
        |> (++)
            (case params.profile of
                Straight ->
                    []

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

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

                Nothing ->
                    []
            )
        |> (++)
            (if params.rendering.qrCode then
                [ ( 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 : DictKeyMode -> ParametersDict
fallbackValues mode =
    let
        toString =
            case mode of
                Regular ->
                    Key.toString

                Compact ->
                    Key.toCompactID
    in
    [ ( toString TaperTo, "18" )
    , ( toString TipSharpness, String.fromInt defaultTipSharpness )
    , ( toString FixedLoopWidth, String.fromFloat (toMM defaultFixedLoop.width) )
    , ( toString FixedLoopLength, String.fromFloat (toMM defaultFixedLoop.length) )
    , ( toString FreeLoopWidth, String.fromFloat (toMM defaultFreeLoop.width) )
    , ( toString FreeLoopLength, String.fromFloat (toMM defaultFreeLoop.length) )
    , ( toString FreeLoopOverlap, String.fromFloat (toMM defaultFreeLoop.overlap) )
    ]
        |> Dict.fromList


getKey : Key -> ParametersDict -> Maybe String
getKey key fields =
    case Dict.get (Key.toCompactID key) fields of
        Just value ->
            Just value

        Nothing ->
            Dict.get (Key.toString key) fields


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