require "json"
require "./handler"

module Guff
  module APIMethods
    API = {
      "post": {
        "get_posts": {
          text: "Get posts matching query.",

          args: {
            "q": {
              text:     "Search string.",
              type:     :text,
              required: false,
              default:  "",
            },

            "page": {
              text:     "Page number",
              type:     :int,
              required: false,
              default:  "1",
            },

            "tags": {
              text:     "Comma-separated list of tags (union)",
              type:     :tags,
              required: false,
              default:  "1",
            },

            "sort": {
              text:     "Sort order of results",
              type:     :sort,
              required: false,
              default:  "date,desc",
            },
          },
        },
      },

      "test": {
        "version": {
          text: "Get version",
        },

        "get_posts": {
          text: "Test get posts",
        },

        "error": {
          text: "Test error response",
        },
      }
    }

    TYPE_CHECKS = {
      text: /.*/,
      int:  /^\d+$/,
      tags: /^[a-z0-9_,-]+$/,
      sort: /^[a-z0-9_]+,(?:asc|desc)$/,
    }

    private def get_method_args(
      params    : HTTP::Params,
      namespace : String,
      method    : String
    )
      return {} of String => String unless (
        API[namespace]? &&
        API[namespace][method] &&
        API[namespace][method][:args]?
      )

      # get method args
      args = API[namespace][method][:args] as \
        Hash(String, Hash(Symbol, String | Symbol | Bool))

      args.keys.reduce({} of String => String) do |r, arg_name|
        arg_data = args[arg_name] as Hash(Symbol, String|Symbol|Bool)

        # check for required parameter
        if arg_data[:required] && !params.has_key?(arg_name)
          raise "missing required parameter: %s" % [arg_name]
        end

        # get value
        val = params.fetch(arg_name, arg_data[:default] as String)

        # check value
        if !TYPE_CHECKS[arg_data[:type]].match(val)
          raise "invalid parameter format: %s" % [arg_name]
        end

        # add value to result
        r[arg_name] = val

        # return result
        r
      end
    end

    ################
    # post methods #
    ################

    private def do_post_get_posts(
      context : HTTP::Server::Context,
      args    : Hash(String, String)
    )
      [{foo: "bar"}, {foo: "asdf"}].to_json
    end

    ################
    # test methods #
    ################

    private def do_test_version(
      context : HTTP::Server::Context,
      args    : Hash(String, String)
    )
      {version: Guff::VERSION}.to_json
    end

    private def do_test_get_posts(
      context : HTTP::Server::Context,
      args    : Hash(String, String)
    )
      [{foo: "bar"}, {foo: "asdf"}].to_json
    end

    private def do_test_error(
      context : HTTP::Server::Context,
      args    : Hash(String, String)
    )
      raise "some random error"
    end
  end
end