class Mission < ActiveRecord::Base
  
  extend FriendlyId
  friendly_id :title, use: :slugged
  validates_presence_of :title, :slug
  
  belongs_to :owner, :class_name => "User"
  has_many :mission_agents, :dependent => :destroy
  has_many :agent_steps, :through => :mission_agents
  has_many :rewards
  accepts_nested_attributes_for :mission_agents, allow_destroy:true
  
  mount_uploader :cover_img, MissionCoverUploader
  process_in_background :cover_img
  
  after_initialize do |user|
      check_for_time_left
  end
  
  def agent_count
     return self.mission_agents.count
  end
  
  def confirmed_agent_count
    confirmed_agents = 0
    self.mission_agents.each do |agent|
      if agent.user != nil
        confirmed_agents = confirmed_agents + 1
      end
    end
    return confirmed_agents
  end
  
  def agent_count_stats
    return String.new("#{self.confirmed_agent_count}/#{self.agent_count}")
  end
  
  def step_count
    total_steps = 0
    self.mission_agents.each do |agent|
      total_steps = total_steps + agent.agent_steps.count
    end
    return total_steps
  end
  
  def completed_steps_count
    completed_steps = 0
    self.mission_agents.each do |agent|
      agent.agent_steps.each do |step|
        if step.completed
          completed_steps = completed_steps + 1
        end
      end
    end
    return completed_steps
  end
  
  def step_count_stats
    return String.new("#{self.completed_steps_count}/#{self.step_count}")
  end
  
  def percentage_completed
    steps_mod  = 0.8
    agents_mod = 0.3
    completed  = (completed_steps_count * steps_mod) + (confirmed_agent_count * agents_mod)
    total      = (step_count * steps_mod) + (agent_count * agents_mod)
    if total > 0
      percentage = (100/total) * completed
    else
      if self.status == 3
        percentage = 100
      else
        percentage = 0
      end
    end
    return percentage
  end
  
  def is_agent(user)
    if user
      if self.mission_agents.where(user_id: user.id).count > 0
        return true
      end
    end
    return false
  end

  def all_steps_completed
    if self.step_count > 0 
      self.mission_agents.each do |agent|
        agent.agent_steps.each do |step|
          if step.completed == false || step.completed == nil
            return false
          end
        end
      end
      return true
    else
      return false
    end
  end
  
  def check_for_time_left
    if self.status == 2 && self.end_date != nil
      if self.seconds_left <= 0
        self.check_for_completion
      end
    end
  end
  
  def check_for_completion
    if self.status == 1 || self.status == 2
      if seconds_left > 0
        if self.all_steps_completed
          self.completed
        end
      else
        self.failed
      end
    end
  end
  
  # LAUNCH
  def launch
    if self.status == 1 || self.status == nil
      if self.duration_scale == "days"
        self.end_date = self.duration_number.days.from_now
      elsif self.duration_scale == "hours"
        self.end_date = self.duration_number.hours.from_now
      end
      self.launch_date = Time.now
      self.status = 2
      self.save
      return true
    end
    return false
  end
  
  def completed
    analytics = Analytics.new
    analytics.track('Mission completed')
    self.update(status: 3)
    self.rewards.each do |reward|
      reward.distribute
    end
  end
  
  def failed
    analytics = Analytics.new
    analytics.track('Mission failed')
    self.update(status: 4)
  end
  
  def seconds_left
    if self.end_date
      seconds_left = self.end_date - Time.now
      return seconds_left
    else
      return 0
    end
  end
  
  def time_left
    array = self.time_left_stats
    return "#{array[0]} #{array[1]}"
  end
  
  def time_left_stats
    if self.status == 3 || self.status == 4
      time = '0'
      time_scale = (I18n.t 'time.seconds')
    elsif self.status == 1 && self.end_date == nil
      time = '?'
    elsif self.end_date
      days_left = self.seconds_left / 60 / 60 / 24
      if days_left >= 2
        time = days_left.round.to_s
        time_scale =  (I18n.t 'time.days')
      elsif days_left < 2
        hours_left = self.seconds_left / 60 / 60
        if hours_left >= 2
          time = hours_left.round.to_s
          time_scale =  (I18n.t 'time.hours')
        elsif hours_left < 2
          minutes_left = self.seconds_left / 60
          if minutes_left > 3
            time = minutes_left.round.to_s
            time_scale =  (I18n.t 'time.minutes')
          elsif minutes_left <= 3
            time = self.seconds_left.round.to_s
            time_scale =  (I18n.t 'time.seconds')
          end
        end
      end 
    else
      time =  '&infin;'
      time_scale = ''
    end
    if time_scale != ''
      time_scale = (time_scale.to_s + ' ' + (I18n.t 'time.remaining'))
    end
    array = [time, time_scale]
    return array
  end
  
  # Step Submissions for Mission Control
  def step_submissions
    submissions = Array.new
    self.mission_agents.each do |agent|
      agent.agent_steps.each do |step|
        if step.step_submissions.count > 0
          if step.step_submissions.last.validated == nil
            submissions << step.step_submissions.last
          end
        end
      end
    end
    return submissions
  end
  
end