elemental shaman upgrade evaluator

# upgrade evaluater
# usage: -b baseitems -u upgrade-items

require 'net/http'
require 'rexml/document'
$maxhit = 5200
$t_start = Time.now
$baseIDs = []
$upgradeIDs = []
$mhID = 0
$ohID = 0
#statweights
$w = Hash["int" => 4.42, "splpwr" => 3.47, "spi" => 5.05, "hit" => 5.05, "haste" => 2.47, "mastery" => 2.31, "crit" => 1.98]    # oxi 20130430

#--------------------------------------------------------------------------------
#
# setup character professions (NYI)
#
#--------------------------------------------------------------------------------
$profs = {
    "alc" => 0, # alchemy (not relevant for simcraft?)
    "bla" => 1, # blacksmithing (prismatic sockets on wrists and hands)
    "enc" => 1, # enchanting (160 int enchant on rings
    "eng" => 0, # engineering (synapse springs on hands)
    "her" => 0, # herbalism (not relevant for simcraft?)
    "ins" => 0, # inscription (520 int, 100 crit on shoulders)
    "jew" => 0, # jewelcrafting NYI
    "lea" => 0, # leatherworking (500 int on wrists)
    "min" => 0, # mining
    "ski" => 0, # skinning
    "tai" => 0  # tailoring (lightweave emroidery on back)
}
$wrathion_weapon_socket = true
$wrathion_meta = false

def timedMsg(msg)
    time = Time.now-$t_start
    time = "%010.4f" % time
    puts time + " " + msg
end

#--------------------------------------------------------------------------------
#
# parse options
#
#--------------------------------------------------------------------------------
while ARGV.length >= 2 do
    switch = ARGV.shift
    case switch
    when "-b"
        while (ARGV.length > 0) and (ARGV[0][0] != "-") do
            $baseIDs.push(ARGV.shift.to_i)
        end
    when "-u"
        while (ARGV.length > 0) and (ARGV[0][0] != "-") do
            $upgradeIDs.push(ARGV.shift.to_i)
        end
    when "-mh"  # mainhand to use when evaluating upgrading from a two-hand weapon
        $mhID = ARGV.shift.to_i
    when "-oh"  # offhand to use when evaluating upgrading from a two-hand weapon
        $ohID = ARGV.shift.to_i
    else
        puts "unkown option\"#{switch}\""
        puts "usage: <-b itemIDs> <-u itemIDs> [-mh itemID] [-oh itemID]"
        puts "-b <itemIDs> your current gear as itemIDs, separated by spaces"
        puts "-u <itemIDs> available upgrades, separated by spaces"
        puts "-mh <itemID> main-hand to use when wearing a two-hander and evaluating an off_hand"
        puts "-oh <itemID> off-hand to use when wearing a two-hander and evaluating a main_hand"
    end
end

#--------------------------------------------------------------------------------
#
# statweights
#
#--------------------------------------------------------------------------------
#puts "#{Time.now-$t_start} setting up gems & statweights"
# $w = Hash["int" => 4.64, "splpwr" => 3.66, "spi" => 5.23, "hit" => 5.23, "haste" => 2.51, "mastery" => 2.36, "crit" => 2.29]  #t15hc bis
$w = Hash["int" => 4.42, "splpwr" => 3.47, "spi" => 5.05, "hit" => 5.05, "haste" => 2.47, "mastery" => 2.31, "crit" => 1.98]    # oxi 20130430
$wnh = $w.dup   # statweights without hit/spi
$wnh["spi"] = 0
$wnh["hit"] = 0

#--------------------------------------------------------------------------------
#
# setup stat prios for reforging
#
#--------------------------------------------------------------------------------
timedMsg("setting up gems")
$nonhitrefstats = Hash["mastery" => $w["mastery"], "haste" => $w["haste"], "crit" => $w["crit"]]
$nonhitrefstats = $nonhitrefstats.sort_by {|_key, value| value}
$high, $medium, $low = $nonhitrefstats[2][0], $nonhitrefstats[1][0], $nonhitrefstats[0][0]


#--------------------------------------------------------------------------------
#
# setup stat prios for reforging
#
#--------------------------------------------------------------------------------
$gemsByColor = {
    "r" => [
        [
            "160int",
            160*$w["int"],
            160*$wnh["int"],
            Hash["int" => 160],
            0
        ],
        [
            "80int_160#{$high}",
            80*$w["int"]+160*$w[$high],
            80*$wnh["int"]+160*$wnh[$high],
            Hash["int" => 80, $high => 160],
            0
        ]
    ],
    "y" => [
        [
            "80int_160#{$high}",
            80*$w["int"]+160*$w[$high],
            80*$wnh["int"]+160*$wnh[$high],
            Hash["int" => 80, $high => 160],
            1
        ],
        [
            "320#{$high}",
            320*$w[$high],
            320*$wnh[$high],
            Hash[$high => 320],
            1
        ]
    ],
    "b" => [
        [
            "80int_160spi",
            80*$w["int"]+160*$w["spi"],
            80*$wnh["int"]+160*$wnh["spi"],
            Hash["int" => 80, "spi" => 160],
            2
        ],
        [
            "160#{$high}_160spi",
            160*$w[$high]+160*$w["spi"],
            160*$wnh[$high]+160*$wnh["spi"],
            Hash[$high => 160, "spi" => 160],
            2
        ]
    ]
}
if $wration_meta then
    $gemsByColor["m"] = [[
        "sinister_primal",
        324*$w["crit"],
        324*$w["crit"],
        Hash["crit" => 324],
        3
    ]]
else
    $gemsByColor["m"] = [[
        "burning_primal",
        216*$w["int"],
        216*$w["int"],
        Hash["int" => 216],
        3
    ]]
end
$gemsByColor.each do |sc|
    sc[1].each do |gem|
        sc[1].sort!{ |a,b| b[1] <=> a[1] }
    end
end
$allgems = $gemsByColor["r"] + $gemsByColor["y"] + $gemsByColor["b"]
$allgems.sort!{ |a,b| b[2] <=> a[2]}
$gemcols = ["red","yellow","blue","meta","prismatic"]
$maxgemcol = $allgems[0][4]
$gems = [$gemsByColor["r"][0][0],$gemsByColor["y"][0][0],$gemsByColor["b"][0][0],$gemsByColor["m"][0][0],$allgems[0][0]]
$gemval = [$gemsByColor["r"][0][1],$gemsByColor["y"][0][1],$gemsByColor["b"][0][1],$gemsByColor["m"][0][1],$allgems[0][1]]
$gemstats = [$gemsByColor["r"][0][3],$gemsByColor["y"][0][3],$gemsByColor["b"][0][3],$gemsByColor["m"][0][3],$allgems[0][3]]
#$gems = ["160int","80int_160#{$high}","80int_160spi","sinister_primal","160int"]
#$gemval = [160 * $w["int"], 80 * $w["int"] + 160 * $w[$high], 80 * $w["int"] + 160 * $w["spi"], 324 * $w["crit"],160 * $w["int"]]
if $debug then
    (0..4).each do |i|
        puts "best #{$gemcols[i]} gem: #{$gems[i]} at #{$gemval[i]}"
    end
end


#--------------------------------------------------------------------------------
#
# setup classes for items and sets
#
#--------------------------------------------------------------------------------
timedMsg("setting up classes")
class Item
    def initialize(id, name, slot, int = 0, splpwr = 0, spi = 0, hit = 0, haste = 0, mastery = 0, crit = 0, sockets = nil)
        @id = id
        @name = name
        @slot = slot    #head,shoulder,back,chest,wrist,hands,waist,legs,feet,finger,trinket,main_hand,off_hand
        @basestats = Hash["int" => int, "splpwr" => splpwr, "spi" => spi, "hit" => hit, "haste" => haste, "mastery" => mastery, "crit" => crit]
        # setup gems
        @sockets = sockets  # array of skt colors, bonus value, bonus stat: 0 = red, 1 = yellow, 2 = blue, 3 = meta, 4 = prismatic
                            # [1, 2, 3, 180, "int"]
        @gembonus = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
        @gemstring = ""
        if @sockets then
            self.gem()
        end
        # setup enchants
        @enchantbonus = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
        @enchantstring = ""
        self.enchant()
        # setup reforging
        @reforges = []
        self.getRefs()
        @refindex = nil
        @refstring = ""
    end

    def getName
        out = @name
    end

    def getSimcName
        name = @name.gsub(" ", "_") # space to underscore
        name.gsub!("'", "")         # remove apostrophes
        name.gsub!(",", "")         # remove commata
        name.gsub!("-", "")         # remove dashes
        name.downcase!
    end

    def getID
        out = @id
    end

    def getSlot
        out = @slot
    end

    def getSpiHit()
        spihit = @basestats["spi"] + @basestats["hit"] + @gembonus["spi"] + @gembonus["hit"] + @enchantbonus["spi"] + @enchantbonus["hit"]# + @reforgebonus["spi"] + @reforgebonus["hit"]
    end

    def getReforgableSpiHit()
        out = @basestats["spi"] + @basestats["hit"]
    end

    def reforge()
        maxval = 0
        maxref = nil
        (0..@reforges.length-1).each do |r|
            self.setReforge(r)
            tempval = self.getValue
            if tempval > maxval then
                maxval = tempval
                maxref = r
            end
        end
        self.setReforge(maxref)
    end

    def getValue()
        value = 0
        stats = $w.keys
        stats.each do |s|
            # if (s != "spi") and (s != "hit") then
            value += @basestats[s] * $w[s]
            value += @gembonus[s] * $w[s]
            value += @enchantbonus[s] * $w[s]
            #value += @reforgebonus[s] * $w[s]
            # end
        end
        out = value
    end

    def getStats()
        itemstats = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
        stats = $w.keys
        stats.each do |s|
            itemstats[s] += @basestats[s]
            itemstats[s] += @gembonus[s]
            itemstats[s] += @enchantbonus[s]
            #itemstats[s] += @reforgebonus[s]
        end
        out = itemstats
    end

    def enchant()
        @enchantbonus.each do |k,v|
            @enchantbonus[k] = 0
        end
        case @slot
        when "shoulders"
            if $profs["ins"] == 1 then
                @enchantbonus["int"] += 520
                @enchantbonus["crit"] += 100
                enchantstring = ",enchant=520int_100crit"
            else
                @enchantbonus["int"] += 200
                @enchantbonus["crit"] += 100
                enchantstring = ",enchant=200int_100crit"
            end
        when "back"
            if $profs["tai"] == 1 then
                enchantstring = ",enchant=lightweave_embroidery_3"
            else
                @enchantbonus["int"] += 180
                enchantstring = ",enchant=180int"
            end
        when "chest"
            @enchantbonus["int"] += 80
            @enchantbonus["spi"] += 80
            enchantstring = ",enchant=80all"
        when "wrists"
            if $profs["lea"] == 1 then
                @enchantbonus["int"] += 500
                enchantstring = ",enchant=500int"
            else
                @enchantbonus["int"] += 180
                enchantstring = ",enchant=180int"
            end
        when "hands"
            @enchantbonus["haste"] += 170
            enchantstring = ",enchant=170haste"
            if $profs["eng"] == 1 then
                enchantstring = "#{enchantstring},addon=synapse_springs_mark_ii"
            end
        when "legs"
            @enchantbonus["int"] += 285
            @enchantbonus["spi"] += 165
            enchantstring = ",enchant=285int_165spi"
        when "feet"
            @enchantbonus["mastery"] += 140
            enchantstring = ",enchant=140mastery"
        when "finger"
            if $profs["enc"] == 1 then
                @enchantbonus["int"] += 160
                enchantstring = ",enchant=160int"
            end
        when "main_hand"
            enchantstring = ",enchant=jade_spirit"
        when "off_hand"
            @enchantbonus["int"] += 165
            enchantstring = ",enchant=165int"
        else
            enchantstring = ""
        end
        @enchantstring = enchantstring
    end

    def gem()
        if @sockets then
            @gembonus.each do |k,v|
                @gembonus[k] = 0
            end
            # calc matching value
            v_match = 0
            @sockets[0..-3].each do |s|
                v_match += $gemval[s]
            end
            v_match += @sockets[-2] * $w[@sockets[-1]]
            #puts "matching value: #{v_match}"
            # calc pure value
            v_pure = 0
            bonus = true
            @sockets[0..-3].each do |s|
                s != 3 ? v_pure += $gemval[4] : v_pure += $gemval[s]
                s != $maxgemcol ? bonus = false : nil
            end
            bonus ? v_pure += @sockets[-2] * $w[@sockets[-1]] : nil
            #puts "pure value: #{v_pure}"

            #construct gemstring
            gemstring = ",gems="
            bonus = true    # assume matching sockets
            if v_match >= v_pure then
                @sockets[0..-3].each do |s|
                    gemstring += "#{$gems[s]}_"
                    $gemstats[s].each do |k,v|
                        @gembonus[k] += v
                    end
                end
                @gembonus[@sockets[-1]] += @sockets[-2]
                gemstring += "#{@sockets[-2]}#{@sockets[-1]}_"
            else
                @sockets[0..-3].each do |s|
                    if s != 3 then
                        gemstring += "#{$gems[4]}_"
                        s != $maxgemcol ? bonus = false : nil
                        $gemstats[4].each do |k,v|
                            @gembonus[k] += v
                        end
                    else
                        gemstring += "#{$gems[s]}_"
                        $gemstats[s].each do |k,v|
                            @gembonus[k] += v
                        end
                    end
                end
                if bonus then
                    gemstring += "#{@sockets[-2]}#{@sockets[-1]}_"
                end
            end
            gemstring.chop!
            @gemstring = gemstring
        end
    end

    # def refSanity(s, t)
        # sensible = true
        # if ((t == "spi") or (t == "hit")) and ((@basestats["spi"] > 0) or (@basestats["hit"] > 0)) then sensible = false end

    # end

    def getRefs()
        hitstats = ["spi", "hit"]
        secstats = ["haste", "mastery", "crit"]
        secstats.sort!{|a,b| $w[b] <=> $w[a]}
        secmin = secstats.sort{|a,b| $w[a] <=> $w[b]}
        refs = Array.new
        sources, targets = Array.new, Array.new
        secstats.each do |s|
            @basestats[s] > 0 ? sources.push(s) : targets.push(s)
        end
        #get all refs that take hit/spi and turn it into sth else
        hitstats.each do |s|
            if @basestats[s] > 0 then
                amnt = (0.4*@basestats[s]).floor
                secstats.each do |t|
                    if @basestats[t] == 0 then
                        refs.push([s,t,amnt])
                        break
                    end
                end
            end
        end
        #get all refs from any stat to hit/spi if not on the item yet
        if (@basestats["spi"] == 0) and (@basestats["hit"] == 0) then
            secmin.each do |s|
                if @basestats[s] > 0 then
                    amnt = (0.4*@basestats[s]).floor
                    refs.push([s,"spi",amnt])
                    break
                end
            end
        end
        #get minsource to maxtarget
        secmin.each do |s|
            if @basestats[s] > 0 then
                amnt = (0.4*@basestats[s]).floor
                secstats.each do |t|
                    if (@basestats[t] == 0) and ($w[t] > $w[s]) then
                        refs.push([s,t,amnt])
                        break
                    end
                end
                break
            end
        end
        # add no-reforge option if applicable
        # only one stat, either spi, hit or highest sec
        numstats = 0
        (secstats+hitstats).each do |s|
            if @basestats[s] > 0 then
                numstats += 1
            end
        end
        if (numstats == 1) and ((@basestats["hit"] > 0) or (@basestats["spi"] > 0) or (@basestats[secstats[0]] > 0)) then
            refs.push(nil)
        elsif (numstats == 2) and (((@basestats["hit"] > 0) and (@basestats[secstats[0]] > 0)) or ((@basestats["spi"] > 0) and (@basestats[secstats[0]] > 0)) or ((@basestats[secstats[1]] > 0) and (@basestats[secstats[0]] > 0)))
            refs.push(nil)
        end
        if refs.length == 0 then
            refs.push(nil)
        end
        @reforges = refs
        out = refs
    end

    def setReforge(index)
        @refindex = index
        if @reforges[@refindex] != nil then
            @refstring =",reforge=#{@reforges[@refindex][0]}_#{@reforges[@refindex][1]}"
        else
            @refstring = ""
        end
    end

    def getRefIndex
        out = @refindex
    end

    def getReforge()
        out = @reforges[@refindex]
    end

    def getReforges()   #deprecated
        refstats = ["spi","hit","haste","mastery","crit"]
        refs = Array.new
        sources, targets = Array.new, Array.new
        refstats.each do |s|
            @basestats[s] > 0 ? sources.push(s) : targets.push(s)
        end
        if (sources.include?("spi") and sources.include?($high)) then
            refs.push(nil)
            refs.push(["spi",$medium])
        elsif (sources.include?("hit") and sources.include?($high)) then
            refs.push(nil)
            refs.push(["hit",$medium])
        elsif (sources.include?("spi") and sources.include?($medium)) then
            refs.push(["spi",$high])
            refs.push([$medium,$high])
        elsif (sources.include?("hit") and sources.include?($medium)) then
            refs.push(["hit",$high])
            refs.push([$medium,$high])
        elsif (sources.include?("spi") and sources.include?($low)) then
            refs.push(["spi",$high])
            refs.push([$low,$high])
        elsif (sources.include?("hit") and sources.include?($low)) then
            refs.push(["hit",$high])
            refs.push([$low,$high])
        elsif (sources.include?($high) and sources.include?($medium)) then
            refs.push(nil)
            refs.push([$medium,"spi"])
        elsif (sources.include?($high) and sources.include?($low)) then
            refs.push([$low,"spi"])
            refs.push([$low,$medium])
        elsif (sources.include?($medium) and sources.include?($low)) then
            refs.push([$low,"spi"])
            refs.push([$low,$high])
        elsif (sources.length == 1) then
            if sources.include?("spi") then
                refs.push(nil)
                refs.push(["spi",$high])
            elsif sources.include?("hit") then
                refs.push(nil)
                refs.push(["hit",$high])
            elsif sources.include?($high) then
                refs.push(nil)
                refs.push([$high,"spi"])
            elsif sources.include?($medium) then
                refs.push([$medium,"spi"])
                refs.push([$medium,$high])
            elsif sources.include?($low) then
                refs.push([$low,"spi"])
                refs.push([$low,$high])
            end
        else
            refs.push(nil)
        end
        # puts "sources: #{sources.to_s}"
        # puts "targets: #{targets.to_s}"
        # puts "refs: #{refs.to_s}"
    end

    def getNumReforges()
        out = @reforges.length
    end

    def to_s    # only for debugging
        out = "itemID\t\t#@id\nName\t\t#@name\nSlot\t\t#@slot\nBase Stats\nInt\t\t#{@basestats["int"]}\nSpellpower\t#{@basestats["splpwr"]}\nSpirit\t\t#{@basestats["spi"]}\nHit Rating\t#{@basestats["hit"]}\nHaste Rating\t#{@basestats["haste"]}\nMastery Rating\t#{@basestats["mastery"]}\nCrit Rating\t#{@basestats["crit"]}\nEnchant\t\t#@enchantstring\n\t\t#{@enchantbonus.to_s}\nGems\t\t#@gemstring\n\t\t#{@gembonus.to_s}\nReforge\t\t#{@reforgestring}\n\t\t#{@reforgebonus.to_s}"
    end

    def getSimc(slotnmbr = "")
        #clean up the item name
        name = @name.gsub(" ", "_") # space to underscore
        name.gsub!("'", "")         # remove apostrophes
        name.gsub!(",", "")         # remove commata
        name.gsub!("-", "")         # remove dashes
        name.downcase!

        out = "#@slot#{slotnmbr}=#{name},id=#@id#{@gemstring}#{@enchantstring}#{@refstring}"
    end
end

class ItemSet
    # $items = [$setslots, $neck, $back, $wrists, $waist, $feet, $fingers, $trinkets, $main_hand, $off_hand]
    # def initialize(head, neck, shoulders, back, chest, wrists, hands, waist, legs, feet, finger1, finger2, trinket1, trinket2, main_hand, off_hand)
        # @slots = [head, neck, shoulders, back, chest, wrists, hands, waist, legs, feet, finger1, finger2, trinket1, trinket2, main_hand, off_hand]
    # end
    def initialize(setItems)
        @slots = setItems.flatten
        @reforgebonus = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
    end

    def getSpiHit()
        spihit = 0
        @slots.each do |s|
            spihit += s.getSpiHit
        end
        spihit += @reforgebonus["spi"] + @reforgebonus["hit"]
        result = spihit
    end

    def getReforgableSpiHit()
        spihit = 0
        @slots.each do |s|
            spihit += s.getReforgableSpiHit
        end
        out = spihit
    end

    def to_s
        @slots.each do |s|
            out = s.to_s
        end
    end

    def getSimc
        temp = ""
        slotnmbr = 0
        f = 1
        t = 1
        @slots.each do |s|
            if s.getSlot == "finger" then
                nmbrstr = f.to_s
                f += 1
            elsif s.getSlot == "trinket" then
                nmbrstr = t.to_s
                t += 1
            else
                nmbrstr = ""
            end
            # case s.getSlot
            # when 2, 4
                # nmbrstr = "1"
            # when 3, 5
                # nmbrstr = "2"
            # else
                # nmbrstr = ""
            # end
            temp += "#{s.getSimc(nmbrstr)}\n"
            slotnmbr += 1
        end
        out = temp
    end

    def calcrefs(a, b)
        if a.length == 1 then
            a[0].each do |i|
                set = b.dup
                set.push(i)
                # do ref related stuff here
                # set reforges for all items
                (0..set.length-1).each do |index|
                    if @slots[index].getRefIndex != set[index] then
                        @slots[index].setReforge(set[index])
                    end
                end
                # reset reforgebonus to 0
                @reforgebonus = Hash["spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
                # recalculate reforgebonus
                @slots.each do |s|
                    ref = s.getReforge
                    if ref != nil then
                        @reforgebonus[ref[0]] -= ref[2]
                        @reforgebonus[ref[1]] += ref[2]
                    end
                end
                # check for hitcap
                if self.getSpiHit < $maxhit then
                    tempval = self.getValue
                    if tempval > @refmaxval then
                        @refmaxval = tempval
                        @refmaxref = set
                        @refmaxrefbonus = @reforgebonus
                    end
                end
            end
        else
            ta = a.dup
            fa = ta.shift
            fa.each do |i|
                tb = b.dup
                tb.push(i)
                calcrefs(ta, tb)
            end
        end
    end

    def reforge
        if $debug then mstart = Time.now end
        @refmaxval = 0
        @refmaxref = nil
        @refmaxrefbonus = nil
        refarr = []
        @slots.each do |s|
            refarr.push(Array(0..s.getNumReforges-1))
        end
        calcrefs(refarr, [])
        if @refmaxref == nil then
            #puts "#{Time.now-$t_start} can't reforge set to below #$maxhit hit"
        else
            (0..@slots.length-1).each do |s|
                @slots[s].setReforge(@refmaxref[s])
            end
            @reforgebonus = @refmaxrefbonus
        end
        if $debug then
            mend = Time.now
            dur = mend - mstart
            puts "ItemSet::reforge took #{dur} seconds"
        end
    end

    def getStats()
        totalStats = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
        @slots.each do |s|
            # puts s
            itemStats = s.getStats
            totalStats.keys.each do |k|
                totalStats[k] += itemStats[k]
            end
        end
        @reforgebonus.keys.each do |k|
            totalStats[k] += @reforgebonus[k]
        end
        out = totalStats
    end

    def getValue()
        # if $debug then mstart = Time.now end
        totalStats = Hash["int" => 0, "splpwr" => 0, "spi" => 0, "hit" => 0, "haste" => 0, "mastery" => 0, "crit" => 0]
        @slots.each do |s|
            # puts s
            itemStats = s.getStats
            totalStats.keys.each do |k|
                totalStats[k] += itemStats[k]
            end
        end
        @reforgebonus.keys.each do |k|
            totalStats[k] += @reforgebonus[k]
        end
        value = 0
        if (totalStats["spi"] + totalStats["hit"]).between?(5100,$maxhit) then
            totalStats.keys.each do |s|
                if (s != "spi") and (s != "hit") then
                    value += totalStats[s] * $w[s]
                end
            end
        end

        # if totalStats["spi"] + totalStats["hit"] > 5100 then
            # value -= (totalStats["spi"] + totalStats["hit"] - 5100) * $w["spi"]
        # end
        # if $debug then
            # mend = Time.now
            # dur = mend - mstart
            # puts "ItemSet::getValue took #{dur} seconds"
        # end
        out = value
    end
end

#--------------------------------------------------------------------------------
#
# load itembase from wowhead
#
#--------------------------------------------------------------------------------
def getWowheadData(itemarr)
    itemBase = Hash.new
    timedMsg("adding #{itemarr.length} items from wowhead")
    bonusTrans = {
        "Intellect" => "int",
        "Hit" => "hit",
        "Spirit" => "spi",
        "Haste" => "haste",
        "Mastery" => "mastery",
        "Critical Strike" => "crit"
    }
    socketTrans = {1 => 3, 2 => 0, 4 => 1, 8 => 2}
    slotTrans = {
        1 => "head",
        2 => "neck",
        3 => "shoulders",
        16 => "back",
        5 => "chest",
        9 => "wrists",
        10 => "hands",
        6 => "waist",
        7 => "legs",
        8 => "feet",
        11 => "finger",
        12 => "trinket",
        14 => "off_hand",
        23 => "off_hand",
        13 => "main_hand",
        17 => "two_hand"
    }
    itemarr.each do |itemID|
        #check if item already exists
        itemExists = false
        itemBase.keys.each do |key|
            itemBase[key].each do |i|
                if i.getID == itemID then
                    itemExists = true
                    timedMsg("Item #{itemID} already exists")
                end
            end
        end

        if itemExists == false then
            timedMsg("adding #{itemID}")
            # uri = URI("http://www.wowhead.com/item=#{itemID}&xml=1")
            # file = File.new("out.txt")

            doc = REXML::Document.new(Net::HTTP.get(URI("http://www.wowhead.com/item=#{itemID}&xml=1")))
            root = doc.root

            str = root.elements[1].elements["jsonEquip"].to_s
            str = str[20..-16]
            str.gsub!("\"","")
            arr = str.split(/[,:]/)
            #puts str + "\n"
            #puts arr.to_s
            hsh = Hash[*arr]
            #puts hsh.to_s
            #hit = hsh["hitrtng"].to_i

            tooltip = root.elements[1].elements["htmlTooltip"].to_s
            strSocketBonus = tooltip.match(/Socket Bonus: \+[0-9]+ [A-za-z ]+/).to_s
            bonusValue = strSocketBonus.match(/[0-9]+/).to_s
            bonusStat = strSocketBonus.match(/[0-9] [A-za-z ]+/).to_s[2..-1]
            #puts bonusValue
            #puts bonusStat
            #puts bonusTrans[bonusStat]

            id = itemID
            puts name = root.elements[1].elements["name"].to_s[15..-11]
            slot = root.elements[1].elements["inventorySlot"].attributes["id"].to_i
            slotName = slotTrans[slot]
            int = hsh["int"].to_i
            splpwr = hsh["splpwr"].to_i
            spi = hsh["spi"].to_i
            hit = hsh["hitrtng"].to_i
            haste = hsh["hastertng"].to_i
            mastery = hsh["mastrtng"].to_i
            crit = hsh["critstrkrtng"].to_i
            sockets = []
            if hsh["socket1"] != nil then sockets.push(socketTrans[hsh["socket1"].to_i].to_i) end
            if hsh["socket2"] != nil then sockets.push(socketTrans[hsh["socket2"].to_i].to_i) end
            if hsh["socket3"] != nil then sockets.push(socketTrans[hsh["socket3"].to_i].to_i) end
            if slotName == "waist" then
                sockets.push(4)
            elsif slotName == "hands" then
                if $profs["bla"] == 1 then
                    sockets.push(4)
                end
            elsif slotName == "wrists" then
                if $profs["bla"] == 1 then
                    sockets.push(4)
                end
            elsif (slotName == "main_hand") or (slotName == "two_hand") then
                if $wrathion_weapon_socket then
                    sockets.push(4)
                end
            end
            if bonusValue != "" then
                sockets.push(bonusValue.to_i)
                sockets.push(bonusTrans[bonusStat])
            end
            if sockets.length == 1 then
                sockets.push(0)
                sockets.push("int")
            end
            if sockets.length == 0 then sockets = nil end
            # if we just added a socket to an item that had none, add a dummy socket bonus to avoid errors
            #puts "sockets: #{sockets}"

            if not (itemBase.key?(slotName)) then itemBase[slotName] = Array.new end
            if slotName == "two_hand" then
                simcSlotName = "main_hand"
            else
                simcSlotName = slotName
            end
            itemBase[slotName].push(Item.new(id,name,simcSlotName,int,splpwr,spi,hit,haste,mastery,crit,sockets))
        end
    end
    out = itemBase
end

$baseItems = getWowheadData($baseIDs)
$upgradeItems = getWowheadData($upgradeIDs)

if $ohID > 0 then
    $oh = getWowheadData([$ohID])["off_hand"][0]
end
if $mhID > 0 then
    $mh = getWowheadData([$mhID])["main_hand"][0]
end

puts "\nbase set:"
$arrBase = []
$baseItems.keys.each do |key|
    $baseItems[key].each do |i|
        puts "#{i.getID} #{i.getName}"
        $arrBase.push(i)
    end
end

$sets = Hash.new
$sets["base"] = ItemSet.new($arrBase)

$upgradeItems.keys.each do |ukey|
    $upgradeItems[ukey].each do |ui|
        if (ukey == "main_hand") and $baseItems.key?("two_hand") then
            if $ohID > 0 then
                puts "\ninserting #{ui.getName} into set."
                arrSet = []
                $baseItems.keys.each do |bkey|  # add all items except the two-hand
                    if bkey != "two_hand" then
                        $baseItems[bkey].each do |bi|
                            arrSet.push(bi)
                        end
                    end
                end
                arrSet.push(ui)                 # add the upgrade main-hand
                arrSet.push($oh)                # add replacement off-hand
                key = "#{ui.getID}_#{ui.getSimcName}"
                $sets[key] = ItemSet.new(arrSet)
                arrSet.each do |i|
                    puts "#{i.getID} #{i.getName}"
                end
            else
                puts "\n can't insert #{ui.getName} into set, no matching off-hand defined."
            end
        elsif (ukey == "off_hand") and $baseItems.key?("two_hand") then
            if $mhID > 0 then
                puts "\ninserting #{ui.getName} into set."
                arrSet = []
                $baseItems.keys.each do |bkey|  # add all items except the two-hand
                    if bkey != "two_hand" then
                        $baseItems[bkey].each do |bi|
                            arrSet.push(bi)
                        end
                    end
                end
                arrSet.push(ui)                 # add the upgrade off-hand
                arrSet.push($mh)                # add replacement main-hand
                key = "#{ui.getID}_#{ui.getSimcName}"
                $sets[key] = ItemSet.new(arrSet)
                arrSet.each do |i|
                    puts "#{i.getID} #{i.getName}"
                end
            else
                puts "\n can't insert #{ui.getName} into set, no matching main-hand defined."
            end
        elsif (ukey == "two_hand") and $baseItems.key?("main_hand") and $baseItems.key?("off_hand") then
            puts "\ninserting #{ui.getName} into set."
            arrSet = []
            $baseItems.keys.each do |bkey|      # add all items except main/off hand
                if (bkey != "main_hand") and (bkey != "off_hand") then
                    $baseItems[bkey].each do |bi|
                        arrSet.push(bi)
                    end
                end
            end
            arrSet.push(ui)                     # add the upgrade two-hand
            key = "#{ui.getID}_#{ui.getSimcName}"
            $sets[key] = ItemSet.new(arrSet)
            arrSet.each do |i|
                puts "#{i.getID} #{i.getName}"
            end
        elsif $baseItems[ukey].length == 1 then
            puts "\ninserting #{ui.getName} into set."
            arrSet = []
            $baseItems.keys.each do |bkey|
                if bkey != ukey then
                    $baseItems[bkey].each do |bi|
                        arrSet.push(bi)
                    end
                else
                    arrSet.push(ui)
                end
            end
            key = "#{ui.getID}_#{ui.getSimcName}"
            $sets[key] = ItemSet.new(arrSet)
            arrSet.each do |i|
                puts "#{i.getID} #{i.getName}"
            end
        elsif $baseItems[ukey].length == 2 then     #replacing a trinket, gotta check both slots
            puts "\ninserting #{ui.getName} into set. NYI"
            arrSet = []
            (0..1).each do |ri|
                arrSet.push([])
                $baseItems.keys.each do |bkey|
                    if bkey != ukey then
                        $baseItems[bkey].each do |bi|
                            arrSet[ri].push(bi)
                        end
                    else
                        arrSet[ri].push($baseItems[bkey][ri])
                        arrSet[ri].push(ui)
                    end
                end
                arrSet[ri].each do |i|
                    puts "#{i.getID} #{i.getName}"
                end
                key = "#{ui.getID}_#{ri}_#{ui.getSimcName}"
                $sets[key] = ItemSet.new(arrSet[ri])
                puts "\n"
            end
        end
    end
end

# write simc files for each set
$sets.each do |k,v|
    v.reforge
    val = v.getValue
    timedMsg("writing #{k} with est. dps of #{val} to file")
    outFile = File.open("#{k}.simc","w")
    outFile.syswrite("shaman=\"#{k}\"\nspec=elemental\ntalents=333323\nglyphs=fire_elemental_totem/unleashed_lightning/chain_lightning/lakestrider/astral_recall\nprofessions=enchanting=600/blacksmithing=600\n\n")
    outFile.syswrite(v.getSimc)
    outFile.close
end
# write mastery simc file
outFile = File.open("upgrades.simc","w")
outFile.syswrite("threads=1\noptimal_raid=1\ncalculate_scale_factors=0\niterations=25000\nhtml=upgrades.html\nfight_style=patchwerk\n\n")
$sets.each do |k,v|
    outFile.syswrite("#{k}.simc name=#{k}\n")
end
outFile.close