class Sessions::Backend::TicketOverviewList
  def initialize( user, client = nil, client_id = nil, ttl = 6 )
    @user               = user
    @client             = client
    @client_id          = client_id
    @ttl                = ttl
    @last_change        = nil
    @last_ticket_change = nil
  end

  def load

    # get whole collection
    overviews = Ticket::Overviews.all(
      :current_user => @user,
    )
    result = []
    overviews.each { |overview|
      overview_data = Ticket::Overviews.list(
        :view         => overview.link,
        :current_user => @user,
        :array        => true,
      )
      data = { :list => overview_data, :index => overview }
      result.push data
    }

    # no data exists
    return if !result || result.empty?

    # no change exists
    return if @last_change == result

    # remember last state
    @last_change = result

    result
  end

  def client_key
    "as::load::#{ self.class.to_s }::#{ @user.id }::#{ @client_id }"
  end

  def push

    # check interval
    return if Sessions::CacheIn.get( self.client_key )

    # reset check interval
    Sessions::CacheIn.set( self.client_key, true, { :expires_in => @ttl.seconds } )

    # check if min one ticket has changed
    last_ticket_change = Ticket.latest_change
    return if last_ticket_change == @last_ticket_change
    @last_ticket_change = last_ticket_change

    # load current data
    items = self.load

    return if !items

    # push overviews
    results = []
    items.each { |item|

      overview_data = item[:list]

      assets = {}
      overview_data[:ticket_ids].each {|ticket_id|
        ticket = Ticket.find( ticket_id )
        assets = ticket.assets(assets)
      }

      # get groups
      group_ids = []
      Group.where( :active => true ).each { |group|
        group_ids.push group.id
      }
      agents = {}
      Ticket::ScreenOptions.agents.each { |user|
        agents[ user.id ] = 1
      }
      users = {}
      groups_users = {}
      groups_users[''] = []
      group_ids.each {|group_id|
        groups_users[ group_id ] = []
        Group.find(group_id).users.each {|user|
          next if !agents[ user.id ]
          groups_users[ group_id ].push user.id
          if !users[user.id]
            users[user.id] = User.find(user.id)
            assets = users[user.id].assets(assets)
          end
        }
      }

      if !@client
        result = {
          :event  => 'navupdate_ticket_overview',
          :data   => item[:index],
        }
        results.push result
      else

        @client.log 'notify', "push overview_list for user #{ @user.id }"

        # send update to browser
        @client.send({
          :data   => assets,
          :event  => [ 'loadAssets' ]
        })
        @client.send({
          :data   => {
            :view          => item[:index].link.to_s,
            :overview      => overview_data[:overview],
            :ticket_ids    => overview_data[:ticket_ids],
            :tickets_count => overview_data[:tickets_count],
            :bulk          => {
              :group_id__owner_id => groups_users,
              :owner_id           => [],
            },
          },
          :event => [ 'ticket_overview_rebuild' ],
        })
      end
    }
    return results if !@client
    nil
  end

end