module Model.Translations exposing
  ( translationsDecoder
  , Translations
  , Translation
  , getMessage
  , getParamMessage
  )

import Maybe exposing (withDefault)
import Json.Decode as Decode exposing (Decoder)
import String

type alias Translations = List Translation

translationsDecoder : Decoder Translations
translationsDecoder = Decode.list translationDecoder

type alias Translation =
  { key : String
  , message : List MessagePart
  }

getTranslation : String -> Translations -> Maybe (List MessagePart)
getTranslation key translations =
  translations
    |> List.filter (\translation -> String.toLower translation.key == String.toLower key)
    |> List.head
    |> Maybe.map .message

translationDecoder : Decoder Translation
translationDecoder =
  Decode.map2 Translation
    (Decode.field "key" Decode.string)
    (Decode.field "message" (Decode.list partDecoder))

type MessagePart =
  Order Int
  | Str String

partDecoder : Decoder MessagePart
partDecoder = (Decode.field "tag" Decode.string) |> Decode.andThen partDecoderWithTag

partDecoderWithTag : String -> Decoder MessagePart
partDecoderWithTag tag =
  case tag of
    "Order" -> Decode.map Order (Decode.field "contents" Decode.int)
    _ -> Decode.map Str (Decode.field "contents" Decode.string)

-----

getMessage : Translations -> String -> String
getMessage = getParamMessage []

getParamMessage : List String -> Translations -> String -> String
getParamMessage values translations key =
  getTranslation key translations
    |> Maybe.map (\parts -> String.concat (List.map (replacePart values) parts))
    |> withDefault key

replacePart : List String -> MessagePart -> String
replacePart values part =
  case part of
    Str str -> str
    Order n ->
      values
        |> List.drop (n - 1)
        |> List.head
        |> withDefault ("{" ++ (toString n) ++ "}")