module Telepathy::Utils
    extend self
    API_URL = "https://api.telegram.org/bot"

    enum ParseMode
        Normal
        Markdown
        HTML
    end

    def get_me(api_key : String)
            response = HTTP::Client.get(API_URL + api_key + "/getMe",
                                        headers: HTTP::Headers{"User-agent" => "Telepathy"})
            return Response(User).from_json(response.body).result
    end

    def get_updates(api_key : String, timeout = 0, last_update_id : Int? = nil)
            update_data = {} of String => Int64 | Int32 | String
            update_data["timeout"] = timeout
            last_update_id.try { |id| update_data["offset"] = id }
            response = HTTP::Client.get(API_URL + api_key + "/getUpdates",
                                        headers: HTTP::Headers{"User-agent" => "Telepathy", 
                                                               "Content-type" => "application/json" },
                                        body: update_data.to_json)
            return Response(Array(Update)).from_json(response.body).result
    end

    def send_message(api_key : String, chat_id : String | Int64, text : String,
                     parse_mode : ParseMode = ParseMode::Normal,
                     disable_web_preview : Bool = false,
                     disable_notification : Bool = false,
                     reply_to_message_id : Int64? = nil)
        message_data = { "chat_id" => chat_id, "text" => text } of String => Int64 | String | Bool
        message_data["disable_web_preview"] = true if disable_web_preview
        message_data["disable_notification"] = true if disable_notification
        if parse_mode == ParseMode::Markdown
            message_data["parse_mode"] = "Markdown"
        elsif parse_mode == ParseMode::HTML
            message_data["parse_mode"] = "HTML"
        end
        reply_to_message_id.try { |id| message_data["reply_to_message_id"] = id }
        HTTP::Client.get(API_URL + api_key + "/sendMessage",
                         headers: HTTP::Headers{"User-agent" => "Telepathy", "Content-type" => "application/json" },
                         body: message_data.to_json)
    end

    def send_photo(api_key : String, chat_id : String | Int64, photo : String | File, caption : String? = nil,
                       disable_notification : Bool = false,
                       reply_to_message_id : Int64? = nil)
        IO.pipe do |reader, writer|
            channel = Channel(String).new(1)
            spawn do
                HTTP::FormData.build(writer) do |formdata|
                    channel.send(formdata.content_type)
                    case chat_id
                    when String
                        formdata.field("chat_id", chat_id.as(String))
                    when Int64
                        formdata.field("chat_id", chat_id.as(Int64).to_s)
                    end
                    formdata.field("disable_notification", disable_notification.to_s)
                    caption.try { |caption| formdata.field("caption", caption) }
                    reply_to_message_id.try { |id| formdata.field("reply_to_message_id", id) }
                    case photo
                    when String
                        formdata.field("photo", photo.as(String))
                    when File
                        photo_file = photo.as(File)
                        formdata.file("photo", photo_file,
                                      HTTP::FormData::FileMetadata.new(filename: File.basename(photo_file.path)))
                    end
                end

                writer.close
            end

            response = HTTP::Client.get(API_URL + api_key + "/sendPhoto",
                                        headers: HTTP::Headers{"User-agent" => "Telepathy", 
                                                               "Content-type" => channel.receive },
                                        body: reader)
        end
    end
end