# Lib
require 'securerandom'
require 'net/http'
require 'ostruct'
require 'json'
require 'time'
require 'cgi'
require 'logger'
require 'concurrent'

# Base
require 'liveqa/version'
require 'liveqa/formated_logger'
require 'liveqa/library_name'
require 'liveqa/util'
require 'liveqa/config'
require 'liveqa/errors'
require 'liveqa/liveqa_object'
require 'liveqa/request'
require 'liveqa/api_resource'
require 'liveqa/store'
require 'liveqa/message'

# Processor
require 'liveqa/processor/async'
require 'liveqa/processor/worker'
require 'liveqa/processor/batch'

# Operations
require 'liveqa/api_operation/save'
require 'liveqa/api_operation/delete'

# Resources
require 'liveqa/event'
require 'liveqa/group'
require 'liveqa/identity'
require 'liveqa/watcher'
require 'liveqa/batch'

# Plugins
require 'liveqa/plugins'

##
# Implementation of the LiveQA
module LiveQA
  class << self

    EVENTS_CREATE_ACTION = 'events:create'.freeze
    GROUPS_UPDATE_ACTION = 'groups:update'.freeze
    IDENTITIES_UPDATE_ACTION = 'identities:update'.freeze
    WATCHERS_CREATE_ACTION = 'watchers:create'.freeze

    ##
    # @return [LiveQA::Config] configurations
    attr_reader :configurations

    ##
    # Configures the LiveQA API
    #
    # @example Default configuration
    #   LiveQA.configure do |config|
    #      config.account_token = 'acc_xx'
    #      config.space_name = 'LiveQA'
    #      config.environment_name = 'production'
    #   end
    def configure
      yield @configurations = LiveQA::Config.new

      LiveQA.configurations.valid!
    end

    ##
    # Send a track event to the server
    #
    # @param [String] event name
    # @param [Hash] payload to be send
    # @param [Hash] options for the request
    #
    # @return [Boolean] status of the request
    def track(name, payload = {}, options = {})
      return true unless configurations.enabled

      payload[:type] = 'track'
      payload[:name] = name
      LiveQA::Plugins::Rails::Data.store_data if defined?(LiveQA::Plugins::Rails::Data)

      payload = Message.extended.merge(payload)

      if configurations.async
        return processor.enqueue(
          action: EVENTS_CREATE_ACTION,
          payload: payload,
          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
        )
      end

      event = Event.create(payload, options)
      event.successful?
    end

    ##
    # Send an identify event to the server
    #
    # @param [String] user id from your database
    # @param [Hash] payload to be send
    # @param [Hash] options for the request
    #
    # @return [Boolean] status of the request
    def identify(user_id, payload = {}, options = {})
      return true unless configurations.enabled

      payload[:type]    = 'identify'
      payload[:user_id] = user_id
      LiveQA::Plugins::Rails::Data.store_data if defined?(LiveQA::Plugins::Rails::Data)

      payload = Message.extended.merge(payload)

      if configurations.async
        return processor.enqueue(
          action: EVENTS_CREATE_ACTION,
          payload: payload,
          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
        )
      end

      event = Event.create(payload, options)
      event.successful?
    end

    ##
    # Send a create/update for a group
    #
    # @param [String] group id from your database
    # @param [Hash] payload to be send
    # @param [Hash] options for the request
    #
    # @return [Boolean] status of the request
    def set_group(group_id, payload = {}, options = {})
      return true unless configurations.enabled

      payload = Message.base.merge(payload)

      if configurations.async
        payload[:id] = group_id

        return processor.enqueue(
          action: GROUPS_UPDATE_ACTION,
          payload: payload,
          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
        )
      end

      group = Group.update(group_id, payload, options)
      group.successful?
    end

    ##
    # Send a create/update for an identity
    #
    # @param [String] user id from your database
    # @param [Hash] payload to be send
    # @param [Hash] options for the request
    #
    # @return [Boolean] status of the request
    def set_identity(user_id, payload = {}, options = {})
      return true unless configurations.enabled

      payload = Message.base.merge(payload)

      if configurations.async
        payload[:id] = user_id

        return processor.enqueue(
          action: IDENTITIES_UPDATE_ACTION,
          payload: payload,
          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
        )
      end

      identity = Identity.update(user_id, payload, options)
      identity.successful?
    end

    ##
    # Send a create a watcher
    #
    # @param [String|Integer] template flow name or id
    # @param [Hash] payload to be send
    # @param [Hash] options for the request
    #
    # @return [Boolean] status of the request
    def watch(id_or_name, payload = {}, options = {})
      return true unless configurations.enabled

      payload[:template_flow] = id_or_name
      payload = Message.base.merge(payload)

      payload.delete(:session_tracker_id) if payload.delete(:without_session)

      if configurations.async
        return processor.enqueue(
          action: WATCHERS_CREATE_ACTION,
          payload: payload,
          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
        )
      end

      watcher = Watcher.create(payload, options)
      watcher.successful?
    end

    private

    def processor
      @processor ||= Processor::Async.new
    end

  end
end