package reforging;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;

/**
 *
 * @author Nyxxie
 */
public class Main {

    private static final LinkedHashMap<Stat, Double> statWeights = new LinkedHashMap();
    private static final LinkedHashMap<BaseStat, Double> baseStats = new LinkedHashMap();
    private static final LinkedHashMap<Slot, Gear> gear = new LinkedHashMap();
    private static final int ABILITY_HIT_CAP = 246;
    private static final int SPELL_HIT_CAP = 446;//tweak this
    private static final int WHITE_HIT_CAP = 446;//tweak this

    public static void main(String[] args) {
        //Define stat weights in order of weight, high to low
        statWeights.put(Stat.ABILITY_HIT, 5.83);
        statWeights.put(Stat.HASTE, 4.28);
        statWeights.put(Stat.CRIT, 2.19);
        statWeights.put(Stat.EXPERTISE, 1.68);
        statWeights.put(Stat.MASTERY, 1.41);
        statWeights.put(Stat.SPELL_HIT, 0.0);
        statWeights.put(Stat.WHITE_HIT, 0.0);//not ready yet

        //Define Base Stats
        baseStats.put(BaseStat.SPELL_HIT_PCT, 6.0);//not ready yet
        baseStats.put(BaseStat.EXPERTISE_PCT, 0.0);//not ready yet

        //Define Gear
        final Gear helm = new Gear();
        helm.stats.put(Stat.CRIT, 100);
        helm.stats.put(Stat.HASTE, 92);
        gear.put(Slot.HEAD, helm);

        final Gear neck = new Gear();
        neck.stats.put(Stat.CRIT, 62);
        neck.stats.put(Stat.HASTE, 49);
        gear.put(Slot.NECK, neck);

        final Gear shoulder = new Gear();
        shoulder.stats.put(Stat.CRIT, 80);
        shoulder.stats.put(Stat.HASTE, 72);
        gear.put(Slot.SHOULDER, shoulder);

        final Gear back = new Gear();
        back.stats.put(Stat.CRIT, 65);
        back.stats.put(Stat.EXPERTISE, 45);
        gear.put(Slot.BACK, back);

        final Gear chest = new Gear();
        chest.stats.put(Stat.CRIT, 108);
        chest.stats.put(Stat.HASTE, 92);
        gear.put(Slot.CHEST, chest);

        final Gear wrist = new Gear();
        wrist.stats.put(Stat.HIT, 60);
        wrist.stats.put(Stat.CRIT, 68);
        gear.put(Slot.WRIST, wrist);

        final Gear hands = new Gear();
        hands.stats.put(Stat.HIT, 72);
        hands.stats.put(Stat.CRIT, 80);
        gear.put(Slot.HANDS, hands);

        final Gear waist = new Gear();
        waist.stats.put(Stat.CRIT, 75);
        waist.stats.put(Stat.HASTE, 68);
        gear.put(Slot.WAIST, waist);

        final Gear legs = new Gear();
        legs.stats.put(Stat.CRIT, 108);
        legs.stats.put(Stat.HASTE, 84);
        gear.put(Slot.LEGS, legs);

        final Gear feet = new Gear();
        feet.stats.put(Stat.HIT, 70);
        feet.stats.put(Stat.CRIT, 86);
        gear.put(Slot.FEET, feet);

        final Gear ring1 = new Gear();
        ring1.stats.put(Stat.HIT, 59);
        ring1.stats.put(Stat.CRIT, 59);
        gear.put(Slot.RING1, ring1);

        final Gear ring2 = new Gear();
        ring2.stats.put(Stat.CRIT, 68);
        ring2.stats.put(Stat.EXPERTISE, 60);
        gear.put(Slot.RING2, ring2);

        final Gear trinket1 = new Gear();
        trinket1.stats.put(Stat.CRIT, 163);
        gear.put(Slot.TRINKET1, trinket1);

        final Gear trinket2 = new Gear();
        trinket2.stats.put(Stat.CRIT, 155);
        gear.put(Slot.TRINKET2, trinket2);

        final Gear mainhand = new Gear();
        mainhand.stats.put(Stat.CRIT, 114);
        mainhand.stats.put(Stat.HASTE, 114);
        gear.put(Slot.MAINHAND, mainhand);

        final Gear relic = new Gear();
        relic.stats.put(Stat.CRIT, 34);
        relic.stats.put(Stat.HASTE, 34);
        gear.put(Slot.RELIC, relic);

        //For each piece of gear, assemble all viable reforge orders for each piece of gear
        final LinkedHashMap<Slot, LinkedHashSet<ReforgeOrder>> allReforgeOrders = assembleReforgeOrders();

        //Do calculations
        final long startTime = Calendar.getInstance().getTimeInMillis();

        long maxCombinations = 1;
        for (LinkedHashSet<ReforgeOrder> roSet : allReforgeOrders.values()) {
            maxCombinations *= roSet.size();
        }

        int counter = 0;
        final LinkedHashMap<Slot, ReforgeOrder> reforgeOrders = new LinkedHashMap();
        double bestWeight = 0.0;
        final ArrayList<LinkedHashMap<Slot, ReforgeOrder>> setOfBestReforgeOrders = new ArrayList();
        final ArrayList<CalculationResult> setOfBestResults = new ArrayList();
        while (cycleReforgeOrder(0, reforgeOrders, allReforgeOrders)) {
            counter += 1;
            if (counter % 100000 == 0) {
                System.out.println("Tested combination " + counter + " of " + maxCombinations);
            }
            final CalculationResult result = calculateReforgeResult(reforgeOrders);
            final double weight = result.totalWeight;
            if (weight >= bestWeight) {
                if (weight > bestWeight) {
                    bestWeight = weight;
                    setOfBestReforgeOrders.clear();
                    setOfBestResults.clear();
                }
                setOfBestReforgeOrders.add(copyReforgeOrders(reforgeOrders));
                setOfBestResults.add(copyCalculationResult(result));
            }
        }

        final long endTime = Calendar.getInstance().getTimeInMillis();

        //Print results
        System.out.println("Tested " + String.valueOf(counter) + " combinations in " + String.valueOf(endTime - startTime) + " ms");
        System.out.println("Best Weight: " + bestWeight);
        printResults(setOfBestResults, setOfBestReforgeOrders);
    }//end of program

    private static void printResults(ArrayList<CalculationResult> setOfBestResults, ArrayList<LinkedHashMap<Slot, ReforgeOrder>> setOfBestReforgeOrders) {
        for (int i = 0; i < setOfBestResults.size(); i++) {
            final LinkedHashMap<Slot, ReforgeOrder> bestReforgeOrders = setOfBestReforgeOrders.get(i);
            final CalculationResult result = setOfBestResults.get(i);

            System.out.println("-----------------");
            System.out.println("Alternative" + String.valueOf(i + 1));
            for (Stat st : result.newStats.keySet()) {
                System.out.println(st.name() + ": " + result.newStats.get(st));
            }
            for (Slot sl : bestReforgeOrders.keySet()) {
                final ReforgeOrder r = bestReforgeOrders.get(sl);
                if (r.leaveAlone) {
                    System.out.println(sl.name() + ": Don't Reforge");
                } else {
                    System.out.println(sl.name() + ": " + r.oldStat.name() + " -> " + r.newStat.name());
                }
            }
        }
    }

    private static LinkedHashMap<Slot, ReforgeOrder> copyReforgeOrders(LinkedHashMap<Slot, ReforgeOrder> reforgeOrders) {
        final LinkedHashMap<Slot, ReforgeOrder> copyOfReforgeOrders = new LinkedHashMap();

        for (Slot sl : reforgeOrders.keySet()) {
            final ReforgeOrder copyOfReforgeOrder;

            final ReforgeOrder reforgeOrder = reforgeOrders.get(sl);
            if (reforgeOrder.leaveAlone) {
                copyOfReforgeOrder = new ReforgeOrder();//leave alone
            } else {
                copyOfReforgeOrder = new ReforgeOrder(reforgeOrder.oldStat, reforgeOrder.newStat);
            }

            copyOfReforgeOrders.put(sl, copyOfReforgeOrder);
        }

        return copyOfReforgeOrders;
    }

    private static CalculationResult copyCalculationResult(CalculationResult calculationResult) {
        final LinkedHashMap<Stat, Integer> copyOfNewStats = new LinkedHashMap();

        final LinkedHashMap<Stat, Integer> newStats = calculationResult.newStats;
        for (Stat st : newStats.keySet()) {
            copyOfNewStats.put(st, newStats.get(st));
        }

        final CalculationResult copyOfCalculationResult = new CalculationResult(copyOfNewStats, calculationResult.totalWeight);
        return copyOfCalculationResult;
    }

    private static CalculationResult calculateReforgeResult(LinkedHashMap<Slot, ReforgeOrder> reforgeOrders) {
        final LinkedHashMap<Stat, Integer> newStats = new LinkedHashMap();
        //Prepare newStats using exising stats on gear
        for (Gear g : gear.values()) {
            for (Stat st : g.stats.keySet()) {
                if (!newStats.containsKey(st)) {
                    newStats.put(st, 0);
                }
            }
        }
        //Prepare newStats using stats not had before reforging
        for (ReforgeOrder ro : reforgeOrders.values()) {
            if (ro.leaveAlone) {
                continue;
            }
            if (!newStats.containsKey(ro.newStat)) {
                newStats.put(ro.newStat, 0);
            }
        }
        //Tally up newStats after reforging
        for (Slot sl : gear.keySet()) {
            final Gear g = gear.get(sl);
            final ReforgeOrder ro = reforgeOrders.get(sl);
            if (ro != null && !ro.leaveAlone) {
                //factor in reduced oldStat
                newStats.put(ro.oldStat, newStats.get(ro.oldStat) + (int) Math.ceil(0.60 * g.stats.get(ro.oldStat)));
                //factor in newStat
                newStats.put(ro.newStat, newStats.get(ro.newStat) + (int) Math.floor(0.40 * g.stats.get(ro.oldStat)));
                //factor in other stats
                for (Stat st : g.stats.keySet()) {
                    if (st == ro.oldStat) {
                        continue;//oldStat already factored in
                    }
                    newStats.put(st, newStats.get(st) + (int) (g.stats.get(st)));
                }
            } else {
                //chose not to reforge this piece
                //factor in all stats
                for (Stat st : g.stats.keySet()) {
                    newStats.put(st, newStats.get(st) + (int) (g.stats.get(st)));
                }
            }
        }


        //weight newStats
        double totalWeight = 0.0;
        for (Stat st : newStats.keySet()) {
            if (st == Stat.HIT) {
                final int hitRating = newStats.get(Stat.HIT);
                //Ability hit
                if (hitRating <= ABILITY_HIT_CAP) {
                    totalWeight += hitRating * statWeights.get(Stat.ABILITY_HIT);
                } else {
                    totalWeight += ABILITY_HIT_CAP * statWeights.get(Stat.ABILITY_HIT);
                    //Spell hit
                    if (hitRating <= 315) {
                        totalWeight += (hitRating - ABILITY_HIT_CAP) * statWeights.get(Stat.SPELL_HIT);
                    } else {
                        totalWeight += (SPELL_HIT_CAP - ABILITY_HIT_CAP) * statWeights.get(Stat.SPELL_HIT);
                        //White hit
                        if (hitRating <= 777) {
                            totalWeight += (hitRating - SPELL_HIT_CAP) * statWeights.get(Stat.WHITE_HIT);
                        } else {
                            totalWeight += (WHITE_HIT_CAP - SPELL_HIT_CAP) * statWeights.get(Stat.WHITE_HIT);
                        }
                    }
                }
            } else {
                totalWeight += newStats.get(st) * statWeights.get(st);
            }
        }

        final CalculationResult result = new CalculationResult(newStats, totalWeight);

        return result;
    }

    private static class CalculationResult {

        final LinkedHashMap<Stat, Integer> newStats;
        final double totalWeight;

        CalculationResult(LinkedHashMap<Stat, Integer> newStats, double totalWeight) {
            this.newStats = newStats;
            this.totalWeight = totalWeight;
        }
    }

    private static boolean cycleReforgeOrder(int level, LinkedHashMap<Slot, ReforgeOrder> reforgeOrders, LinkedHashMap<Slot, LinkedHashSet<ReforgeOrder>> allReforgeOrders) {
        //is this the first iteration?
        if (reforgeOrders.isEmpty()) {
            for (Slot sl : allReforgeOrders.keySet()) {//set first combination to try
                reforgeOrders.put(sl, allReforgeOrders.get(sl).toArray(new ReforgeOrder[0])[0]);
            }
            return true;
        }

        //does this level exist?
        final Slot[] slots = reforgeOrders.keySet().toArray(new Slot[0]);
        if (level >= slots.length) {
            return false;
        }
        final Slot sl = slots[level];//slot this level represents

        ReforgeOrder finalOrder = null;
        {
            final Iterator<ReforgeOrder> i = allReforgeOrders.get(sl).iterator();
            while (i.hasNext()) {
                finalOrder = i.next();
            }
        }

        if (reforgeOrders.get(sl).equals(finalOrder)) {//is this level at max?
            final boolean isNextLevel = cycleReforgeOrder(level + 1, reforgeOrders, allReforgeOrders);//inc the next level
            if (isNextLevel) {
                reforgeOrders.put(sl, allReforgeOrders.get(sl).toArray(new ReforgeOrder[0])[0]);//set to min
                return true;
            } else {
                return false;
            }
        } else {
            //set to next
            final Iterator<ReforgeOrder> i = allReforgeOrders.get(sl).iterator();
            while (i.hasNext()) {
                if (reforgeOrders.get(sl).equals(i.next())) {
                    reforgeOrders.put(sl, i.next());
                    break;
                }
            }
            return true;
        }
    }

    private static LinkedHashMap<Slot, LinkedHashSet<ReforgeOrder>> assembleReforgeOrders() {
        //This function filters out always-inferior reforge-orders in order to cut down the number of combinations that need to be tested
        final LinkedHashMap<Slot, LinkedHashSet<ReforgeOrder>> allReforgeOrders = new LinkedHashMap();
        final Stat _2ndBestStat = statWeights.keySet().toArray(new Stat[0])[1];
        final Stat _3rdBestStat = statWeights.keySet().toArray(new Stat[0])[2];
        for (Slot sl : gear.keySet()) {
            final Gear g = gear.get(sl);
            final LinkedHashSet<ReforgeOrder> viableReforgeOrders = new LinkedHashSet();
            final boolean hasHit = g.stats.containsKey(Stat.HIT);
            final boolean has2ndBestStat = g.stats.containsKey(_2ndBestStat);
            final boolean has3rdBestStat = g.stats.containsKey(_3rdBestStat);
            if (hasHit) {
                if (has2ndBestStat) {
                    viableReforgeOrders.add(new ReforgeOrder(Stat.HIT, _3rdBestStat));
                    viableReforgeOrders.add(new ReforgeOrder());//leave alone
                } else {//!has2ndBestStat
                    viableReforgeOrders.add(new ReforgeOrder(Stat.HIT, _2ndBestStat));
                    Stat otherStat = null;
                    for (Stat st : g.stats.keySet()) {
                        if (st != Stat.HIT) {
                            otherStat = st;
                            break;
                        }
                    }
                    if (otherStat == null) {//no other stat
                        viableReforgeOrders.add(new ReforgeOrder());//leave alone
                    } else {
                        viableReforgeOrders.add(new ReforgeOrder(otherStat, _2ndBestStat));
                    }
                }
            } else {//!hasHit
                //Reforge each stat to HIT
                for (Stat st : g.stats.keySet()) {
                    viableReforgeOrders.add(new ReforgeOrder(st, Stat.HIT));
                }
                if (has2ndBestStat) {
                    if (has3rdBestStat) {
                        viableReforgeOrders.add(new ReforgeOrder());//leave alone
                    } else {//!has3rdBestStat
                        Stat otherStat = null;
                        for (Stat st : g.stats.keySet()) {
                            if (st != _2ndBestStat) {
                                otherStat = st;
                                break;
                            }
                        }
                        if (otherStat == null) {//no other stat
                            viableReforgeOrders.add(new ReforgeOrder());//leave alone
                        } else {
                            viableReforgeOrders.add(new ReforgeOrder(otherStat, _3rdBestStat));
                        }
                    }
                } else {//!has2ndBestStat
                    //Figure out which stat should be reforged into 2ndBestStat
                    final Stat betterStat;
                    final Stat worseStat;
                    final Stat[] stats = g.stats.keySet().toArray(new Stat[0]);
                    if (stats.length == 1) {//no other stat
                        viableReforgeOrders.add(new ReforgeOrder(stats[0], _2ndBestStat));
                    } else {
                        if (statWeights.get(stats[0]) >= statWeights.get(stats[1])) {
                            betterStat = stats[0];
                            worseStat = stats[1];
                        } else {
                            betterStat = stats[1];
                            worseStat = stats[0];
                        }
                        if (Math.ceil(0.60 * g.stats.get(worseStat)) * statWeights.get(worseStat) + Math.floor(0.40 * g.stats.get(worseStat)) * statWeights.get(_2ndBestStat)
                                >= Math.ceil(0.60 * g.stats.get(betterStat)) * statWeights.get(betterStat) + Math.floor(0.40 * g.stats.get(betterStat)) * statWeights.get(_2ndBestStat)) {
                            viableReforgeOrders.add(new ReforgeOrder(worseStat, _2ndBestStat));
                        } else {
                            viableReforgeOrders.add(new ReforgeOrder(betterStat, _2ndBestStat));
                        }
                    }
                }
            }
            allReforgeOrders.put(sl, viableReforgeOrders);
        }//end gear loop
        return allReforgeOrders;
    }

    private static class ReforgeOrder {

        final boolean leaveAlone;
        final Stat oldStat;
        final Stat newStat;

        ReforgeOrder(Stat oldStat, Stat newStat) {
            leaveAlone = false;
            this.oldStat = oldStat;
            this.newStat = newStat;
        }

        ReforgeOrder() {
            leaveAlone = true;
            this.oldStat = null;
            this.newStat = null;
        }
    }

    private static class Gear {

        final LinkedHashMap<Stat, Integer> stats = new LinkedHashMap();
    }

    private enum Slot {

        HEAD, NECK, SHOULDER, BACK, CHEST, WRIST,
        HANDS, WAIST, LEGS, FEET, RING1, RING2, TRINKET1, TRINKET2,
        MAINHAND, OFFHAND, RELIC;
    }

    private enum Stat {

        HIT, HASTE, CRIT, MASTERY, EXPERTISE,
        ABILITY_HIT, SPELL_HIT, WHITE_HIT;
    }

    private enum BaseStat {

        EXPERTISE_PCT, ABILITY_HIT_PCT, SPELL_HIT_PCT, WHITE_HIT_PCT;
    }
}