/src/Svg/Path.elm at 345ad57d54faf970c66840819655c5f4a2f3c686

-- 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 Svg.Path exposing (LargeArcFlag(..), PathCommand(..), PointMode(..), SweepFlag(..), d)

import Svg
import Svg.Attributes


type PointMode
    = Relative
    | Absolute


type alias PointXY =
    ( Float, Float )


pointXY : PointXY -> String
pointXY ( x, y ) =
    String.fromFloat x ++ "," ++ String.fromFloat y


type alias PointX =
    Float


type alias PointY =
    Float


type LargeArcFlag
    = LargeArc
    | SmallArc


largeArcFlag : LargeArcFlag -> String
largeArcFlag flag =
    case flag of
        LargeArc ->
            "1"

        SmallArc ->
            "0"


type SweepFlag
    = Clockwise
    | Counterclockwise


sweepFlag : SweepFlag -> String
sweepFlag flag =
    case flag of
        Clockwise ->
            "1"

        Counterclockwise ->
            "0"


type alias EllipticalArcCurveParameters =
    { rx : Float
    , ry : Float
    , angle : Float
    , largeArcFlag : LargeArcFlag
    , sweepFlag : SweepFlag
    , x : Float
    , y : Float
    }


ellipticalArcCurveParamsToString : EllipticalArcCurveParameters -> String
ellipticalArcCurveParamsToString params =
    String.fromFloat params.rx
        ++ " "
        ++ String.fromFloat params.ry
        ++ " "
        ++ String.fromFloat params.angle
        ++ " "
        ++ largeArcFlag params.largeArcFlag
        ++ " "
        ++ sweepFlag params.sweepFlag
        ++ " "
        ++ String.fromFloat params.x
        ++ ","
        ++ String.fromFloat params.y


type PathCommand
    = MoveTo PointMode PointXY
    | LineTo PointMode PointXY
    | HorizontalLineTo PointMode PointX
    | VerticalLineTo PointMode PointY
    | CubicBezierCurve PointMode ( PointXY, PointXY, PointXY ) (List ( PointXY, PointXY, PointXY ))
    | SmoothCubicBezierCurve PointMode ( PointXY, PointXY ) (List ( PointXY, PointXY ))
    | QuadraticBezierCurve PointMode ( PointXY, PointXY ) (List ( PointXY, PointXY ))
    | SmoothQuadraticBezierCurve PointMode PointXY (List PointXY)
    | EllipticalArcCurve PointMode EllipticalArcCurveParameters (List EllipticalArcCurveParameters)
    | ClosePath


pointsToString2 : ( PointXY, PointXY ) -> String
pointsToString2 ( p1, p2 ) =
    pointXY p1 ++ " " ++ pointXY p2


pointsToString3 : ( PointXY, PointXY, PointXY ) -> String
pointsToString3 ( p1, p2, p3 ) =
    pointXY p1 ++ " " ++ pointXY p2 ++ " " ++ pointXY p3


pathCommandToString : PathCommand -> String
pathCommandToString command =
    case command of
        MoveTo mode p ->
            let
                op =
                    case mode of
                        Absolute ->
                            "M"

                        Relative ->
                            "m"
            in
            op ++ " " ++ pointXY p

        LineTo mode p ->
            let
                op =
                    case mode of
                        Absolute ->
                            "L"

                        Relative ->
                            "l"
            in
            op ++ " " ++ pointXY p

        HorizontalLineTo mode x ->
            let
                op =
                    case mode of
                        Absolute ->
                            "H"

                        Relative ->
                            "h"
            in
            op ++ " " ++ String.fromFloat x

        VerticalLineTo mode y ->
            let
                op =
                    case mode of
                        Absolute ->
                            "V"

                        Relative ->
                            "v"
            in
            op ++ " " ++ String.fromFloat y

        CubicBezierCurve mode ps params ->
            let
                op =
                    case mode of
                        Absolute ->
                            "C"

                        Relative ->
                            "c"
            in
            (op
                :: pointsToString3 ps
                :: (params |> List.map pointsToString3 |> List.foldr (::) [])
            )
                |> String.join " "

        SmoothCubicBezierCurve mode ps params ->
            let
                op =
                    case mode of
                        Absolute ->
                            "S"

                        Relative ->
                            "S"
            in
            (op
                :: pointsToString2 ps
                :: (params |> List.map pointsToString2 |> List.foldr (::) [])
            )
                |> String.join " "

        QuadraticBezierCurve mode ps params ->
            let
                op =
                    case mode of
                        Absolute ->
                            "Q"

                        Relative ->
                            "q"
            in
            (op
                :: pointsToString2 ps
                :: (params |> List.map pointsToString2 |> List.foldr (::) [])
            )
                |> String.join " "

        SmoothQuadraticBezierCurve mode p params ->
            let
                op =
                    case mode of
                        Absolute ->
                            "T"

                        Relative ->
                            "t"
            in
            (op
                :: pointXY p
                :: (params |> List.map pointXY |> List.foldr (::) [])
            )
                |> String.join " "

        EllipticalArcCurve mode param params ->
            let
                op =
                    case mode of
                        Absolute ->
                            "A"

                        Relative ->
                            "a"
            in
            (op
                :: ellipticalArcCurveParamsToString param
                :: (params |> List.map ellipticalArcCurveParamsToString |> List.foldr (::) [])
            )
                |> String.join " "

        ClosePath ->
            "Z"


d : List PathCommand -> Svg.Attribute msg
d commands =
    Svg.Attributes.d
        (commands
            |> List.map pathCommandToString
            |> String.join " "
        )