namespace ElasticsearchFs

module ApiGenerator =

    module EnumSpec =

        type Source =
            | Parameter
            | Part

        type T =
            { Source: Source
              ActionName: string
              Name: string
              Options: string array }

        let make source actionName name options : T =
            { Source = source
              ActionName = actionName
              Name = name
              Options = options }

        let ofParameter actionName parameterName parameter =
            if ApiSpec.Parameter.isEnum parameter then
                Some (make Source.Parameter actionName parameterName parameter.Options)
            else
                None

        let ofPart actionName partName part =
            if ApiSpec.Part.isEnum part then
                Some (make Source.Part actionName partName part.Options)
            else
                None

        let ofUrl actionName (url: ApiSpec.Url) : T array =
            let parameters =
                Map.toArray url.Parameters
                |> Array.choose (fun (n,p) -> ofParameter actionName n p)
            let parts =
                Map.toArray url.Parts
                |> Array.choose (fun (n,p) -> ofPart actionName n p)
            Array.append parameters parts

        let ofApiSpec apiSpec =
            Map.toArray apiSpec
            |> Array.collect (fun (actionName,action) ->
                ofUrl actionName (ApiSpec.Action.url action))