# Show syndromes affecting units, including duration
# original author: drayath, edited by expwnent
=begin

show-unit-syndromes
===================
Show syndromes affecting units and the remaining and maximum duration, along
with (optionally) substantial detail on the effects.

Use one or more of the following options:

:help:                  Show the help message
:showall:               Show units even if not affected by any syndrome
:showeffects:           Show detailed effects of each syndrome
:showdisplayeffects:    Show effects that only change the look of the unit
:selected:              Show selected unit
:dwarves:               Show dwarves
:livestock:             Show livestock
:wildanimals:           Show wild animals
:hostile:               Show hostiles (e.g. invaders, thieves, forgotten beasts etc)
:world:                 Show all defined syndromes in the world
:export:                ``export:<filename>`` sends output to the given file, showing all
                        syndromes affecting each unit with the maximum and present duration.

=end

#TODO: When showing effects on a unit, show the actual change to the unit
#       E.g. if +150%, +500 strength show actual total bonus based on the unit stats.
# For this also need to know
#        how does size_delays affect the start/peak/end time
#        how does size_dilute affect the Severity, does it also affect the phy/mental stat adjustments?
#        how does peak affect the Severity, does it also affect the phy/mental stat adjustments?
#TODO: Add interaction info needs to display a bit more data, but the required structures are not yet decoded

#TODO: Several of the unk_xxx fields have been identified here, and can get some more by comparing the raws with the printed interaction and effect information. Pass these onto the dfhack guys.

def print_help()
  puts "Use one or more of the following options:"
  puts "    showall: Show units even if not affected by any syndrome"
  puts "    showeffects: shows detailed effects of each syndrome"
  puts "    showdisplayeffects: show effects that only change the look of the unit"
  puts "    ignorehiddencurse: Hides syndromes the user should not be able to know about (TODO)"
  puts "    selected: Show selected unit"
  puts "    dwarves: Show dwarves"
  puts "    livestock: Show livestock"
  puts "    wildanimals: Show wild animals"
  puts "    hostile: Show hostiles (e.g. invaders, thieves, forgotten beasts etc)"
  puts "    world: Show all defined syndromes in the world"
  puts "    export:<filename> Write the output to a file instead of the console."
  puts ""
  puts "Will show all syndromes affecting each units with the maximum and present duration."
end

class Output
  attr_accessor :fileLogger, :indent_level

  def initialize(filename)
    indent_level = ""
    if filename==nil
      @fileLogger = nil
    else
      @fileLogger = File.new(filename + ".html", "w")
      @fileLogger.puts("<html><body>")
    end
  end

  RED = "red"
  GREEN = "green"
  BLUE = "blue"
  DEFAULT = "black"
  HIGHLIGHT = "black\" size=\"+1"

  def colorize(text, color_code)
    if @fileLogger == nil
      return text
    else
      new_text = "<font color=\"#{color_code}\">#{text}</font>"
      if color_code == HIGHLIGHT
        new_text = "<b>" + new_text + "</b>"
      end

      return new_text
    end
  end

  def inactive(text)
    if @fileLogger == nil
      return "###" + text
    else
      return "<del>#{text}</del>"
    end
  end

  def indent()
    if @fileLogger == nil
      @indent_level = "#{@indent_level} - "
    else
      @fileLogger.puts("<ul>")
    end
  end

  def unindent()
    if @fileLogger == nil
      @indent_level = @indent_level.chomp(" - ")
    else
      @fileLogger.puts("</ul>")
    end
  end

  def break()
    if @fileLogger == nil
      puts("\n")
    else
      @fileLogger.puts("<hr/></br>")
    end
  end

  def close()
    if @fileLogger != nil
      @fileLogger.puts("</body></html>")
      @fileLogger.flush
      @fileLogger.close
      @fileLogger = nil
    end
  end

  def log(text, color=nil)
    if @fileLogger == nil
      puts("#{@indent_level}#{text}")
    elsif color==nil
      @fileLogger.puts(text+"<br/>")
    elsif @indent_level == ""
      @fileLogger.puts(colorize(text, color))
    else
      @fileLogger.puts("<li>" + colorize(text, color)+"</li>")
    end
  end
end

def get_mental_att(att_index)

  case att_index
  when 0
    return "Analytical Ability"
  when 1
    return "Focus"
  when 2
    return "Willpower"
  when 3
    return "Creativity"
  when 4
    return "Intuition"
  when 5
    return "Patience"
  when 6
    return "Memory"
  when 7
    return "Linguistics"
  when 8
    return "Spacial Sense"
  when 9
    return "Musicality"
  when 10
    return "Kinesthetic Sense"
  when 11
    return "Empathy"
  when 12
    return "Social Awareness"
  else
    return "Unknown"
  end
end

def get_physical_att(att_index)

  case att_index
  when 0
    return "strength"
  when 1
    return "agility"
  when 2
    return "toughness"
  when 3
    return "endurance"
  when 4
    return "recuperation"
  when 5
    return "disease resistance"
  else
    return "unknown"
  end
end

def get_effect_target(target)

  values = []

  limit = target.key.length - 1
  for i in (0..limit)

    if(target.mode[i].to_s() != "")

      items = ""

      #case target.mode[i].to_s()
      #when "BY_TYPE"
      #  item = "type("
      #when "BY_TOKEN"
      #  item = "token("
      #when "BY_CATEGORY"
      #  item = "category("
      #end

      if(target.key[i].to_s()!="")
        item = "#{item}#{target.key[i].to_s().capitalize()}"
      end

      if target.tissue[i].to_s() != "ALL"
        if(target.key[i].to_s()!="" and target.tissue[i].to_s()!="")
          item = "#{item}:"
        end

        if(target.tissue[i].to_s()!="")
          item = "#{item}#{target.tissue[i].to_s().capitalize()}"
        end
      end

      #item = item + ")"

      values.push(item)
    end

  end

  if values.length == 0 or (values.length == 1 and values[0] == "All")
    return ""
  else
    return ", target=" + values.join(", ")
  end
end

def get_att_pairs(values, percents, physical)

  items = []

  color = Output::DEFAULT

  limit = values.length - 1
  for i in (0..limit)
    if (values[i] != 0 or percents[i] != 100)

      if physical
        item = "#{get_physical_att(i)}("
      else
        item = "#{get_mental_att(i)}("
      end

      if(values[i]!=0)
        item = item + "%+d" % values[i]
      end

      if (values[i]!=0 and percents[i]!=100)
        item = item + ", "
      end

      if (percents[i]!=100 or values[i]==0)
        item = item + "%d" % percents[i] + "%"
      end

      item = item + ")"

      if color != Output::RED and values[i] >= 0 and percents[i] > 100
        color = Output::GREEN
      elsif values[i] <0 || percents[i] < 100
        color = Output::RED
      end

      items.push(item)
    end
  end

  return items.join(", "), color
end

def get_display_name(name, verb)
  if name != nil and name != ""
    return name.capitalize()
  end

  if verb == nil or verb == ""
    return "Mystery"
  end

  if verb.length > 100
    verb = verb.slice(0, 100).capitalize()
  end

  pos = verb.index(".")
  if pos == nil
    return verb.slice(0, verb.rindex(" ")).capitalize()
  else
    return verb.slice(0, pos).capitalize()
  end
end

def get_interaction(interaction)

  # name, USAGE_HINT, range, wait period are probably all we really want to show.

  #result = "a=#{interaction.unk_6c} b=#{interaction.unk_7c} c=#{interaction.unk_8c} d=#{interaction.unk_a8} e=#{interaction.unk_c4} f=#{interaction.unk_e4} "
  #result = result + "g=#{interaction.unk_e0} h=#{interaction.unk_e4} i=#{interaction.unk_100} j=#{interaction.unk_11c} k=#{interaction.unk_138} l=#{interaction.unk_154} "
  #result = result + "m=#{interaction.unk_170} n=#{interaction.unk_18c} o=#{interaction.unk_1a8} p=#{interaction.unk_1c4} q=#{interaction.unk_1e8} r=#{interaction.unk_25c} "
  #result = result + "s=#{interaction.unk_278}"

  interaction = interaction.interaction
  if interaction.adv_name == ""
    name = "mystery"
  else
    name = interaction.adv_name
  end

  return "ability=#{get_display_name(interaction.adv_name, interaction.verb_2nd)}, delay=#{interaction.wait_period}, actionType=TODO, range=TODO, maxTargets=TODO"
end

def get_effect_flags(flags)

  values = []

  if(flags.SIZE_DELAYS) then values.push("size delays") end
  if(flags.SIZE_DILUTES) then values.push("size dilutes") end
  if(flags.VASCULAR_ONLY) then values.push("vascular only") end
  if(flags.MUSCULAR_ONLY) then values.push("muscles only") end
  if(flags.RESISTABLE) then values.push("resistable") end
  if(flags.LOCALIZED) then values.push("localized") end

  return values.join(",")
end

def get_tag1_flags(logger, flags, add)

  values = []

  good = false
  bad = false

  if add
    good_color = Output::GREEN
    bad_color = Output::RED
  else
    good_color = Output::RED
    bad_color = Output::GREEN
  end

  if(flags.EXTRAVISION)
    values.push(logger.colorize("extravision", good_color))
    good = true
  end

  if(flags.OPPOSED_TO_LIFE)
    values.push(logger.colorize("attack the living", bad_color))
    bad = true
  end

  if(flags.NOT_LIVING)
    values.push(logger.colorize("undead", Output::DEFAULT))
  end

  if(flags.NOEXERT)
    values.push(logger.colorize("does not tire", good_color))
    good = true
  end

  if(flags.NOPAIN)
    values.push(logger.colorize("does not feel pain", good_color))
    good = true
  end

  if(flags.NOBREATHE)
    values.push(logger.colorize("does not breathe", good_color))
    good = true
  end

  if(flags.HAS_BLOOD)
    values.push(logger.colorize("has blood", Output::DEFAULT))
  end

  if(flags.NOSTUN)
    values.push(logger.colorize("can't be stunned", good_color))
    good = true
  end

  if(flags.NONAUSEA)
    values.push(logger.colorize("does not get nausea", good_color))
    good = true
  end

  if(flags.NO_DIZZINESS)
    values.push(logger.colorize("does not get dizzy", good_color))
    good = true
  end

  if(flags.NO_FEVERS)
    values.push(logger.colorize("does not get fever", good_color))
    good = true
  end

  if(flags.TRANCES)
    values.push(logger.colorize("can enter trance", good_color))
    good = true
  end

  if(flags.NOEMOTION)
    values.push(logger.colorize("feels no emotion", good_color))
    good = true
  end

  if(flags.LIKES_FIGHTING)
    values.push(logger.colorize("like fighting", Output::DEFAULT))
  end

  if(flags.PARALYZEIMMUNE)
    values.push(logger.colorize("can't be paralyzed", good_color))
    good = true
  end
  if(flags.NOFEAR)
    values.push(logger.colorize("does not feel fear", good_color))
    good = true
  end

  if(flags.NO_EAT)
    values.push(logger.colorize("does not eat", good_color))
    good = true
  end

  if(flags.NO_DRINK)
    values.push(logger.colorize("does not drink", good_color))
    good = true
  end

  if(flags.NO_SLEEP)
    values.push(logger.colorize("does not sleep", good_color))
    good = true
  end
  if(flags.MISCHIEVOUS)
    values.push(logger.colorize("mischievous", Output::DEFAULT))
  end

  if(flags.NO_PHYS_ATT_GAIN)
    values.push(logger.colorize("physical stats cant improve", good_color))
    good = true
  end

  if(flags.NO_PHYS_ATT_RUST)
    values.push(logger.colorize("physical stats do not rust", good_color))
    good = true
  end

  if(flags.NOTHOUGHT)
    values.push(logger.colorize("stupid", bad_color))
    bad = true
  end

  if(flags.NO_THOUGHT_CENTER_FOR_MOVEMENT)
    values.push(logger.colorize("no brain needed to move", good_color))
    good = true
  end

  if(flags.CAN_SPEAK)
    values.push(logger.colorize("can speak", good_color))
    good = true
  end

  if(flags.CAN_LEARN)
    values.push(logger.colorize("can learn", good_color))
    good = true
  end

  if(flags.UTTERANCES)
    values.push(logger.colorize("utterances", Output::DEFAULT))
  end

  if(flags.CRAZED)
    values.push(logger.colorize("crazed", bad_color))
    bad = true
  end

  if(flags.BLOODSUCKER)
    values.push(logger.colorize("drinks blood", bad_color))
    bad = true
  end

  if(flags.NO_CONNECTIONS_FOR_MOVEMENT)
    values.push(logger.colorize("can move without nerves", good_color))
    good = true
  end

  if(flags.SUPERNATURAL)
    values.push(logger.colorize("supernatural", good_color))
    good = true
  end

  if add
    if bad
      color = Output::RED
    elsif good
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  else
    if good
      color = Output::RED
    elsif bad
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  end

  return values.join(", "), color
end

def get_tag2_flags(logger, flags, add)
  values = []

  good = false
  bad = false

  if add
    good_color = Output::GREEN
    bad_color = Output::RED
  else
    good_color = Output::RED
    bad_color = Output::GREEN
  end

  if(flags.NO_AGING)
    good = true
    values.push(logger.colorize("does not age", good_color))
  end

  if(flags.MORTAL)
    bad = true
    values.push(logger.colorize("mortal", bad_color))
  end

  if(flags.STERILE)
    values.push(logger.colorize("can't have children", Output::DEFAULT))
  end

  if(flags.FIT_FOR_ANIMATION)
    values.push(logger.colorize("can be animated", Output::DEFAULT))
  end

  if(flags.FIT_FOR_RESURRECTION)
    good = true
    values.push(logger.colorize("can be resurrected", Output::DEFAULT))
  end

  if add
    if bad
      color = Output::RED
    elsif good
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  else
    if good
      color = Output::RED
    elsif bad
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  end

  return values.join(", "), color
end

def find_creature_name(id, casteid)
  creature = df.world.raws.creatures.all.find{ |c| c.creature_id == id }

  if creature == nil
    return id, casteid
  end

  creature_name = creature.name[0].capitalize()

  if casteid == "DEFAULT"
    return creature_name, ""
  end

 caste = creature.caste.find{ |c| c.caste_id == casteid }

  if caste == nil
    return creature_name, casteid
  elsif creature.name[0].downcase() == caste.caste_name[0].downcase()
    return creature_name, ""
  else
    castename = caste.caste_name[0].downcase().chomp(creature.name[0].downcase()).strip()

    if castename.start_with?(creature.name[0])
      castename = castename.slice(creature.name[0].length, castename.length - creature.name[0].length).strip()
    end

    if castename.start_with?("of the")
      castename = castename.slice("of the".length, castename.length - "of the".length).strip()
    end

    return creature_name, castename.downcase()
  end
end

def get_effect(logger, ce, ticks, showdisplayeffects)

  flags = get_effect_flags(ce.flags)
  if flags != ""
    flags = " (#{flags})"
  end

  if ce.end == -1
    duration = " [permanent]"
  elsif ce.start >= ce.peak or ce.peak <= 1
    duration = " [#{ce.start}-#{ce.end}]"
  else
    duration = " [#{ce.start}-#{ce.peak}-#{ce.end}]"
  end

  case ce.getType().to_s()
  when "PAIN"
    name = "Pain"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "SWELLING"
    name = "Swelling"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "OOZING"
    name = "Oozing"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "BRUISING"
    name = "Bruising"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "BLISTERS"
    name = "Blisters"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "NUMBNESS"
    name = "Numbness"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::GREEN
  when "PARALYSIS"
    name = "Paralysis"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "FEVER"
    name = "Fever"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "BLEEDING"
    name = "Bleeding"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "COUGH_BLOOD"
    name = "Cough Blood"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "VOMIT_BLOOD"
    name = "Vomit Blood"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "NAUSEA"
    name = "Nausea"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "UNCONSCIOUSNESS"
    name = "Unconsciousness"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "NECROSIS"
    name = "Necrosis"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "IMPAIR_FUNCTION"
    name = "Impairs"
    desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
    color = Output::RED
  when "DROWSINESS"
    name = "Drowsiness"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "DIZZINESS"
    name = "Dizziness"
    desc = "power=#{ce.sev}"
    color = Output::RED
  when "ADD_TAG"
    name = "Add"
    tags1 = get_tag1_flags(logger, ce.tags1, true)
    tags2 = get_tag2_flags(logger, ce.tags2, true)
    desc = "#{tags1[0]},#{tags2[0]}"

    if tags1[1] == Output::RED || tags2[1] == Output::RED
      color = Output::RED
    elsif tags1[1] == Output::GREEN || tags2[1] == Output::GREEN
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  when "REMOVE_TAG"
    name = "Remove"
    tags1 = get_tag1_flags(logger, ce.tags1, true)
    tags2 = get_tag2_flags(logger, ce.tags2, true)
    desc = "#{tags1[0]},#{tags2[0]}"

    if tags1[1] == Output::RED || tags2[1] == Output::RED
      color = Output::RED
    elsif tags1[1] == Output::GREEN || tags2[1] == Output::GREEN
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end
  when "DISPLAY_TILE"
    if !showdisplayeffects then return "", Output::DEFAULT end
    name = "Tile"
    desc = "Tile=#{ce.tile}, Colour=#{ce.color}"
    color = Output::DEFAULT
  when "FLASH_TILE"
    if !showdisplayeffects then return "", Output::DEFAULT end
    name = "Flash"
    color = ce.sym_color[1]
    tile = ce.sym_color[0]
    desc = "tile = #{tile}, colour=#{color}, time=#{ce.period}, period=#{ce.time}"
    color = Output::DEFAULT
  when "SPEED_CHANGE"
    name = "Physical"
    desc = "speed("

    value = ce.bonus_add
    percent = ce.bonus_perc
    if(value!=0)
      desc = desc + "%+d" % value
    end

    if (value!=0 and percent!=100)
      desc = desc + ", "
    end

    if (percent!=100 or value==0)
      desc = desc + "%d" % percent + "%"
    end

    desc = desc + ")"

    if value < 0 or percent < 100
      color = Output::RED
    elsif value >0 or percent >100
      color = Output::GREEN
    else
      color = Output::DEFAULT
    end

  when "CAN_DO_INTERACTION"
    name = "Add interaction"
    desc = get_interaction(ce).to_s
    color = Output::GREEN
  when "SKILL_ROLL_ADJUST"
    name = "Skill check"
    desc = "modifier=#{ce.multiplier}%, chance=#{ce.chance}%"

    if ce.multiplier > 100
      color = Output::GREEN
    elsif ce.multiplier < 100
      color = Output::RED
    else
      color = Output::DEFAULT
    end

  when "BODY_TRANSFORMATION"
    name = "Transformation"

    if ce.chance > 0
      chance = ", chance=#{ce.chance} "
    else
      chance = ""
    end

    creature_name = find_creature_name(ce.race_str, ce.caste_str)

    if creature_name[1] == ""
        desc = "#{creature_name[0]}#{chance}"
    else
        desc = "#{creature_name[0]}(#{creature_name[1]})#{chance}"
    end

    color = Output::BLUE
  when "PHYS_ATT_CHANGE"
    name = "Physical"
    data = get_att_pairs(ce.phys_att_add, ce.phys_att_perc, true)
    desc = data[0]
    color = data[1]
  when "MENT_ATT_CHANGE"
    name = "Mental"
    data = get_att_pairs(ce.ment_att_add, ce.ment_att_perc, false)
    desc = data[0]
    color = data[1]
  when "MATERIAL_FORCE_MULTIPLIER"
    name = "Material force multiplier"
    desc = "received damage scaled by #{(ce.fraction_mul * 100 / ce.fraction_div * 100)/100}%"
    if ce.fraction_div > ce.fraction_mul
      color = Output::GREEN
    elsif ce.fraction_div < ce.fraction_mul
      color = Output::RED
    else
      color = Output::DEFAULT
    end

    if ce.mat_index >=0
        mat = df.decode_mat(ce.mat_type, ce.mat_index )
    elsif ce.mat_type >= 0
        mat = df.decode_mat(ce.mat_type, 0 )
    else
        mat = nil
    end

    if mat!= nil
      token = mat.token
      if token.start_with?("INORGANIC:")
        token = token.slice("INORGANIC:".length, token.length - "INORGANIC:".length)
      end

      desc = "#{desc} vs #{token.capitalize()}"
    end

  when "BODY_MAT_INTERACTION"
    # interactionId, SundromeTriggerType
    name = "Body material interaction"
    desc = "a???=#{ce.unk_6c}, b???=#{ce.unk_88}, c???=#{ce.unk_8c}, d???=#{ce.unk_90}, e???=#{ce.unk_94}"
    color = Output::DEFAULT
  when "BODY_APPEARANCE_MODIFIER"
    if !showdisplayeffects then return "", Output::DEFAULT end
    # !!! seems to be missing info class !!!
    # should be enum and value
    name = "Body Appearance"
    desc = "<TODO>"
    color = Output::DEFAULT
  when "BP_APPEARANCE_MODIFIER"
    if !showdisplayeffects then return "", Output::DEFAULT end
    name = "Body part appearance"
    desc = "value=#{ce.value} change_type_enum?=#{ce.unk_6c}#{get_effect_target(ce.target)}"
    color = Output::DEFAULT
  when "DISPLAY_NAME"
    if !showdisplayeffects then return "", Output::DEFAULT end
    name = "Set display name"
    desc = ce.name.to_s
    color = Output::DEFAULT
  else
    name = "Unknown"
    color = Output::HIGHLIGHT
  end

  text = "#{name}#{duration}#{flags} #{desc}"
  if ticks > 0 and ((ce.start > 0     and ticks < ce.start)     or (ce.end > 0     and ticks > ce.end))
    text = logger.inactive(text)
  end

  return text, color
end

print_syndrome = lambda { |logger, syndrome, showeffects, showdisplayeffects|
  rawsyndrome = df.world.raws.syndromes.all[syndrome.type]
  duration = rawsyndrome.ce.minmax_by{ |ce| ce.end }

  if duration[0].end == -1
    durationStr = "permanent"
  else
    if duration[0].end == duration[1].end
      durationStr = "#{syndrome.ticks} of #{duration[0].end}"
    else
      durationStr = "#{syndrome.ticks} of #{duration[0].end}-#{duration[1].end}"
    end
  end

  effects = rawsyndrome.ce.collect { |effect| get_effect(logger, effect, syndrome.ticks, showdisplayeffects) }

  if effects.any?{ |text, color| color==Output::RED }
    color = Output::RED
  elsif effects.any?{|text, color| color==Output::GREEN }
    color = Output::GREEN
  else
    color = Output::DEFAULT
  end

  logger.indent()
  logger.log "#{get_display_name(rawsyndrome.syn_name, "")} [#{durationStr}]", color

  if showeffects
    logger.indent()
    effects.each{ |text, color| if text!="" then logger.log text, color end }
    logger.unindent()
  end
  logger.unindent()
}

print_raw_syndrome = lambda { |logger, rawsyndrome, showeffects, showdisplayeffects|

  effects = rawsyndrome.ce.collect { |effect| get_effect(logger, effect, -1, showdisplayeffects) }

  if effects.any?{ |item| item[1]==Output::RED }
    color = Output::RED
  elsif effects.any?{|item| item[1]==Output::GREEN }
    color = Output::GREEN
  else
    color = Output::DEFAULT
  end

  logger.indent()
  logger.log get_display_name(rawsyndrome.syn_name, ""), color

  if showeffects
    logger.indent()
    effects.each{ |text, color| if text!="" then logger.log text, color end }
    logger.unindent()
  end
  logger.unindent()
}

print_syndromes = lambda { |logger, unit, showrace, showall, showeffects, showhiddencurse, showdisplayeffects|

  if showhiddencurse
    syndromes = unit.syndromes.active
  else
    syndromes = unit.syndromes.active
    # TODO: syndromes = unit.syndromes.active.select{ |s| visible_syndrome?(unit, s) }
  end

  if !syndromes.empty? or showall
    if showrace
      logger.log "#{df.world.raws.creatures.all[unit.race].name[0]}#{unit.name == '' ? "" : ": "}#{unit.name}", Output::HIGHLIGHT
    else
      logger.log unit.name.to_s, Output::HIGHLIGHT
    end
  end

  syndromes.each { |syndrome| print_syndrome[logger, syndrome, showeffects, showdisplayeffects] }
}

def starts_with?(str, prefix)
  prefix = prefix.to_s
  str[0, prefix.length] == prefix
end

showall = false
showeffects = false
selected = false
dwarves = false
livestock = false
wildanimals = false
hostile = false
world = false
showhiddencurse = false
showdisplayeffects = false

if $script_args.any?{ |arg| arg == "help" or arg == "?" or arg == "-?" }
  print_help()
elsif $script_args.empty?
  dwarves = true
  showeffects = true
else
  if $script_args.any?{ |arg| arg == "showall" } then showall=true end
  if $script_args.any?{ |arg| arg == "showeffects" } then showeffects=true end
  if $script_args.any?{ |arg| arg == "ignorehiddencurse" } then showhiddencurse=true end
  if $script_args.any?{ |arg| arg == "showdisplayeffects" } then showdisplayeffects=true end
  if $script_args.any?{ |arg| arg == "selected" } then selected=true end
  if $script_args.any?{ |arg| arg == "dwarves" } then dwarves=true end
  if $script_args.any?{ |arg| arg == "livestock" } then livestock=true end
  if $script_args.any?{ |arg| arg == "wildanimals" } then wildanimals=true end
  if $script_args.any?{ |arg| arg == "hostile" } then hostile=true end
  if $script_args.any?{ |arg| arg == "world" } then world=true end
  if $script_args.any?{ |arg| starts_with?(arg, "export:") }
    exportfile = $script_args.find{ |arg| starts_with?(arg, "export:") }.gsub("export:", "")
    export=true
  end
end

if export
  logger = Output.new(exportfile)
else
  logger = Output.new(nil)
end

if selected
  print_syndromes[logger, df.unit_find(), true, showall, showeffects, showhiddencurse, showdisplayeffects]
  logger.break()
end

if dwarves
  logger.log "Dwarves", Output::HIGHLIGHT
  df.unit_citizens.each { |unit|
    print_syndromes[logger, unit, false, showall, showeffects, showhiddencurse, showdisplayeffects]
  }
  logger.break()
end

if livestock
  logger.log "Livestock", Output::HIGHLIGHT
  df.world.units.active.find_all { |u| df.unit_category(u) == :Livestock }.each { |unit|
    print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
  }
  logger.break()
end

if wildanimals
  logger.log "Wild animals", Output::HIGHLIGHT
  df.world.units.active.find_all { |u| df.unit_category(u) == :Other and  df.unit_other_category(u) == :Wild }.each { |unit|
    print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
  }
  logger.break()
end

if hostile
  logger.log "Hostile units", Output::HIGHLIGHT
  df.unit_hostiles.each { |unit|
    print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
  }
  logger.break()
end

if world
  logger.log "All syndromes", Output::HIGHLIGHT
  df.world.raws.syndromes.all.each { |syndrome| print_raw_syndrome[logger, syndrome, showeffects, showdisplayeffects]    }
end

logger.close()
