module dscord.api.client;

import std.conv,
       std.array,
       std.format,
       std.variant,
       std.algorithm.iteration,
       core.time;
import vibe.core.core,
       vibe.http.client,
       vibe.stream.operations,
       vibe.textfilter.urlencode;
import discord.api,
       discord.info,
       discord.structures,
       discord.api.routes,
       discord.api.ratelimit;

enum MessageFilter : string {
  AROUND = "around",
  BEFORE = "before",
  AFTER = "after"
}

class APIClient {
  string baseURL = "https://discordapp.com/api";
  string userAgent;
  string token;
  RateLimiter ratelimit;
  Client client;
  Logger log;

  this(Client client) {
    this.client = client;
    this.log = client.log;
    this.token = client.token;
    this.ratelimit = new RateLimiter;
    this.userAgent = format("DiscordBot (%s %s) %s", GITHUB_REPO, VERSION, "vibe.d/" ~ vibeVersionString);
  }

  APIResponse request(CompiledRoute route) {
    return request(route, null, "");
  }

  APIResponse request(CompiledRoute route, string[string] params) {
    return request(route, params, "");
  }

  APIResponse request(CompiledRoute route, VibeJSON obj) {
    return request(route, null, obj.toString);
  }

  APIResponse request(CompiledRoute route, string[string] params, string content) {
    Duration timeout = 15.seconds;

    if (!this.ratelimit.check(route.bucket, timeout)) {
      throw new APIError(-1, "Request expired before rate-limit cooldown.");
    }

    string paramString = "";
    if (params != null) {
      if (params.length > 0) {
        paramString = "?";
      }
      foreach(key; params.keys) {
        paramString ~= urlEncode(key) ~ "=" ~ urlEncode(params[key]) ~ "&";
      }
      paramString = paramString[0..$-1];
    }

    auto res = new APIResponse(requestHTTP(this.baseURL ~ route.compiled ~ paramString,
      (scope req) {
        req.method = route.method;
        req.headers["Authorization"] = "Bot " ~ this.token;
        req.headers["Content-Type"] = "application/json";
        req.headers["User-Agent"] = this.userAgent;
        req.bodyWriter.write(content);
    }));
    this.log.tracef("[%s] [%s] %s: \n\t%s", route.method, res.statusCode, this.baseURL ~ route.compiled, content);

    if (res.header("X-RateLimit-Limit", "") != "") {
      this.ratelimit.update(route.bucket,
            res.header("X-RateLimit-Remaining"),
            res.header("X-RateLimit-Reset"),
            res.header("Retry-After", ""));
    }

    if (res.statusCode == 429) {
      this.log.error("Request returned 429.");
      return this.request(route, params, content);
    } else if (res.statusCode == 502) {
      sleep(randomBackoff());
      return this.request(route, params, content);
    }
    return res;
  }

  /**
    The client as a Discord user.
  */
  User usersMeGet() {
    auto json = this.request(Routes.USERS_ME_GET()).ok().vibeJSON;
    return new User(this.client, json);
  }

  /**
    Obtains a Discord user from ID. (Returns User object)
  */
  User usersGet(Snowflake id) {
    auto json = this.request(Routes.USERS_GET(id)).vibeJSON;
    return new User(this.client, json);
  }

  /**
    Updates the client user settings.
  */
  User usersMePatch(string username, string avatar) {
    VibeJSON data = VibeJSON(["username": VibeJSON(username), "avatar": VibeJSON(avatar)]);
    auto json = this.request(Routes.USERS_ME_PATCH(), data).vibeJSON;
    return new User(this.client, json);
  }

  /**
    All the channels the client is currrently handling.
  */
  Channel[] usersMeDMSList() {
    auto json = this.request(Routes.USERS_ME_DMS_LIST()).ok().vibeJSON;
    return deserializeFromJSONArray(json, v => new Channel(this.client, v));
  }

  /**
    Creates a new DM for a recipient (user) ID. Returns a Channel object.
  */
  Channel usersMeDMSCreate(Snowflake recipientID) {
    VibeJSON payload = VibeJSON(["recipient_id": VibeJSON(recipientID)]);
    auto json = this.request(Routes.USERS_ME_DMS_CREATE(), payload).ok().vibeJSON;
    return new Channel(this.client, json);
  }

  /**
    All the guilds the client is currently handling.
  */
  Guild[] usersMeGuildsList() {
    auto json = this.request(Routes.USERS_ME_GUILDS_LIST()).ok().vibeJSON;
    return deserializeFromJSONArray(json, v => new Guild(this.client, v));
  }

  /**
    Leaves a guild.
  */
  void usersMeGuildsLeave(Snowflake id) {
    this.request(Routes.USERS_ME_GUILDS_LEAVE(id)).ok();
  }

  /**
    Obtains a Guild from a guild ID.
  */
  Guild guildsGet(Snowflake id) {
    auto json = this.request(Routes.GUILDS_GET(id)).ok().vibeJSON;
    return new Guild(this.client, json);
  }

  /**
    Updates a guild with new data.
  */
  Guild guildsModify(Snowflake id, VibeJSON obj) {
    auto json = this.request(Routes.GUILDS_MODIFY(id), obj).vibeJSON;
    return new Guild(this.client, json);
  }

  /**
    Deletes a guild.
  */
  void guildsDelete(Snowflake id) {
    this.request(Routes.GUILDS_DELETE(id)).ok();
  }

  /**
    Kicks a member from a guild.
  */
  void guildsMembersKick(Snowflake id, Snowflake user) {
    this.request(Routes.GUILDS_MEMBERS_KICK(id, user)).ok();
  }


  /**
    Collection of channels that are in a guild.
  */
  Channel[] guildsChannelsList(Snowflake id) {
    auto json = this.request(Routes.GUILDS_CHANNELS_LIST(id)).ok().vibeJSON;
    return deserializeFromJSONArray(json, v => new Channel(this.client, v));
  }

  /**
    Sends a message to a channel.
  */
  Message channelsMessagesCreate(Snowflake channel, inout(string) content, inout(string) nonce, inout(bool) tts, inout(MessageEmbed) embed) {
    VibeJSON payload = VibeJSON([
      "content": VibeJSON(content),
      "nonce": VibeJSON(nonce),
      "tts": VibeJSON(tts),
    ]);

    if (embed) {
      payload["embed"] = embed.serializeToJSON();
    }
    auto json = this.request(Routes.CHANNELS_MESSAGES_CREATE(channel), payload).ok().vibeJSON;
    return new Message(this.client, json);
  }

  /**
    Edits a message's content.
  */
  Message channelsMessagesModify(Snowflake channel, Snowflake message, inout(string) content, inout(MessageEmbed) embed) {
    VibeJSON payload = VibeJSON(["content": VibeJSON(content)]);

    if (embed) {
      payload["embed"] = embed.serializeToJSON();
    }
    auto json = this.request(Routes.CHANNELS_MESSAGES_MODIFY(channel, message), payload).ok().vibeJSON;
    return new Message(this.client, json);
  }

  /**
    Deletes a message.
  */
  void channelsMessagesDelete(Snowflake channel, Snowflake message) {
    this.request(Routes.CHANNELS_MESSAGES_DELETE(channel, message)).ok();
  }

  /**
    Gets the messages sent in a channel. (Limit: 100) (Mapped by their IDs)
  */
  Message[] channelsMessagesList(Snowflake channel, uint limit = 50, MessageFilter filter = MessageFilter.BEFORE, Snowflake msg = 0){
    enum string errorTooMany = "The maximum number of messages that can be returned at one time is 100.";
    assert(limit <= 100, errorTooMany);

    if(limit > 100){
      throw new Exception(errorTooMany);
    }

    string[string] params = ["limit":limit.toString];

    if (msg) {
      params[filter] = msg.toString;
    }
    auto json = this.request(Routes.CHANNELS_MESSAGES_LIST(channel), params).ok().vibeJSON;
    return deserializeFromJSONArray(json, v => new Message(this.client, v));
  }

  /**
    Bulk deletes given messages.
  */
  void channelsMessagesDeleteBulk(Snowflake channel, Snowflake[] messages) {
    VibeJSON payload = VibeJSON(["messages": VibeJSON(array(map!((m) => VibeJSON(m))(messages)))]);
    this.request(Routes.CHANNELS_MESSAGES_DELETE_BULK(channel), payload).ok();
  }

  /**
    Returns a valid Gateway Websocket URL.
  */
  string getGateway() {
    return this.request(Routes.GATEWAY_GET()).ok().vibeJSON["url"].to!string;
  }
}