module Main exposing (main)

import Browser exposing (sandbox)
import Debug exposing (toString, todo)
import Dict
import Html exposing (Html, div, text)
import Xml.Decode exposing (..)


type alias Name =
    String


type Value
    = IntValue Int
    | StringValue String


type alias Member =
    ( Name, Value )


type alias Struct =
    { foo : String, bar : Int }


xml : String
xml =
    String.join "\n"
        [ "<struct>"
        , "  <member>"
        , "    <name>hoge</name>"
        , "    <value>"
        , "      <string>hello</string>"
        , "    </value>"
        , "  </member>"
        , "  <member>"
        , "    <name>fuga</name>"
        , "    <value><i4>100</i4></value>"
        , "  </member>"
        , "</struct>"
        ]


memberNameDecoder : Decoder String
memberNameDecoder =
    path [ "name" ] (single string)


hogeDecoder : Decoder String
hogeDecoder =
    with memberNameDecoder <|
        \name ->
            if name == "hoge" then
                path [ "value", "string" ] (single string)

            else
                fail "recode name does not hoge"


fugaDecoder : Decoder Int
fugaDecoder =
    with memberNameDecoder <|
        \name ->
            if name == "fuga" then
                path [ "value", "i4" ] (single int)

            else
                fail "recode name does not fuga"


structDecoder : Decoder Struct
structDecoder =
    let
        parseOnMember : Decoder a -> Decoder a
        parseOnMember d =
            path [ "member" ] (leakyList d)
                |> andThen
                    (\l ->
                        case List.head l of
                            Just v ->
                                succeed v

                            Nothing ->
                                fail ":("
                    )
    in
    succeed (\foo bar -> { foo = foo, bar = bar })
        |> andMap (parseOnMember hogeDecoder)
        |> andMap (parseOnMember fugaDecoder)


type alias Model =
    String


init : Model
init =
    xml


view : Model -> Html msg
view model =
    let
        parsed : String
        parsed =
            toString <| run structDecoder model
    in
    div []
        [ div [] [ text parsed ]
        ]


main =
    sandbox
        { init = init
        , update = always identity
        , view = view
        }