1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73

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

import Length exposing (toMM)
import Models.PWS01.Parameters exposing (LoopStyle(..), Parameters, canvasSizeDimension)
import Models.PWS01.Parameters.Key exposing (Key)
import Models.PWS01.Template.Cuts exposing (cuts)
import Models.PWS01.Template.InfoArea exposing (infoArea)
import String
import Svg exposing (..)
import Svg.Attributes exposing (..)
import Svg.Path exposing (LargeArcFlag(..), PathCommand(..), PointMode(..), SweepFlag(..))
import Template.Layout as Layout
import Template.Layout.Container as Container
import Template.Layout.Coordinate exposing (Request(..), SizeRequest, minSizeOf)
import Url exposing (Url)


template : Url -> Parameters -> Maybe Key -> List (Svg.Attribute msg) -> List (Svg.Svg msg)
template url params highlighting attrs =
    let
        ( canvasWidth, canvasHeight ) =
            canvasSizeDimension params.rendering.size
                |> Tuple.mapBoth toMM toMM

        margin =
            toMM params.rendering.margin

        gap =
            toMM params.rendering.gap

        info =
            infoArea url params

        cutsArea : SizeRequest
        cutsArea =
            let
                infoSize =
                    minSizeOf info.size
            in
            { width = AtLeast (canvasWidth - margin * 2 - gap)
            , height = AtLeast (canvasHeight - margin * 2 - gap * 2 - infoSize.height)
            }
    in
    cuts cutsArea params highlighting
        |> List.map
            (\cut ->
                svg
                    (viewBox (String.join " " [ "0", "0", String.fromInt (ceiling canvasWidth), String.fromInt (ceiling canvasHeight) ])
                        :: class "print"
                        :: attrs
                    )
                    [ Container.rows
                        |> Container.sized (AtLeast 0) (AtLeast 0)
                        |> Container.gapped gap
                        |> Container.aligned Container.Center
                        |> Container.padded margin
                        |> Container.build
                            [ Container.columns
                                |> Container.padded (gap / 2)
                                |> Container.build [ cut ]
                            , info
                            ]
                        |> Layout.render { width = canvasWidth, height = canvasHeight }
                    ]
            )