class ChatController < ApplicationController

  before_filter :require_login, except: [:init, :members, :load, :pusher_auth]
  skip_before_filter :check_for_previous_confirmed_sessions, only: [:pusher_auth, :load, :members]

  # Method used to init chat activity.
  def init
    if logged_in?
      if params[:group_id].blank?
        init_chat_with(params[:user_ids] || [], params[:conversation_id])
      else
        group = current_user.groups.find(params[:group_id])
        init_chat_for(group)
      end
      render nothing: true
    else
      session.merge!(user_ids: params[:user_ids], init_chat: true)
      not_authenticated
    end
  end

  # Method to close chat activity.
  def close
    find_chat_activity
    @chat_activity.destroy if @chat_activity
    ActsAsTenant.current_tenant.pusher_configuration.client.trigger_async("private-user-#{current_user.id}", 'close-chat', {conversation_id: @conversation.id})
    render nothing: true
  end

  #Method to maximize the chat window
  def maximize
    find_chat_activity
    ActsAsTenant.current_tenant.pusher_configuration.client.trigger_async("private-user-#{current_user.id}", 'maximize-chat', {conversation_id: @conversation.try(:id), type: params[:type]})
    @chat_activity.update_columns(minimized: false)
    respond_to do |format|
      if request.xhr?
        format.js
      else
        format.html {render nothing: true}
      end
    end
  end

  # Method to minimize the chat window.
  def minimize
    find_chat_activity
    ActsAsTenant.current_tenant.pusher_configuration.client.trigger_async("private-user-#{current_user.id}", 'minimize-chat', {conversation_id: @conversation.try(:id), type: params[:type]})
    @chat_activity.update_columns(minimized: true)
    respond_to do |format|
      if request.xhr?
        format.js
      else
        format.html {render nothing: true}
      end
    end
  end

  # Autocomplete method returns chat members.
  def autocomplete
    conversation = ChatConversation.find(params[:conversation_id])
    users = current_user.users_with_interaction(params[:query], except: conversation.members.pluck(:id))
    render json: users.map{|user| {name: user.full_name, id: user.id}}
  end

  # Method to get all members for chat activity related to user.
  def members
    if logged_in?
      unless params["user_type"]
        @groups = current_user.groups.course_groups.order('created_at Desc')
        if @groups.blank?
          @groups = Subject.featured.with_tutors
        end
        @my_groups = current_user.groups.user_groups.order('created_at Desc').none
        @friends = current_user.common_friends.none
        @recents = current_user.recent_chat_conversations.order('chat_conversations.updated_at DESC').page(1).per(3)
        @all = current_user.users_with_interaction.none
        respond_to do |format|
          format.json
        end
      else
        if params["type"] == 'Subject'
          @group = Subject.find(params["group_id"]) if params["group_id"]
        else
          @group = Group.find(params["group_id"]) if params["group_id"]
        end
        if params["user_type"] == 'tutor' && @group
          @users = @group.tutors.searchable.except_user(current_user).paginate(params["page"],3,params["offset"])
        elsif params["user_type"] == 'student' && @group
          @users = @group.users.except_user(current_user).paginate(params["page"],3,params["offset"])
        elsif params["user_type"] == 'recents'
          @users = current_user.recent_chat_conversations.order('chat_conversations.updated_at DESC').page(params[:page]).per(3).padding(params["offset"])
        end
        respond_to do |format|
          format.js
        end
      end
    else
      unless params["user_type"]
        @groups = Subject.featured.with_tutors
      else
        if params["type"] == 'Subject'
          @group = Subject.find(params["group_id"]) if params["group_id"]
        else
          @group = Group.find(params["group_id"]) if params["group_id"]
        end
        if params["user_type"] == 'tutor' && @group
          @users = @group.tutors.searchable.except_user(current_user).paginate(params["page"],3,params["offset"])
        elsif params["user_type"] == 'student' && @group
          @users = @group.users.except_user(current_user).paginate(params["page"],3,params["offset"])
        end
      end
    end
  end

  # Used to create channel for chat conversation of users.
  def pusher_auth
    if current_user or params[:channel_name] == 'presence-user'
      response = ActsAsTenant.current_tenant.pusher_configuration.client[params[:channel_name]].authenticate(params[:socket_id],{
          :user_id => (current_user ? current_user.id : "anonymous-user-#{params[:socket_id]}")
        })
      render :json => response
    else
      render :text => "Forbidden", :status => '403'
    end
  end

  # It loads the chat boxes for current user for chat activity.
  def load
    chatboxes = []
    current_user.chat_activities.includes(:chat_conversation).each do |activity|
      if activity.chat_conversation
        chatboxes << activity.chat_conversation.chat_data_for(current_user).merge(minimized: activity.minimized)
      end
    end
    respond_to do |format|
      format.json {render json: chatboxes}
    end
  end

  # Find chat activity for user if not exists then create new chat activity.
  def find_chat_activity
    unless params[:conversation_id]
      @chat_activity = current_user.chat_activities.find_or_create_by(chat_conversation_id: nil)
    else
      @conversation = ChatConversation.find(params[:conversation_id])
      @chat_activity = current_user.chat_activities.find_or_create_by(chat_conversation: @conversation)
    end
  end

end