class ASF::MeetingUtil

# File lib/whimsy/asf/meeting-util.rb, line 279
def self.annotate_attendance(dir)
  attendance = JSON.parse(IO.read(File.join(dir, 'attendance.json')))
  memapps = read_memapps(dir)
  iclas = ASF::ICLA.preload
  memapp_map = JSON.parse(IO.read(File.join(dir, 'memapp-map.json')))
  attendance['cohorts'] = {}
  attendance['unmatched'] = []
  attendance['members'].each do |date, ary|
    next unless date.start_with? '20' # exclude 'active'
    ary.each do |nam|
      found = iclas.select{|i| i.icla.legal_name == nam}
      found = iclas.select{|i| i.icla.name == nam} if found.empty?
      if found.empty?
        if memapps.has_key?(nam)
          attendance['cohorts'][memapps[nam][0]] = date
        elsif memapp_map.has_key?(nam)
          attendance['cohorts'][memapp_map[nam]] = date
        else
          attendance['unmatched'] << nam
        end
      else
        attendance['cohorts'][found[0].icla.id] = date
      end
    end
  end
  File.open(File.join(dir, 'attendance-cohorts.json'), 'w') do |f| # Do not overwrite blindly; manual copy if desired
    f.puts JSON.pretty_generate(attendance)
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 459
def self.application_time_remaining
  meetingend = self.meeting_end # this is in seconds
  now = DateTime.now.to_time.to_i
  remain = (meetingend + APPLICATION_EXPIRY_POST_VOTE_SECS - now) / 3600
  {hoursremain: remain, days: remain.abs/24, hours: remain.abs%24}
end

# File lib/whimsy/asf/meeting-util.rb, line 476
def self.application_valid?(message_datetime)
  expirytime = self.meeting_end + APPLICATION_EXPIRY_POST_VOTE_SECS
  msgtime = DateTime.iso8601(message_datetime).to_time.to_i
  msgtime <= expirytime
end

# File lib/whimsy/asf/meeting-util.rb, line 469
def self.applications_valid
  self.application_time_remaining[:hoursremain] > 0
end

# File lib/whimsy/asf/meeting-util.rb, line 55
def self.calculate_quorum(mtg_dir)
  begin
    begin
      num_members = File.read(File.join(mtg_dir, 'record')).each_line.count
    rescue
      num_members = ASF::Member.list.length - ASF::Member.status.length
    end
    quorum_need = (num_members + 2) / 3
    num_proxies = Dir[File.join(mtg_dir, 'proxies-received', '*')].count
    attend_irc = quorum_need - num_proxies
    attend_irc = 0 if attend_irc < 0 # allow for more proxies than quorum
  rescue StandardError => e
    # Ensure we can't break rest of script
    puts "ERROR: #{e}"
    return 0, 0, 0, 0
  end
  return num_members, quorum_need, num_proxies, attend_irc
end

# File lib/whimsy/asf/meeting-util.rb, line 342
def self.current_status(cur_mtg_dir)
  proxies = Dir["#{cur_mtg_dir}/proxies-received/*"].
    map {|file| File.basename(file, '.*')}

  _tag,emeritus = ASF::SVN.getlisting('emeritus-requests-received')
  emeritus.map! {|file| File.basename(file, '.*')}

  lambda do |id|
    if emeritus.include? id
      'Emeritus request received'
    elsif proxies.include? id
      'Proxy received'
    else
      'No response'
    end
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 92
def self.getProxyAssignments(mtg_dir=nil)
  _, assignments = self.parseProxies(mtg_dir)
  hdr = assignments.shift
  # work out the column layout
  re = %r{^((\s+)<name>\s+)<name>}
  if hdr.match re
    total, offset = [$1.length, $2.length]
  else
    raise ArgumentError, "proxies: bad header '#{hdr}'"
  end
  assignments.map do |line|
    proxy = line[offset..total-1].strip
    if line[total..-1].strip.match %r{(.+) +\((.+)\)}
      proxied = $1
      uid = $2
    else
      raise ArgumentError, "proxies: bad assignment '#{line}'"
    end
    [proxy, proxied, uid]
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 115
def self.getProxyNominees(mtg_dir=nil)
  assignments = self.getProxyAssignments(mtg_dir)
  assignments.map do |line|
    line[0]
  end.uniq
end

# File lib/whimsy/asf/meeting-util.rb, line 85
def self.getVolunteers(mtg_dir=nil)
  volunteers, _ = self.parseProxies(mtg_dir)
  volunteers.each.filter_map {|line| l = line.strip; l if l.length > 0}
end

# File lib/whimsy/asf/meeting-util.rb, line 310
def self.get_attend_matrices(dir)
  attendance = MeetingUtil.get_attendance(dir)

  # extract and format dates
  dates = attendance['dates'].sort.
    map {|date| Date.parse(date).strftime('%Y-%b')}

  # compute mappings of names to ids
  members = ASF::Member.list
  active = Hash[members.select {|_id, data| not data['status']}]
  nameMap = Hash[members.map {|id, data| [id, data[:name]]}]
  idMap = Hash[nameMap.to_a.map(&:reverse)]

  # analyze attendance
  matrix = attendance['matrix'].map do |name, meetings|
    id = idMap[name]
    next unless id and active[id]

    # exclude 'active entry'
    data = meetings.select {|key, value| key.start_with? '20'}.
      sort.reverse.map(&:last)

    first = data.length
    missed = (data.index {|datum| datum != '-'} || data.length)

    [id, name, first, missed]
  end

  return attendance, matrix.compact, dates, nameMap
end

# File lib/whimsy/asf/meeting-util.rb, line 173
def self.get_attendance(mtg_root)
  return JSON.parse(IO.read(File.join(mtg_root, 'attendance.json')))
end

# File lib/whimsy/asf/meeting-util.rb, line 388
def self.get_invite_times()
  times = MeetingUtil.get_timeline(latest_meeting_dir)
  # Needs more work to reconcile recent changes to time calculations
  return { # TEMP HACK: return times in seconds, as per the original get_invite_times method.
    nominations_close:  DateTime.iso8601(times['nominations_close_iso']).to_time.to_i,
    polls_close: DateTime.iso8601(times['polls_close_iso']).to_time.to_i,
    meeting_start: DateTime.iso8601(times['meeting_start_iso']).to_time.to_i,
    meeting_end: DateTime.iso8601(times['meeting_end_iso']).to_time.to_i,
  }
end

# File lib/whimsy/asf/meeting-util.rb, line 401
def self.get_invite_times_ical
  times = {}
  File.readlines(File.join(latest_meeting_dir, VCAL_EVENTS_FILENAME)).slice_before(/^BEGIN:VEVENT/).drop(1).each do |ev|
    uid = nil
    dtstart = dtend = nil
    ev.each do |line|
      case line
        when /^UID:(.+)/
          uid = $1.chomp.sub(/-?\d{4}/, '')
        when /^DTSTART;TZID=(.+):(.+)/
          tz = $1
          if tz == 'UTC'
            dtstart = DateTime.iso8601($2.chomp).to_time.to_i
          else
            raise ArgumentError.new("Cannot parse #{line.chomp} in #{VCAL_EVENTS_FILENAME}")
          end
        when /^DTEND;TZID=(.+):(.+)/
          tz = $1
          if tz == 'UTC'
            dtend = DateTime.iso8601($2.chomp).to_time.to_i
          else
            raise ArgumentError.new("Cannot parse #{line.chomp} in #{VCAL_EVENTS_FILENAME}")
          end
      end
    end
    times[uid] = dtstart
    times['asf-members-end'] = dtend if uid == 'asf-members'
  end
  return {
    nominations_close: times['asf-members-nominations-close'],
    polls_close: times['asf-members-polls-close'],
    meeting_start: times['asf-members'],
    meeting_end: times['asf-members-end']
  }
end

# File lib/whimsy/asf/meeting-util.rb, line 163
def self.get_latest(mtg_root)
  return Dir[File.join(mtg_root, '2*')].max
end

# File lib/whimsy/asf/meeting-util.rb, line 154
def self.get_latest_completed(mtg_root, sentinel='raw-irc-log')
  return Dir[File.join(mtg_root, '2*')].select {|d| File.exist? File.join(d, sentinel) }.max
end

# File lib/whimsy/asf/meeting-util.rb, line 158
def self.get_latest_file(file='.', mtg_root=nil)
  return Dir[File.join(mtg_root || MEETINGS_DIR, '2???????', file)].max
end

# File lib/whimsy/asf/meeting-util.rb, line 168
def self.get_previous(mtg_root)
  return Dir[File.join(mtg_root, '2*')].sort[-2]
end

# File lib/whimsy/asf/meeting-util.rb, line 179
def self.get_timeline(mtg_root)
  begin
    return JSON.parse(IO.read(File.join(mtg_root, 'runbook', 'timeline.json')))
  rescue StandardError => e
    return "ERROR: get_timeline(#{mtg_root}) threw: #{e.message}"
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 126
def self.is_user_proxied(mtg_dir, id)
  proxylist = self.getProxyAssignments(mtg_dir)
  user = ASF::Person.find(id)
  help = nil
  copypasta = [] # theiravailid | Their Name in Rolls (proxy)
  max_uid_len = 16 # for alignment
  begin
    proxylist.each do |proxy, subject, uid|
      if user.cn == proxy
        copypasta << "#{uid.ljust(max_uid_len)} | #{subject} (proxy)"
      elsif user.id == uid
        help = "NOTE: You have already submitted a proxy form for #{proxy} to mark your attendance (be sure they know to mark you at Roll Call)! "
      end
    end
  rescue StandardError => e
    (help ||= '') << "ERROR, could not read LDAP, proxy data may not be correct: #{e.message}"
  end
  if copypasta.empty?
    return help
  else
    (help ||= '') << "During the meeting, to mark your proxies' attendance, AFTER logging into the ASFMM tool, click the top left Hamburger menu, Proxies button, and copy/paste the below lines to mark your proxies attendance."
    copypasta.unshift("#{user.id.ljust(max_uid_len)} | #{user.cn}")
    return help, copypasta
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 361
def self.latest_meeting_dir
  MeetingUtil.get_latest(MEETINGS_DIR)
end

# File lib/whimsy/asf/meeting-util.rb, line 450
def self.meeting_end
  self.get_invite_times[:meeting_end]
end

# File lib/whimsy/asf/meeting-util.rb, line 446
def self.meeting_start
  self.get_invite_times[:meeting_start]
end

# File lib/whimsy/asf/meeting-util.rb, line 438
def self.nominations_close
  self.get_invite_times[:nominations_close]
end

# File lib/whimsy/asf/meeting-util.rb, line 75
def self.parseProxies(mtg_dir=nil)
  mtg_dir ||= latest_meeting_dir
  lines = IO.readlines(File.join(mtg_dir, PROXIES_FILENAME))
  parts = lines.slice_before(%r{^(Volunteers|Assignments):}).drop(1)
  volunteers = parts.shift.drop(3) # heading
  assignments = parts.shift.drop(4)
  return volunteers, assignments
end

# File lib/whimsy/asf/meeting-util.rb, line 213
def self.parse_memapp(path=nil,header=false)
  path ||= get_latest_file('memapp-received.txt')
  text = File.read(path)
  # latest layout; look for at least one yes column; trim the user name
  list = text.scan(/^(no|yes)\s+(no|yes)(?:\s+(no|yes)\s+(no|yes))?\s+(\S+)\s+(.+)/).each {|a| a.last.strip!}
  if header
    hdr = text.split(/\R/)[0..1] # Assume 2 line header
    # Assume 6 columns for now
    hyphens=hdr[1].scan(/^(--+ +)(---+ +)(---+ +)(---+ +)(---+ +)(----+ *)$/).first
    hyphens.pop # drop last; don't want to pad that
    fmt = [hyphens.map{|h| '%%-%ds' % (h.size - 1)},'%s'].join(' ')
    return [list, hdr, fmt]
  else
    return list
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 245
def self.parse_memapp_to_h(path=nil,header=false)
  keys = %i(invite apply mail karma id name)
  res = self.parse_memapp(path, header)
  if header
    list, hdr, fmt = res # split the response
    return [list.map{|entry| keys.zip(entry).to_h}, hdr, fmt, keys]
  else
    return res.map{|entry| keys.zip(entry).to_h}
  end
end

# File lib/whimsy/asf/meeting-util.rb, line 442
def self.polls_close
  self.get_invite_times[:polls_close]
end

# File lib/whimsy/asf/meeting-util.rb, line 258
def self.read_memapps(dir)
  memapps = Hash.new('unknown')
  Dir[File.join(dir, '*', 'memapp-received.txt')].each do |received|
    meeting = File.basename(File.dirname(received))
    next if meeting.include? 'template'
    text = File.read(received)
    list = text.scan(/(.+)\s<(.*)@.*>.*Yes/i) # early layout
    if list.empty?
      # latest layout; look for at least one yes column
      list = text.scan(/^(?:no\s*)*(?:yes\s+)+(\w\S*)\s+(.*)\s*/)
    else
      # reverse order of id name type files
      list.each {|a| a[0], a[1] = a[1], a[0] }
    end
    list.each { |itm| memapps[itm[1].strip] = [itm[0], meeting] }
  end
  return memapps
end

# File lib/whimsy/asf/meeting-util.rb, line 366
def self.tracker(meetingsMissed)
  cur_mtg_dir = MeetingUtil.get_latest(MEETINGS_DIR)
  current_status = self.current_status(cur_mtg_dir)

  _attendance, matrix, dates, _nameMap = MeetingUtil.get_attend_matrices(MEETINGS_DIR)
  inactive = matrix.select do |id, _name, _first, missed|
    id and missed >= meetingsMissed
  end

  Hash[inactive.map {|id, name, first, missed|
    [id, {
      'name' => name,
      'missed' => missed,
      'status' => current_status[id],
      'since' => dates[-first-1] || dates.first,
      'last' => dates[-missed-1]
    }]
  }]
end