# Copyright (C) 2012-2014 Zammad Foundation, http://zammad-foundation.org/

class Ticket
  module Escalation

=begin

rebuild escalations for all open tickets

  result = Ticket::Escalation.rebuild_all

returns

  result = true

=end

    def self.rebuild_all
      state_list_open = Ticket::State.by_category( 'open' )

      tickets = Ticket.where( state_id: state_list_open )
      tickets.each {|ticket|
        ticket.escalation_calculation
      }
    end

=begin

rebuild escalation for ticket

  ticket = Ticket.find(123)
  result = ticket.escalation_calculation

returns

  result = true

=end

    def escalation_calculation

      # set escalation off if ticket is already closed
      state = Ticket::State.lookup( id: self.state_id )
      if state.ignore_escalation?

        # nothing to change
        return true if !self.escalation_time

        self.escalation_time            = nil
        #      self.first_response_escal_date  = nil
        #      self.close_time_escal_date      = nil
        self.callback_loop = true
        self.save
        return true
      end

      # get sla for ticket
      sla_selected = escalation_calculation_get_sla

      # reset escalation if no sla is set
      if !sla_selected

        # nothing to change
        return true if !self.escalation_time

        self.escalation_time            = nil
        #      self.first_response_escal_date  = nil
        #      self.close_time_escal_date      = nil
        self.callback_loop = true
        self.save
        return true
      end

      #    puts sla_selected.inspect
      #    puts days.inspect
      self.escalation_time            = nil
      self.first_response_escal_date  = nil
      self.update_time_escal_date     = nil
      self.close_time_escal_date      = nil

      # first response
      if sla_selected.first_response_time

        # get escalation date without pending time
        self.first_response_escal_date = TimeCalculation.dest_time( self.created_at, sla_selected.first_response_time, sla_selected.data, sla_selected.timezone )

        # get pending time between created and first response escal. time
        time_in_pending = escalation_suspend( self.created_at, self.first_response_escal_date, 'relative', sla_selected, sla_selected.first_response_time )

        # get new escalation time (original escal_date + time_in_pending)
        self.first_response_escal_date = TimeCalculation.dest_time( self.first_response_escal_date, time_in_pending.to_i, sla_selected.data, sla_selected.timezone )

        # set ticket escalation
        self.escalation_time = calculation_higher_time( self.escalation_time, self.first_response_escal_date, self.first_response )
      end
      if self.first_response# && !self.first_response_in_min

        # get response time in min between created and first response
        self.first_response_in_min = escalation_suspend( self.created_at, self.first_response, 'real', sla_selected )

      end

      # set time to show if sla is raised ot in
      if sla_selected.first_response_time && self.first_response_in_min
        self.first_response_diff_in_min = sla_selected.first_response_time - self.first_response_in_min
      end

      # update time
      last_update = self.last_contact_agent
      if !last_update
        last_update = self.created_at
      end
      if sla_selected.update_time
        self.update_time_escal_date = TimeCalculation.dest_time( last_update, sla_selected.update_time, sla_selected.data, sla_selected.timezone  )

        # get pending time between created and update escal. time
        time_in_pending = escalation_suspend( last_update, self.update_time_escal_date, 'relative', sla_selected, sla_selected.update_time )

        # get new escalation time (original escal_date + time_in_pending)
        self.update_time_escal_date = TimeCalculation.dest_time( self.update_time_escal_date, time_in_pending.to_i, sla_selected.data, sla_selected.timezone )

        # set ticket escalation
        self.escalation_time = calculation_higher_time( self.escalation_time, self.update_time_escal_date, false )
      end
      if self.last_contact_agent
        self.update_time_in_min = TimeCalculation.business_time_diff( self.created_at, self.last_contact_agent, sla_selected.data, sla_selected.timezone  )
      end

      # set sla time
      if sla_selected.update_time && self.update_time_in_min
        self.update_time_diff_in_min = sla_selected.update_time - self.update_time_in_min
      end

      # close time
      if sla_selected.close_time

        # get escalation date without pending time
        self.close_time_escal_date = TimeCalculation.dest_time( self.created_at, sla_selected.close_time, sla_selected.data, sla_selected.timezone  )

        # get pending time between created and close escal. time
        extended_escalation = escalation_suspend( self.created_at, self.close_time_escal_date, 'relative', sla_selected, sla_selected.close_time )

        # get new escalation time (original escal_date + time_in_pending)
        self.close_time_escal_date = TimeCalculation.dest_time( self.close_time_escal_date, extended_escalation.to_i, sla_selected.data, sla_selected.timezone )

        # set ticket escalation
        self.escalation_time = calculation_higher_time( self.escalation_time, self.close_time_escal_date, self.close_time )
      end
      if self.close_time # && !self.close_time_in_min
        self.close_time_in_min = escalation_suspend( self.created_at, self.close_time, 'real', sla_selected )
      end
      # set sla time
      if sla_selected.close_time && self.close_time_in_min
        self.close_time_diff_in_min = sla_selected.close_time - self.close_time_in_min
      end
      if self.changed?
        self.callback_loop = true
        self.save
      end
    end

=begin

return sla for ticket

  ticket = Ticket.find(123)
  result = ticket.escalation_calculation_get_sla

returns

  result = selected_sla

=end

    def escalation_calculation_get_sla
      sla_selected = nil
      sla_list = Cache.get( 'SLA::List::Active' )
      if sla_list == nil
        sla_list = Sla.where( active: true )
        Cache.write( 'SLA::List::Active', sla_list, { expires_in: 1.hour } )
      end
      sla_list.each {|sla|
        if !sla.condition || sla.condition.empty?
          sla_selected = sla
        elsif sla.condition
          hit = false
          map = [
            [ 'tickets.priority_id', 'priority_id' ],
            [ 'tickets.group_id', 'group_id' ]
          ]
          map.each {|item|
            if sla.condition[ item[0] ]
              if sla.condition[ item[0] ].class == String
                sla.condition[ item[0] ] = [ sla.condition[ item[0] ] ]
              end
              if sla.condition[ item[0] ].include?( self[ item[1] ].to_s )
                hit = true
              else
                hit = false
              end
            end
          }
          if hit
            sla_selected = sla
          end
        end
      }
      sla_selected
    end

    private

    #type could be:
    # real - time without supsend state
    # relative - only suspend time

    def escalation_suspend (start_time, end_time, type, sla_selected, sla_time = 0)
      if type == 'relative'
        end_time += sla_time * 60
      end
      total_time_without_pending = 0
      total_time = 0
      #get history for ticket
      history_list = self.history_get

      #loop through hist. changes and get time
      last_state            = nil
      last_state_change     = nil
      last_state_is_pending = false
      history_list.each { |history_item|

        # ignore if it isn't a state change
        next if !history_item['attribute']
        next if history_item['attribute'] != 'state'

        # ignore all newer state before start_time
        next if history_item['created_at'] < start_time

        # ignore all older state changes after end_time
        next if last_state_change && last_state_change > end_time

        # if created_at is later then end_time, use end_time as last time
        if history_item['created_at'] > end_time
          history_item['created_at'] = end_time
        end

        # get initial state and time
        if !last_state
          last_state        = history_item['value_from']
          last_state_change = start_time
        end

        # check if time need to be counted
        counted = true
        if history_item['value_from'] == 'pending reminder'
          counted = false
        elsif history_item['value_from'] == 'close'
          counted = false
        end

        diff = escalation_time_diff( last_state_change, history_item['created_at'], sla_selected )
        if counted
          # puts "Diff count #{history_item['value_from']} -> #{history_item['value_to']} / #{last_state_change} -> #{history_item['created_at']}"
          total_time_without_pending = total_time_without_pending + diff
        else
        # puts "Diff not count #{history_item['value_from']} -> #{history_item['value_to']} / #{last_state_change} -> #{history_item['created_at']}"
        end
        total_time = total_time + diff

        if history_item['value_to'] == 'pending reminder'
          last_state_is_pending = true
        else
          last_state_is_pending = false
        end

        # remember for next loop last state
        last_state        = history_item['value_to']
        last_state_change = history_item['created_at']
      }

      # if last state isnt pending, count rest
      if !last_state_is_pending && last_state_change && last_state_change < end_time
        diff = escalation_time_diff( last_state_change, end_time, sla_selected )
        # puts "Diff count last state was not pending #{diff.to_s} - #{last_state_change} - #{end_time}"
        total_time_without_pending = total_time_without_pending + diff
        total_time = total_time + diff
      end

      # if we have not had any state change
      if !last_state_change
        diff = escalation_time_diff( start_time, end_time, sla_selected )
        # puts 'Diff state has not changed ' + diff.to_s
        total_time_without_pending = total_time_without_pending + diff
        total_time = total_time + diff
      end

      #return sum
      if type == 'real'
        return total_time_without_pending
      elsif type == 'relative'
        relative = total_time - total_time_without_pending
        return relative
      else
        raise "ERROR: Unknown type #{type}"
      end
    end

    def escalation_time_diff( start_time, end_time, sla_selected )
      if sla_selected
        diff = TimeCalculation.business_time_diff( start_time, end_time, sla_selected.data, sla_selected.timezone)
      else
        diff = TimeCalculation.business_time_diff( start_time, end_time )
      end
      diff
    end

    def calculation_higher_time(escalation_time, check_time, done_time)
      return escalation_time if done_time
      return check_time if !escalation_time
      return escalation_time if !check_time
      return check_time if escalation_time > check_time
      return escalation_time
    end
  end
end