module dcord.state;

import std.functional,
       std.stdio,
       std.algorithm.iteration,
       std.experimental.logger,
       std.array;

import vibe.core.sync : createManualEvent, LocalManualEvent;
import std.algorithm.searching : canFind, countUntil;
import std.algorithm.mutation : remove;

import dcord.api,
       dcord.types,
       dcord.client,
       dcord.gateway,
       dcord.util.emitter;

/// The State class is used to track and maintain client state.
class State: Emitter {
  /// Client instance
  Client client;
  /// APIClient instance
  APIClient api;
  /// GatewayClient instance
  GatewayClient gw;

  /// Currently logged in user, recieved from READY payload.
  User me;

  /// All users that the bot sees 
  UserMap users;

  /// All currently loaded guilds
  GuildMap guilds;

  /// All currently loaded DMs
  ChannelMap directMessages;

  /// All currently loaded channels
  ChannelMap channels;

  /// All voice states
  VoiceStateMap voiceStates;

  /// Event triggered when all guilds are synced
  LocalManualEvent ready;

  bool requestOfflineMembers = true;

  private {
    Snowflake[] awaitingCreate;

    Logger log;
    EventListenerArray listeners;
  }

  this(Client client) {
    this.client = client;
    this.log = client.log;
    this.api = client.api;
    this.gw = client.gw;

    this.users = new UserMap;
    this.guilds = new GuildMap;
    this.directMessages = new ChannelMap;
    this.channels = new ChannelMap;
    this.voiceStates = new VoiceStateMap;

    this.ready = createManualEvent();

    // Finally bind all listeners
    this.bindListeners();
  }

  private void listen(Ty...)() {
    foreach (T; Ty) {
      this.listeners ~= this.client.events.listen!T(mixin("&this.on" ~ T.stringof));
    }
  }

  private void bindListeners() {
    // Unbind all listeners
    this.listeners.each!(l => l.unbind());

    // Always listen for ready payload
    this.listen!(
      Ready, GuildCreate, GuildUpdate, GuildDelete, GuildMemberAdd, GuildMemberRemove,
      GuildMemberUpdate, GuildMembersChunk, GuildRoleCreate, GuildRoleUpdate, GuildRoleDelete,
      GuildEmojisUpdate, ChannelCreate, ChannelUpdate, ChannelDelete, VoiceStateUpdate, MessageCreate,
      PresenceUpdate
    );
  }

  private void onReady(Ready r) {
    this.me = r.me;
    this.awaitingCreate ~= r.guilds.map!(g => g.id).array;
    this.directMessages.each(dm => this.directMessages[dm.id] = dm);
  }

  private void onGuildCreate(GuildCreate c) {
    // If this guild is "coming online" and we're awaiting its creation, clear that state here
    if (!c.unavailable && this.awaitingCreate.canFind(c.guild.id)) {
      this.awaitingCreate.remove(this.awaitingCreate.countUntil(c.guild.id));

      // If no other guilds are awaiting, emit the event
      if(this.awaitingCreate.length == 0) this.ready.emit();
    }

    this.guilds[c.guild.id] = c.guild;

    c.guild.channels.each(c => this.channels[c.id] = c); 
    c.guild.members.each(m => this.users[m.user.id] = m.user); 
    c.guild.voiceStates.each(v => this.voiceStates[v.sessionID] = v);
    if(this.requestOfflineMembers) c.guild.requestOfflineMembers(); 
  }

  private void onGuildUpdate(GuildUpdate c) {
    if(!this.guilds.has(c.guild.id)) return;
  }

  private void onGuildDelete(GuildDelete c) {
    if(!this.guilds.has(c.guildID)) return;
    this.guilds.remove(c.guildID);
  }

  private void onGuildMemberAdd(GuildMemberAdd c) {
    if(this.users.has(c.member.user.id)) {
      this.users[c.member.user.id] = c.member.user;
    }

    if(this.guilds.has(c.member.guild.id)) {
      this.guilds[c.member.guild.id].members[c.member.user.id] = c.member;
    }
  }

  private void onGuildMemberRemove(GuildMemberRemove c) {
    if(!this.guilds.has(c.guildID)) return;
    if(!this.guilds[c.guildID].members.has(c.user.id)) return;
    this.guilds[c.guildID].members.remove(c.user.id);
  }

  private void onGuildMemberUpdate(GuildMemberUpdate c) {
    if(!this.guilds.has(c.member.guildID)) return;
    if(!this.guilds[c.member.guildID].members.has(c.member.user.id)) return;
  }

  private void onGuildRoleCreate(GuildRoleCreate c) {
    if(!this.guilds.has(c.guildID)) return;
    this.guilds[c.guildID].roles[c.role.id] = c.role;
  }

  private void onGuildRoleDelete(GuildRoleDelete c) {
    if(!this.guilds.has(c.guildID)) return;
    if(!this.guilds[c.guildID].roles.has(c.role.id)) return;
    this.guilds[c.guildID].roles.remove(c.role.id);
  }

  private void onGuildRoleUpdate(GuildRoleUpdate c) {
    if(!this.guilds.has(c.guildID)) return;
    if(!this.guilds[c.guildID].roles.has(c.role.id)) return;
    this.guilds[c.guildID].roles[c.role.id] = c.role;
  }

  private void onChannelCreate(ChannelCreate c) {
    this.channels[c.channel.id] = c.channel;
  }

  private void onChannelUpdate(ChannelUpdate c) {
    this.channels[c.channel.id] = c.channel;
  }

  private void onChannelDelete(ChannelDelete c) {
    if(this.channels.has(c.channel.id)) this.channels.remove(c.channel.id);
  }

  private void onVoiceStateUpdate(VoiceStateUpdate u) {
    // TODO: shallow tracking, don't require guilds
    auto guild = this.guilds.get(u.state.guildID);
    if (!guild) return;

    if (!u.state.channelID) {
      this.voiceStates.remove(u.state.sessionID);
      guild.voiceStates.remove(u.state.sessionID);
    } else {
      this.voiceStates[u.state.sessionID] = u.state;
      guild.voiceStates[u.state.sessionID] = u.state;
    }
  }
  
  private void onGuildMembersChunk(GuildMembersChunk c) {
    // TODO
  }

  private void onGuildEmojisUpdate(GuildEmojisUpdate c) {
    // TODO
  }

  private void onMessageCreate(MessageCreate mc) {
    // TODO
  }

  private void onPresenceUpdate(PresenceUpdate p) {
    // TODO
  }
}