main.py

# -*- coding: utf-8 -*-

# Run this app with `python main.py` and
# visit http://127.0.0.1:8080/ in your web browser.

import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
import numpy as np
from dash.dependencies import Input, Output, State
import dash_bootstrap_components as dbc
import wotlk_cat_sim as ccs
import sim_utils
import player as player_class
import multiprocessing
import trinkets
import copy
import json
import base64
import io


app = dash.Dash(__name__, external_stylesheets=[dbc.themes.DARKLY])
server = app.server

default_input_stats = {
        "agility": 1690,
        "armor": 7288,
        "armorPen": 43.21,
        "armorPenRating": 605,
        "attackPower": 9050,
        "crit": 59.96,
        "critRating": 790,
        "critReduction": 6,
        "defense": 400,
        "dodge": 44.88,
        "expertise": 26,
        "expertiseRating": 139,
        "feralAttackPower": 3175,
        "haste": 18.2,
        "hasteRating": 459,
        "health": 23837,
        "hit": 7.01,
        "hitRating": 230,
        "intellect": 211,
        "mainHandSpeed": 3.5,
        "mana": 6381,
        "parry": 5,
        "spellCrit": 20.33,
        "spellCritRating": 790,
        "spellHaste": 14,
        "spellHit": 8.77,
        "spirit": 193,
        "stamina": 1660,
        "strength": 189
}

stat_input = dbc.Col([
    html.H5('Eighty Upgrades Input'),
    dcc.Markdown(
        'This simulator uses Eighty Upgrades as its gear selection UI. In '
        'order to use it, create a Eighty Upgrades profile for your character'
        ' and download the gear set using the "Export" button at the top right'
        ' of the character sheet. Make sure that "Cat Form" is selected in the'
        ' export window, and that "Talents" are checked (and set up in your '
        'character sheet). Also make sure that trinket and Idol slots are left'
        ' empty prior to exporting, as these will be selected in the sim UI.',
        style={'width': 300},
    ),
    dcc.Markdown(
        'Consumables and party/raid buffs can be specified either in the '
        'Eighty Upgrades "Buffs" tab, or in the "Consumables" and "Raid '
        'Buffs " sections in the sim. If the "Buffs" option is checked in the '
        'Eighty Upgrades export window, then the corresponding sections in '
        'the sim input will be ignored.',
        style={'width': 300},
    ),
    dcc.Upload(
        id='upload-data',
        children=html.Div([
            'Drag and Drop or ',
            html.A('Select File')
        ]),
        style={
            'width': '100%',
            'height': '60px',
            'lineHeight': '60px',
            'borderWidth': '1px',
            'borderStyle': 'dashed',
            'borderRadius': '5px',
            'textAlign': 'center',
            'margin': '0px'
        },
        # Don't allow multiple files to be uploaded
        multiple=False
    ),
    html.Br(),
    html.Div(
        'No file uploaded, using default input stats instead.',
        id='upload_status', style={'color': '#E59F3A'}
    ),
    html.Br(),
    html.H5('Idols, Glyphs, and Other Bonuses'),
    dbc.Checklist(
        options=[{'label': 'Idol of the Raven Goddess', 'value': 'raven'}],
        value=[], id='raven_idol'
    ),
    dbc.Checklist(
        options=[
            {'label': 'Idol of the Ravenous Beast', 'value': 'shred_idol'},
            {'label': 'Idol of Worship', 'value': 'rip_idol'},
            {'label': 'Idol of the Wastes', 'value': 'wastes_idol'},
            {'label': 'Idol of Mutilation', 'value': 'idol_of_mutilation'},
            {'label': 'Idol of the Corruptor', 'value': 'mangle_idol'},
            {'label': 'Idol of the Crying Moon', 'value': 'rake_idol'},
            {'label': 'Glyph of Mangle', 'value': 'mangle_glyph'},
            {'label': 'Glyph of Rip', 'value': 'rip_glyph'},
            {'label': 'Glyph of Shred', 'value': 'shred_glyph'},
            {'label': 'Glyph of Savage Roar', 'value': 'roar_glyph'},
            {'label': 'Glyph of Berserk', 'value': 'berserk_glyph'},
            {'label': '2-piece Tier 6 bonus', 'value': 't6_2p'},
            {'label': '4-piece Tier 6 bonus', 'value': 't6_4p'},
            {'label': '2-piece Tier 7 bonus', 'value': 't7_2p'},
            {'label': '2-piece Tier 8 bonus', 'value': 't8_2p'},
            {'label': '4-piece Tier 8 bonus', 'value': 't8_4p'},
            {'label': '2-piece Tier 9 bonus', 'value': 't9_2p'},
            {'label': '4-piece Tier 9 bonus', 'value': 't9_4p'},
            {'label': '2-piece Tier 10 bonus', 'value': 't10_2p'},
            {'label': '4-piece Tier 10 bonus', 'value': 't10_4p'},
            {'label': 'Wolfshead Helm', 'value': 'wolfshead'},
            {'label': 'Relentless Earthsiege Diamond', 'value': 'meta'},
            {'label': 'Enchant Weapon: Mongoose', 'value': 'mongoose'},
            {'label': 'Enchant Weapon: Executioner', 'value': 'executioner'},
            {'label': 'Enchant Weapon: Berserking', 'value': 'berserking'},
            {'label': 'Hyperspeed Accelerators', 'value': 'engi_gloves'},
            {'label': 'Swordguard Embroidery', 'value': 'ap_cloak'},
        ],
        value=[
            'idol_of_mutilation', 'shred_glyph', 'roar_glyph', 't9_2p',
            't9_4p', 'meta', 'berserking', 'engi_gloves'
        ],
        id='bonuses'
    ),
    ], width='auto', style={'marginBottom': '2.5%', 'marginLeft': '2.5%'})

buffs_1 = dbc.Col(
    [dbc.Collapse([html.H5('Consumables'),
     dbc.Checklist(
         options=[{'label': 'Flask of Endless Rage', 'value': 'flask'},
                  {
                      'label': 'Snapper Extreme / Worg Tartare',
                      'value': 'hit_food'
                  },
                  {'label': 'Blackened Dragonfin', 'value': 'agi_food'},
                  {'label': 'Dragonfin Filet', 'value': 'str_food'},
                  {'label': 'Hearty Rhino', 'value': 'arp_food'},
                  {'label': 'Adamantite Weightstone', 'value': 'weightstone'}],
         value=['flask', 'arp_food'],
         id='consumables'
     ),
     html.Br(),
     html.H5('Raid Buffs'),
     dbc.Checklist(
         options=[{'label': 'Blessing of Kings', 'value': 'kings'},
                  {
                      'label': 'Blessing of Might / Battle Shout',
                      'value': 'might'
                  },
                  {
                      'label': 'Blessing of Wisdom / Mana Spring Totem',
                      'value': 'wisdom'
                  },
                  {'label': 'Mark of the Wild', 'value': 'motw'},
                  {'label': 'Heroic Presence', 'value': 'heroic_presence'},
                  {
                      'label': 'Strength of Earth Totem / Horn of Winter',
                      'value': 'str_totem'
                  },
                  {
                      'label': "Unleashed Rage / Trueshot Aura / Abomination's Might",
                      'value': 'unleashed_rage'
                  },
                  {'label': 'Arcane Intellect', 'value': 'ai'},
                  {'label': 'Prayer of Spirit', 'value': 'spirit'},
                  {
                        'label': 'Moonkin Aura / Elemental Oath',
                        'value': 'moonkin_aura'
                  }
         ],
         value=[
             'kings', 'might', 'wisdom', 'motw', 'str_totem', 'unleashed_rage',
             'ai', 'heroic_presence', 'moonkin_aura'
         ],
         id='raid_buffs'
     ),
     html.Br()], id='buff_section', is_open=True),
     html.H5('Other Buffs'),
     dbc.Checklist(
         options=[
             {
                 'label': 'Sanctified Retribution / Ferocious Inspiration / Arcane Empowerment',
                 'value': 'sanc_aura'
             },
             {'label': 'Braided Eternium Chain', 'value': 'be_chain'},
             {
                 'label': 'Improved Windfury Totem / Improved Icy Talons',
                 'value': 'major_haste'
             },
             {
                 'label': 'Improved Moonkin Form / Swift Retribution',
                 'value': 'minor_haste'
             },
             {'label': 'Wrath of Air Totem', 'value': 'spell_haste'},
             {'label': 'Mana Replenishment', 'value': 'replenishment'},
         ],
         value=[
             'sanc_aura', 'major_haste', 'minor_haste', 'spell_haste',
             'replenishment'
         ],
         id='other_buffs'
     ),
     dbc.InputGroup(
         [
             dbc.InputGroupAddon(
                 'Rejuvenation / Wild Growth uptime:', addon_type='prepend'
             ),
             dbc.Input(
                 value=0.0, type='number', id='hot_uptime',
             ),
             dbc.InputGroupAddon('%', addon_type='append')
         ],
         style={'width': '75%', 'marginTop': '2.5%'}
     ),
    ],
    width='auto', style={'marginBottom': '2.5%', 'marginLeft': '2.5%'}
)

encounter_details = dbc.Col(
    [html.H4('Encounter Details'),
     dbc.InputGroup(
         [
             dbc.InputGroupAddon('Fight Length:', addon_type='prepend'),
             dbc.Input(
                 value=180.0, type='number', id='fight_length',
             ),
             dbc.InputGroupAddon('seconds', addon_type='append')
         ],
         style={'width': '75%'}
     ),
     dbc.InputGroup(
         [
             dbc.InputGroupAddon('Boss Armor:', addon_type='prepend'),
             dbc.Input(value=10643, type='number', id='boss_armor')
         ],
         style={'width': '50%'}
     ),
     dbc.InputGroup(
         [
             dbc.InputGroupAddon('Target Count:', addon_type='prepend'),
             dbc.Input(value=1, type='number', id='num_targets')
         ],
         style={'width': '50%'}
     ),
     html.Br(),
     html.H5('Damage Debuffs'),
     dbc.Checklist(
         options=[
             {'label': 'Gift of Arthas', 'value': 'gift_of_arthas'},
             {'label': 'Sunder Armor', 'value': 'sunder'},
             {'label': 'Faerie Fire', 'value': 'faerie_fire'},
             {
                 'label': 'Blood Frenzy / Savage Combat',
                 'value': 'blood_frenzy'
             },
             {
                'label': "Curse of Elements / Earth and Moon / Ebon Plaguebringer",
                'value': 'curse_of_elements'
             },
         ],
         value=['gift_of_arthas', 'sunder', 'faerie_fire', 'blood_frenzy', 'curse_of_elements'],
         id='boss_debuffs'
     ),
     html.Br(),
     html.H5('Stat Debuffs'),
     dbc.Checklist(
         options=[
             {
                 'label': 'Heart of the Crusader / Master Poisoner',
                 'value': 'jotc'
             },
             {'label': 'Judgment of Wisdom', 'value': 'jow'},
             {'label': 'Misery / Improved Faerie Fire', 'value': 'misery'},
             {
                 'label': 'Shadow Mastery / Improved Scorch / Winter\'s Chill',
                 'value': 'shadow_mastery'
             },
         ],
         value=['jotc', 'jow', 'misery', 'shadow_mastery'],
         id='stat_debuffs',
     ),
     html.Br(),
     html.H5('Cooldowns'),
     dbc.Checklist(
         options=[
             {'label': 'Bloodlust', 'value': 'lust'},
             {'label': 'Dark / Demonic Rune', 'value': 'rune'},
             {'label': 'Unholy Frenzy', 'value': 'unholy_frenzy'},
             {'label': 'Shattering Throw', 'value': 'shattering_throw'},
         ],
         value=['lust'], id='cooldowns',
     ),
     dbc.InputGroup(
         [
             dbc.InputGroupAddon('Potion CD:', addon_type='prepend'),
             dbc.Select(
                 options=[
                     {'label': 'Potion of Speed', 'value': 'haste'},
                     {'label': 'None', 'value': 'none'},
                 ],
                 value='haste', id='potion',
             ),
         ],
         style={'width': '75%', 'marginTop': '1.5%'}
     ),
     html.Br(),
     html.H5('Talents'),
     dbc.Checklist(
         options=[
             {'label': 'Omen of Clarity', 'value': 'omen'},
             {'label': 'Berserk', 'value': 'berserk'},
             {'label': 'Primal Gore', 'value': 'primal_gore'},
         ],
         value=['omen', 'berserk', 'primal_gore'], id='binary_talents'
     ),
     html.Br(),
     html.Div([
         html.Div(
             'Feral Aggression:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
                 {'label': '4', 'value': 4},
                 {'label': '5', 'value': 5},
             ],
             value=4, id='feral_aggression',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Savage Fury:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
             ],
             value=2, id='savage_fury',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Protector of the Pack:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
             ],
             value='0', id='potp',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Predatory Instincts:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
             ],
             value=3, id='predatory_instincts',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Improved Mangle:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
             ],
             value='0', id='improved_mangle',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Improved Mark of the Wild:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
             ],
             value=2, id='imp_motw',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Furor:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
                 {'label': '4', 'value': 4},
                 {'label': '5', 'value': 5},
             ],
             value=3, id='furor',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Naturalist:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
                 {'label': '4', 'value': 4},
                 {'label': '5', 'value': 5},
             ],
             value=5, id='naturalist',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Natural Shapeshifter:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
                 {'label': '3', 'value': 3},
             ],
             value=3, id='natural_shapeshifter',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )]),
     html.Div([
         html.Div(
             'Improved Leader of the Pack:',
             style={
                 'width': '35%', 'display': 'inline-block',
                 'fontWeight': 'bold'
             }
         ),
         dbc.Select(
             options=[
                 {'label': '0', 'value': 0},
                 {'label': '1', 'value': 1},
                 {'label': '2', 'value': 2},
             ],
             value=2, id='ilotp',
             style={
                 'width': '20%', 'display': 'inline-block',
                 'marginBottom': '2.5%', 'marginRight': '5%'
             }
         )])],
    width='auto',
    style={
        'marginLeft': '2.5%', 'marginBottom': '2.5%', 'marginRight': '-2.5%'
    }
)

# Sim replicates input
iteration_input = dbc.Col([
    html.H4('Sim Settings'),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon('Number of replicates:', addon_type='prepend'),
            dbc.Input(value=150000, type='number', id='num_replicates')
        ],
        style={'width': '50%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon('Modeled input delay:', addon_type='prepend'),
            dbc.Input(
                value=100, type='number', id='latency', min=1, step=1,
            ),
            dbc.InputGroupAddon('ms', addon_type='append')
        ],
        style={'width': '50%'}
    ),
    html.Br(),
    html.H5('Player Strategy'),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Minimum combo points for Rip:', addon_type='prepend'
            ),
            dbc.Select(
                options=[
                    {'label': '3', 'value': 3},
                    {'label': '4', 'value': 4},
                    {'label': '5', 'value': 5},
                ],
                value=5, id='rip_cp',
            ),
        ],
        style={'width': '55%', 'marginBottom': '1.5%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Minimum combo points for Ferocious Bite:',
                addon_type='prepend'
            ),
            dbc.Select(
                options=[
                    {'label': '3', 'value': 3},
                    {'label': '4', 'value': 4},
                    {'label': '5', 'value': 5},
                ],
                value=5, id='bite_cp',
            ),
        ],
        style={'width': '65%', 'marginBottom': '1.5%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon('Wait', addon_type='prepend'),
            dbc.Input(
                value=0.0, min=0.0, step=0.5, type='number', id='cd_delay',
            ),
            dbc.InputGroupAddon(
                'seconds before using cooldowns', addon_type='append'
            ),
        ],
        style={'width': '63%', 'marginBottom': '1.5%'},
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Targeted offset in Rip/Roar timings:', addon_type='prepend'
            ),
            dbc.Input(
                value=25, min=0, step=1, type='number', id='min_roar_offset'
            ),
            dbc.InputGroupAddon('seconds', addon_type='append')
        ],
        style={'width': '65%', 'marginBottom': '1.5%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Rip leeway for determining Roar clips:', addon_type='prepend'
            ),
            dbc.Input(
                value=4, min=0, step=1, type='number', id='roar_clip_leeway'
            ),
            dbc.InputGroupAddon('seconds', addon_type='append')
        ],
        style={'width': '67%', 'marginBottom': '1.5%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Maximum Energy for Faerie Fire during Berserk:',
                addon_type='prepend'
            ),
            dbc.Input(
                value=15, min=0, step=1, type='number', id='berserk_ff_thresh'
            ),
        ],
        style={'width': '67%', 'marginBottom': '1.5%'}
    ),
    dbc.InputGroup(
        [
            dbc.InputGroupAddon(
                'Max allowed FF delay to fit in damage casts:',
                addon_type='prepend'
            ),
            dbc.Input(
                value=0.1, min=0, step=0.1, type='number', id='max_ff_delay'
            ),
            dbc.InputGroupAddon('seconds', addon_type='append')
        ],
        style={'width': '75%'}
    ),
    html.Br(),
    dbc.Checklist(
        options=[{'label': ' use Ferocious Bite', 'value': 'bite'}],
        value=['bite'], id='use_biteweave'
    ),
    dbc.Collapse(
        [
            dbc.InputGroup(
                [
                    dbc.InputGroupAddon(
                        'Maximum Energy for Bite during Berserk:',
                        addon_type='prepend'
                    ),
                    dbc.Input(
                        value=25, min=18, step=1, type='number',
                        id='berserk_bite_thresh'
                    )
                ],
                style={
                    'width': '65%', 'marginBottom': '1%', 'marginLeft': '5%'
                }
            ),
            dbc.InputGroup(
                [
                    dbc.InputGroupAddon(
                        'Bite usage model:', addon_type='prepend'
                    ),
                    dbc.Select(
                        options=[
                            {'label': 'analytical', 'value': 'analytical'},
                            {'label': 'empirical', 'value': 'empirical'}
                        ],
                        value='empirical', id='bite_model'
                    ),
                ],
                style={
                    'width': '65%', 'marginBottom': '1%', 'marginLeft': '5%'
                }
            ),
            dbc.Collapse(
                [
                    dbc.InputGroup(
                        [
                            dbc.InputGroupAddon(
                                'Bite with',
                                addon_type='prepend'
                            ),
                            dbc.Input(
                                type='number', value=4, id='bite_time',
                                min=0, step=1
                            ),
                            dbc.InputGroupAddon(
                                'seconds left on Rip/Roar', addon_type='append'
                            )
                        ],
                        style={
                            'width': '65%', 'marginBottom': '1%',
                            'marginLeft': '5%'
                        }
                    ),
                ],
                id='empirical_options', is_open=True
            ),
        ],
        id='biteweave_options', is_open=True
    ),
    dbc.Checklist(
        options=[{'label': ' use Rake', 'value': 'use_rake'}],
        value=['use_rake'], id='use_rake'
    ),
    dbc.Checklist(
        options=[{'label': ' use Mangle over Shred', 'value': 'mangle_spam'}],
        value=[], id='mangle_spam'
    ),
    dbc.Checklist(
        options=[{
            'label': ' Mangle / Trauma maintained by bear tank / Arms warrior',
            'value': 'bear_mangle'
        }], value=[], id='bear_mangle'
    ),
    dbc.Collapse(
        [
            dbc.Checklist(
                options=[{
                    'label': ' pre-pop Berserk 1 second before combat starts',
                    'value': 'prepop_berserk'
                }], value=[], id='prepop_berserk'
            ),
        ],
        id='berserk_options', is_open=True
    ),
    dbc.Collapse(
        [
            dbc.Checklist(
                options=[{
                    'label': ' pre-proc Clearcasting before combat starts',
                    'value': 'preproc_omen'
                }], value=['preproc_omen'], id='preproc_omen'
            ),
        ],
        id='omen_options', is_open=True
    ),
    dbc.Checklist(
        options=[{'label': ' enable bearweaving', 'value': 'bearweave'}],
        value=[], id='bearweave'
    ),
    dbc.Collapse(
        [
            dbc.Checklist(
                options=[{
                    'label': ' prioritize Lacerate maintenance over Mangle',
                    'value': 'lacerate_prio'
                }],
                value=[], id='lacerate_prio',
                style={'marginTop': '1%', 'marginLeft': '5%'}
            ),
            dbc.Collapse(
                [
                    dbc.InputGroup(
                        [
                            dbc.InputGroupAddon(
                                'Refresh Lacerate with',
                                addon_type='prepend'
                            ),
                            dbc.Input(
                                type='number', value=8, id='lacerate_time',
                                min=0, step=1
                            ),
                            dbc.InputGroupAddon(
                                'seconds remaining', addon_type='append'
                            )
                        ],
                        style={
                            'width': '70%', 'marginBottom': '1%',
                            'marginLeft': '5%', 'marginTop': '1%',
                        }
                    ),
                ],
                id='lacerate_options', is_open=True
            ),
            dbc.Checklist(
                options=[{
                    'label': ' allow bear powershifts when Rage starved',
                    'value': 'powerbear'
                }],
                value=[], id='powerbear',
                style={'marginTop': '1%', 'marginLeft': '5%'}
            ),
            dbc.Checklist(
                options=[{
                    'label': ' reset swing timer using Albino Snake',
                    'value': 'snek'
                }],
                value=['snek'], id='snek',
                style={'marginTop': '1%', 'marginLeft': '5%'}
            ),
        ],
        id='bearweave_options', is_open=True
    ),
    dbc.Checklist(
        options=[{'label': ' enable flowershifting', 'value': 'flowershift'}],
        value=[], id='flowershift'
    ),
    dbc.Collapse(
        [
            dbc.InputGroup(
                [
                    dbc.InputGroupAddon(
                        'Number of targets for Gift of the Wild:',
                        addon_type='prepend'
                    ),
                    dbc.Input(
                        type='number', value=30, id='gotw_targets', min=1,
                        step=1
                    )
                ],
                style={
                    'width': '70%', 'marginBottom': '1%', 'marginLeft': '5%',
                    'marginTop': '1%',
                }
            ),
            dbc.Checklist(
                options=[{
                    'label': ' reset swing timer using fast weapon',
                    'value': 'daggerweave'
                }],
                value=[], id='daggerweave',
                style={'marginTop': '1%', 'marginLeft': '5%'}
            ),
            dbc.Collapse(
                [
                    dbc.InputGroup(
                        [
                            dbc.InputGroupAddon(
                                'EP loss from weapon swap:',
                                addon_type='prepend'
                            ),
                            dbc.Input(
                                type='number', value=1415, id='dagger_ep_loss',
                                min=0, step=1
                            ),
                        ],
                        style={
                            'width': '70%', 'marginBottom': '1%',
                            'marginLeft': '5%', 'marginTop': '1%',
                        }
                    ),
                ],
                id='dagger_options', is_open=True
            ),
        ],
        id='flowershift_options', is_open=True
    ),
    html.Br(),
    html.H5('Trinkets'),
    dbc.Row([
        dbc.Col(dbc.Select(
            id='trinket_1',
            options=[
                {'label': 'Empty', 'value': 'none'},
                {'label': "Deathbringer's Will (H)", 'value': 'dbw'},
                {
                    'label': 'Whispering Fanged Skull (H)',
                    'value': 'whispering_fanged_skull',
                },
                {
                    'label': 'Death\'s Verdict (H)',
                    'value': 'deaths_verdict_heroic',
                },
                {
                    'label': 'Death\'s Verdict (N)',
                    'value': 'deaths_verdict_normal',
                },
                {'label': 'Comet\'s Trail', 'value': 'comet_trail'},
                {'label': 'Mjolnir Runestone', 'value': 'mjolnir_runestone'},
                {'label': 'Dark Matter', 'value': 'dark_matter'},
                {'label': 'Pyrite Infuser', 'value': 'pyrite_infuser'},
                {'label': 'Wrathstone', 'value': 'wrathstone'},
                {
                    'label': 'Blood of the Old God',
                    'value': 'blood_of_the_old_god',
                },
                {
                    'label': 'Darkmoon Card: Greatness (Strength)',
                    'value': 'dmcg_str',
                },
                {
                    'label': 'Darkmoon Card: Greatness (Agility)',
                    'value': 'dmcg_agi',
                },
                {'label': 'Grim Toll', 'value': 'grim_toll'},
                {'label': 'Mirror of Truth', 'value': 'mirror'},
                {'label': "Loatheb's Shadow", 'value': 'loatheb'},
                {'label': 'Meteorite Whetstone', 'value': 'whetstone'},
                {
                    'label': 'Fury of the Five Flights',
                    'value': 'fury_of_the_five_flights',
                },
                {'label': 'Incisor Fragment', 'value': 'incisor_fragment'},
                {'label': 'Mark of Norgannon', 'value': 'norgannon'},
                {'label': "Sphere of Red Dragon's Blood", 'value': 'sphere'},
                {'label': 'Extract of Necromantic Power', 'value': 'extract'},
                {'label': "Bandit's Insignia", 'value': 'bandits_insignia'},
                {'label': 'Blackened Naaru Sliver', 'value': 'bns'},
                {'label': 'Darkmoon Card: Death', 'value': 'dmcd'},
                {'label': 'Tears of Anguish', 'value': 'tears'},
                {
                    'label': 'Gnomish Lightning Generator',
                    'value': 'lightning_generator'
                },
                {
                    'label': "Mighty Alchemist's Stone",
                    'value': 'mighty_alch'
                },
                {'label': "Fezzik's Pocketwatch", 'value': 'fezzik'},
                {'label': "Berserker's Call", 'value': 'berserkers_call'},
                {'label': 'Vestige of Haldor', 'value': 'vestige'},
                {'label': 'Madness of the Betrayer', 'value': 'madness'},
                {'label': 'Shard of Contempt', 'value': 'shard_of_contempt'},
            ],
            value='mjolnir_runestone'
        )),
        dbc.Col(dbc.Select(
            id='trinket_2',
            options=[
                {'label': 'Empty', 'value': 'none'},
                {'label': "Deathbringer's Will (H)", 'value': 'dbw'},
                {
                    'label': 'Whispering Fanged Skull (H)',
                    'value': 'whispering_fanged_skull',
                },
                {
                    'label': 'Death\'s Verdict (H)',
                    'value': 'deaths_verdict_heroic',
                },
                {
                    'label': 'Death\'s Verdict (N)',
                    'value': 'deaths_verdict_normal',
                },
                {'label': 'Comet\'s Trail', 'value': 'comet_trail'},
                {'label': 'Mjolnir Runestone', 'value': 'mjolnir_runestone'},
                {'label': 'Dark Matter', 'value': 'dark_matter'},
                {'label': 'Pyrite Infuser', 'value': 'pyrite_infuser'},
                {'label': 'Wrathstone', 'value': 'wrathstone'},
                {
                    'label': 'Blood of the Old God',
                    'value': 'blood_of_the_old_god',
                },
                {
                    'label': 'Darkmoon Card: Greatness (Strength)',
                    'value': 'dmcg_str',
                },
                {
                    'label': 'Darkmoon Card: Greatness (Agility)',
                    'value': 'dmcg_agi',
                },
                {'label': 'Grim Toll', 'value': 'grim_toll'},
                {'label': 'Mirror of Truth', 'value': 'mirror'},
                {'label': "Loatheb's Shadow", 'value': 'loatheb'},
                {'label': 'Meteorite Whetstone', 'value': 'whetstone'},
                {
                    'label': 'Fury of the Five Flights',
                    'value': 'fury_of_the_five_flights',
                },
                {'label': 'Incisor Fragment', 'value': 'incisor_fragment'},
                {'label': 'Mark of Norgannon', 'value': 'norgannon'},
                {'label': "Sphere of Red Dragon's Blood", 'value': 'sphere'},
                {'label': 'Extract of Necromantic Power', 'value': 'extract'},
                {'label': "Bandit's Insignia", 'value': 'bandits_insignia'},
                {'label': 'Blackened Naaru Sliver', 'value': 'bns'},
                {'label': 'Darkmoon Card: Death', 'value': 'dmcd'},
                {'label': 'Tears of Anguish', 'value': 'tears'},
                {
                    'label': 'Gnomish Lightning Generator',
                    'value': 'lightning_generator'
                },
                {
                    'label': "Mighty Alchemist's Stone",
                    'value': 'mighty_alch'
                },
                {'label': "Fezzik's Pocketwatch", 'value': 'fezzik'},
                {'label': "Berserker's Call", 'value': 'berserkers_call'},
                {'label': 'Vestige of Haldor', 'value': 'vestige'},
                {'label': 'Madness of the Betrayer', 'value': 'madness'},
                {'label': 'Shard of Contempt', 'value': 'shard_of_contempt'},
            ],
            value='deaths_verdict_heroic'
        )),
    ]),
    html.Div([
        dbc.Row([
            dbc.Col(
                dcc.Markdown('Put trinket on ICD (ignored if 0)'),
                id="trinket_icd_text_1"
            ),
            dbc.Col(
                dcc.Markdown('Put trinket on ICD (ignored if 0)'),
                id="trinket_icd_text_2"
            ),
        ], style={'marginTop': '1.5%', 'marginBottom': '-2%'}),
        dbc.Row([
            dbc.Col(dbc.InputGroup(
                [
                    dbc.Input(
                        value=0.0, min=0.0, step=0.5, type='number', 
                        id='trinket_icd_precombat_1',
                    ),
                    dbc.InputGroupAddon(
                        'seconds before combat', addon_type='append'
                    ),
                ],
                id="trinket_icd_group_1"
            )),
            dbc.Col(dbc.InputGroup(
                [
                    dbc.Input(
                        value=0.0, min=0.0, step=0.5, type='number', 
                        id='trinket_icd_precombat_2',
                    ),
                    dbc.InputGroupAddon(
                        'seconds before combat', addon_type='append'
                    ),
                ],
                id="trinket_icd_group_2"
            )),
        ]),
    ], id="trinket_icd_section"),
    dbc.Tooltip(
        """Putting a trinket on ICD (internal cooldown) will prevent the trinket
            from activating until its cooldown has ended. This can be useful when
            attempting to line up trinket procs with other combat effects. Typically
            done by equipping trinkets before combat.""",
        target="trinket_icd_section"
    ),
    html.Div(
        'Make sure not to include passive trinket stats in the sim input.',
        style={
            'marginTop': '2.5%', 'fontSize': 'large', 'fontWeight': 'bold'
        },
    ),
    html.Div([
        dbc.Button(
            "Run", id='run_button', n_clicks=0, size='lg', color='success',
            style={
                'marginBottom': '10%', 'fontSize': 'large', 'marginTop': '10%',
                'display': 'inline-block'
            }
        ),
        html.Div(
            '', id='status',
            style={
                'display': 'inline-block', 'fontWeight': 'bold',
                'marginLeft': '10%', 'fontSize': 'large'
            }
        )
    ]),
    dcc.Interval(id='interval', interval=500),
], width='auto', style={'marginBottom': '2.5%', 'marginLeft': '2.5%'})

input_layout = html.Div(children=[
    html.H1(
        children='WoW Classic WotLK Feral Cat Simulator',
        style={'textAlign': 'center'}
    ),
    dbc.Row(
        [stat_input, buffs_1, encounter_details, iteration_input],
        style={'marginTop': '2.5%'}
    ),
])

stats_output = dbc.Col(
    [html.H4('Raid Buffed Stats'),
     html.Div([
         html.Div(
             'Swing Timer:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_swing_timer'
         )
     ]),
     html.Div([
         html.Div(
             'Attack Power:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_attack_power'
         )
     ]),
     html.Div([
         html.Div(
             'Armor Penetration Rating:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_arp'
         )
     ]),
     html.Div([
         html.Div(
             'Boss Crit Chance:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_crit'
         )
     ]),
     html.Div([
         html.Div(
             'Boss Miss Chance:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_miss'
         )
     ]),
     html.Div([
         html.Div(
             'Mana:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_mana'
         )
     ]),
     html.Div([
         html.Div(
             'Intellect:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_int'
         )
     ]),
     html.Div([
         html.Div(
             'Spirit:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_spirit'
         )
     ]),
     html.Div([
         html.Div(
             'MP5:',
             style={'width': '50%', 'display': 'inline-block',
                    'fontWeight': 'bold', 'fontSize': 'large'}
         ),
         html.Div(
             '',
             style={'width': '50%', 'display': 'inline-block',
                    'fontSize': 'large'},
             id='buffed_mp5'
         )
     ])],
    width=4, xl=3, style={'marginLeft': '2.5%', 'marginBottom': '2.5%'}
)

sim_output = dbc.Col([
    html.H4('Results'),
    dcc.Loading(children=html.Div([
        html.Div(
            'Average DPS:',
            style={
                'width': '50%', 'display': 'inline-block',
                'fontWeight': 'bold', 'fontSize': 'large'
            }
        ),
        html.Div(
            '',
            style={
                'width': '50%', 'display': 'inline-block', 'fontSize': 'large'
            },
            id='mean_std_dps'
        ),
    ]), id='loading_1', type='default'),
    dcc.Loading(children=html.Div([
        html.Div(
            'Median DPS:',
            style={
                'width': '50%', 'display': 'inline-block',
                'fontWeight': 'bold', 'fontSize': 'large'
            }
        ),
        html.Div(
            '',
            style={
                'width': '50%', 'display': 'inline-block', 'fontSize': 'large'
            },
            id='median_dps'
        ),
    ]), id='loading_2', type='default'),
    dcc.Loading(children=html.Div([
        html.Div(
            'Time to oom:',
            style={
                'width': '50%', 'display': 'inline-block',
                'fontWeight': 'bold', 'fontSize': 'large'
            }
        ),
        html.Div(
            '',
            style={
                'width': '50%', 'display': 'inline-block', 'fontSize': 'large'
            },
            id='time_to_oom'
        ),
    ]), id='loading_oom_time', type='default'),
    html.Br(),
    html.H5('DPS Breakdown'),
    dcc.Loading(children=dbc.Table([
        html.Thead(html.Tr([
            html.Th('Ability'), html.Th('Number of Casts'), html.Th('CPM'),
            html.Th('Damage per Cast'), html.Th('DPS Contribution')
        ])),
        html.Tbody(id='dps_breakdown_table')
    ]), id='loading_3', type='default'),
    html.Br(),
    html.H5('Aura Statistics'),
    dcc.Loading(children=dbc.Table([
        html.Thead(html.Tr([
            html.Th('Aura Name'), html.Th('Number of Procs'),
            html.Th('Average Uptime'),
        ])),
        html.Tbody(id='aura_breakdown_table')
    ]), id='loading_auras', type='default'),
    html.Br(),
    html.Br()
], style={'marginLeft': '2.5%', 'marginBottom': '2.5%'}, width=4, xl=3)

weights_section = dbc.Col([
    html.H4('Stat Weights'),
    html.Div([
        dbc.Row(
            [
                dbc.Col(dbc.Button(
                    'Calculate Weights', id='weight_button', n_clicks=0,
                    color='info'
                ), width='auto'),
                dbc.Col(
                    [
                        dbc.FormGroup(
                            [
                                dbc.Checkbox(
                                    id='epic_gems',
                                    className='form-check-input', checked=True
                                ),
                                dbc.Label(
                                    'Assume Epic gems',
                                    html_for='epic_gems',
                                    className='form-check-label'
                                )
                            ],
                            check=True
                        ),
                    ],
                    width='auto'
                )
            ]
        ),
        html.Div(
            'Calculation will take several minutes.',
            style={'fontWeight': 'bold'},
        ),
        dcc.Loading(
            children=[
                html.P(
                    children=[
                        html.Strong(
                            'Error: ', style={'fontSize': 'large'},
                            id='error_str'
                        ),
                        html.Span(
                            'Stat weight calculation requires the simulation '
                            'to be run with at least 20,000 replicates.',
                            style={'fontSize': 'large'}, id='error_msg'
                        )
                    ],
                    style={'marginTop': '4%'},
                ),
                dbc.Table([
                    html.Thead(html.Tr([
                        html.Th('Stat Increment'), html.Th('DPS Added'),
                        html.Th('Normalized Weight')
                    ])),
                    html.Tbody(id='stat_weight_table'),
                ]),
                html.Div(
                    html.A(
                        'Seventy Upgrades Import Link',
                        href='https://seventyupgrades.com', target='_blank'
                    ),
                    id='import_link'
                )
            ],
            id='loading_4', type='default'
        ),
    ]),
], style={'marginLeft': '5%', 'marginBottom': '2.5%'}, width=4, xl=3)

sim_section = dbc.Row(
    [stats_output, sim_output, weights_section]
)

graph_section = html.Div([
    dbc.Row(
        [
            dbc.Col(
                dbc.Button(
                    "Generate Example", id='graph_button', n_clicks=0,
                    color='info',
                    style={'marginLeft': '2.5%', 'fontSize': 'large'}
                ),
                width='auto'
            ),
            dbc.Col(
                dbc.FormGroup(
                    [
                        dbc.Checkbox(
                            id='show_whites', className='form-check-input'
                        ),
                        dbc.Label(
                            'Show white damage', html_for='show_whites',
                            className='form-check-label'
                        )
                    ],
                    check=True
                ),
                width='auto'
            )
        ]
    ),
    html.H4(
        'Example of energy flow in a fight', style={'textAlign': 'center'}
    ),
    dcc.Graph(id='energy_flow'),
    html.Br(),
    dbc.Col(
        [
            html.H5('Combat Log'),
            dbc.Table([
                html.Thead(html.Tr([
                    html.Th('Time'), html.Th('Event'), html.Th('Outcome'),
                    html.Th('Energy'), html.Th('Combo Points'),
                    html.Th('Mana'), html.Th('Rage')
                ])),
                html.Tbody(id='combat_log')
            ])
        ],
        width=5, xl=4, style={'marginLeft': '2.5%'}
    )
])

app.layout = html.Div([
    input_layout, sim_section, graph_section
])


# Helper functions used in master callback
def process_trinkets(
        trinket_1, trinket_2, player, ap_mod, stat_mod, haste_multiplier,
        cd_delay, trinket_icd_precombat_1, trinket_icd_precombat_2
):
    proc_trinkets = []
    all_trinkets = []

    for slot, trinket in enumerate([trinket_1, trinket_2]):
        if trinket == 'none':
            continue

        trinket_params = copy.deepcopy(trinkets.trinket_library[trinket])

        for stat, increment in trinket_params['passive_stats'].items():
            if stat == 'intellect':
                increment *= 1.2  # hardcode the HotW 20% increase
            if stat in ['strength', 'agility', 'intellect', 'spirit']:
                increment *= stat_mod
            if stat == 'strength':
                increment *= 2
                stat = 'attack_power'
            if stat == 'agility':
                stat = 'attack_power'
                # additionally modify crit here
                setattr(
                    player, 'crit_chance',
                    getattr(player, 'crit_chance') + increment / 83.33 / 100.
                )
                player.agility += increment
            if stat == 'attack_power':
                increment *= ap_mod
            if stat == 'haste_rating':
                new_haste_rating = increment + sim_utils.calc_haste_rating(
                    player.swing_timer, multiplier=haste_multiplier
                )
                new_swing_timer = sim_utils.calc_swing_timer(
                    new_haste_rating, multiplier=haste_multiplier
                )
                player.swing_timer = new_swing_timer
                continue

            setattr(player, stat, getattr(player, stat) + increment)

        if trinket_params['type'] == 'passive':
            continue

        active_stats = trinket_params['active_stats']

        if active_stats['stat_name'] == 'attack_power':
            active_stats['stat_increment'] *= ap_mod
        if active_stats['stat_name'] == 'Agility':
            active_stats['stat_name'] = [
                'agility', 'attack_power', 'crit_chance'
            ]
            agi_increment = active_stats['stat_increment']
            active_stats['stat_increment'] = np.array([
                stat_mod * agi_increment,
                stat_mod * agi_increment * ap_mod,
                stat_mod * agi_increment/83.33/100.
            ])
        if active_stats['stat_name'] == 'Strength':
            active_stats['stat_name'] = 'attack_power'
            active_stats['stat_increment'] *= 2 * stat_mod * ap_mod

        if trinket_params['type'] == 'activated':
            # If this is the second trinket slot and the first trinket was also
            # activated, then we need to enforce an activation delay due to the
            # shared cooldown. For now we will assume that the shared cooldown
            # is always equal to the duration of the first trinket's proc.
            if all_trinkets and (not proc_trinkets):
                delay = cd_delay + all_trinkets[-1].proc_duration
            else:
                delay = cd_delay

            all_trinkets.append(
                trinkets.ActivatedTrinket(delay=delay, **active_stats)
            )
        else:
            proc_type = active_stats.pop('proc_type')

            if proc_type == 'chance_on_hit':
                proc_chance = active_stats.pop('proc_rate')
                active_stats['chance_on_hit'] = proc_chance
                active_stats['chance_on_crit'] = proc_chance
            elif proc_type == 'chance_on_crit':
                active_stats['chance_on_hit'] = 0.0
                active_stats['chance_on_crit'] = active_stats.pop('proc_rate')
            elif proc_type == 'ppm':
                ppm = active_stats.pop('proc_rate')
                active_stats['chance_on_hit'] = ppm/60.
                active_stats['yellow_chance_on_hit'] = ppm/60.

            if slot == 0:
                icd_precombat = trinket_icd_precombat_1
            else:
                icd_precombat = trinket_icd_precombat_2

            if trinket == 'dbw':
                trinket_obj = trinkets.DeathbringersWill(
                    stat_mod, ap_mod, icd_precombat=icd_precombat,
                    **active_stats
                )
            elif trinket_params['type'] == 'instant_damage':
                trinket_obj = trinkets.InstantDamageProc(
                    **active_stats, icd_precombat=icd_precombat
                )
            elif trinket_params['type'] == 'refreshing_proc':
                trinket_obj = trinkets.RefreshingProcTrinket(**active_stats)
            elif trinket_params['type'] == 'stacking_proc':
                trinket_obj = trinkets.StackingProcTrinket(**active_stats)
            else:
                trinket_obj = trinkets.ProcTrinket(
                    **active_stats, icd_precombat=icd_precombat
                )

            all_trinkets.append(trinket_obj)
            proc_trinkets.append(all_trinkets[-1])

    player.proc_trinkets = proc_trinkets
    return all_trinkets


def create_player(
        buffed_agility, buffed_attack_power, buffed_hit, buffed_spell_hit, buffed_crit,
        buffed_spell_crit, buffed_weapon_damage, haste_rating, expertise_rating, 
        armor_pen_rating, buffed_mana_pool, buffed_int, buffed_spirit, buffed_mp5, 
        weapon_speed, unleashed_rage, kings, raven_idol, other_buffs, stat_debuffs,
        cooldowns, bonuses, binary_talents, naturalist, feral_aggression,
        savage_fury, potp, predatory_instincts, improved_mangle, imp_motw, furor,
        natural_shapeshifter, ilotp, potion, gotw_targets
):
    """Takes in raid buffed player stats from Eighty Upgrades, modifies them
    based on boss debuffs and miscellaneous buffs not captured by Eighty
    Upgrades, and instantiates a Player object with those stats."""

    # Swing timer calculation is independent of other buffs. First we add up
    # the haste rating from all the specified haste buffs
    buffed_haste_rating = haste_rating
    haste_multiplier = (
        (1 + 0.2 * ('major_haste' in other_buffs))
        * (1 + 0.03 * ('minor_haste' in other_buffs))
    )
    buffed_swing_timer = sim_utils.calc_swing_timer(
        buffed_haste_rating, multiplier=haste_multiplier
    )

    # Also calculate hasted spell GCD for use when flowershifting
    spell_haste_multiplier = (
        (1 + 0.03 * ('minor_haste' in other_buffs))
        * (1 + 0.05 * ('spell_haste' in other_buffs))
    )

    # Augment secondary stats as needed
    ap_mod = 1.1 * (1 + 0.1 * unleashed_rage)
    debuff_ap = 0
    encounter_crit = (
        buffed_crit + 3 * ('jotc' in stat_debuffs)
        + (28 * ('be_chain' in other_buffs) + 40 * bool(raven_idol)) / 45.91
    )
    encounter_spell_crit = (
        buffed_spell_crit + 3 * ('jotc' in stat_debuffs)
        + 5 * ('shadow_mastery' in stat_debuffs)
        + (28 * ('be_chain' in other_buffs) + 40 * bool(raven_idol)) / 45.91
    )
    encounter_hit = buffed_hit
    encounter_spell_hit = (buffed_spell_hit + 3 * ('misery' in stat_debuffs))
    encounter_mp5 = (
        buffed_mp5 + 0.01 * buffed_mana_pool * ('replenishment' in other_buffs)
    )

    # Calculate bonus damage parameters
    encounter_weapon_damage = buffed_weapon_damage
    damage_multiplier = (
        (1 + 0.02 * int(naturalist))
        * (1 + 0.03 * ('sanc_aura' in other_buffs))
    )
    spell_damage_multiplier = (1 + 0.03 * ('sanc_aura' in other_buffs))
    shred_bonus = 203 * ('shred_idol' in bonuses)
    rip_bonus = 21 * ('rip_idol' in bonuses)

    # Create and return a corresponding Player object
    player = player_class.Player(
        attack_power=buffed_attack_power, ap_mod=ap_mod,
        agility=buffed_agility, hit_chance=encounter_hit / 100, 
        spell_crit_chance=encounter_spell_crit / 100,
        spell_hit_chance=encounter_spell_hit / 100,
        expertise_rating=expertise_rating, crit_chance=encounter_crit / 100,
        swing_timer=buffed_swing_timer, mana=buffed_mana_pool,
        intellect=buffed_int, spirit=buffed_spirit, mp5=encounter_mp5,
        omen='omen' in binary_talents,
        primal_gore='primal_gore' in binary_talents,
        feral_aggression=int(feral_aggression), savage_fury=int(savage_fury),
        potp=int(potp), predatory_instincts=int(predatory_instincts),
        improved_mangle=int(improved_mangle), furor=int(furor),
        natural_shapeshifter=int(natural_shapeshifter),
        ilotp=int(ilotp), weapon_speed=weapon_speed,
        bonus_damage=encounter_weapon_damage, multiplier=damage_multiplier,
        spell_damage_multiplier=spell_damage_multiplier,
        jow='jow' in stat_debuffs, armor_pen_rating=armor_pen_rating,
        t6_2p='t6_2p' in bonuses, t6_4p='t6_4p' in bonuses,
        t7_2p='t7_2p' in bonuses, t8_2p='t8_2p' in bonuses,
        t8_4p='t8_4p' in bonuses, t9_2p='t9_2p' in bonuses,
        t9_4p='t9_4p' in bonuses, t10_2p='t10_2p' in bonuses, 
        t10_4p='t10_4p' in bonuses, wolfshead='wolfshead' in bonuses,
        mangle_glyph='mangle_glyph' in bonuses,
        meta='meta' in bonuses, rune='rune' in cooldowns,
        shred_bonus=shred_bonus, rip_bonus=rip_bonus, debuff_ap=debuff_ap,
        roar_glyph='roar_glyph' in bonuses,
        berserk_glyph='berserk_glyph' in bonuses,
        rip_glyph='rip_glyph' in bonuses, shred_glyph='shred_glyph' in bonuses,
        gotw_targets=int(gotw_targets)
    )
    player.update_spell_gcd(
        buffed_haste_rating, multiplier=spell_haste_multiplier
    )
    stat_mod = (1 + 0.1 * kings) * 1.06 * (1 + 0.01 * imp_motw)
    return player, ap_mod, stat_mod, haste_multiplier


def apply_buffs(
        unbuffed_ap, unbuffed_strength, unbuffed_agi, unbuffed_hit, 
        unbuffed_spell_hit, unbuffed_crit, unbuffed_spell_crit,
        unbuffed_arp, unbuffed_mana, unbuffed_int, unbuffed_spirit, 
        unbuffed_mp5, weapon_damage, raid_buffs, consumables, imp_motw
):
    """Takes in unbuffed player stats, and turns them into buffed stats based
    on specified consumables and raid buffs. This function should only be
    called if the "Buffs" option is not checked in the exported file from
    Eighty Upgrades, or else the buffs will be double counted!"""

    # Determine "raw" AP, crit, and mana not from Str/Agi/Int
    raw_ap_unbuffed = unbuffed_ap / 1.1 - 2 * unbuffed_strength - unbuffed_agi
    raw_crit_unbuffed = unbuffed_crit - unbuffed_agi / 83.33
    raw_spell_crit_unbuffed = unbuffed_spell_crit - unbuffed_int / 166.67
    raw_mana_unbuffed = unbuffed_mana - 15 * unbuffed_int

    # Augment all base stats based on specified buffs
    gear_multi = 1.06 * (1 + 0.01 * imp_motw)
    stat_multiplier = 1 + 0.1 * ('kings' in raid_buffs)
    added_stats = 51 * ('motw' in raid_buffs)

    buffed_strength = stat_multiplier * (unbuffed_strength + gear_multi * (
        added_stats + 155 * ('str_totem' in raid_buffs)
        + 40 * ('str_food' in consumables)
    ))
    buffed_agi = stat_multiplier * (unbuffed_agi + gear_multi * (
        added_stats + 155 * ('str_totem' in raid_buffs)
        + 40 * ('agi_food' in consumables)
    ))
    buffed_int = stat_multiplier * (unbuffed_int + 1.2 * gear_multi * (
        added_stats + 60 * ('ai' in raid_buffs)
    ))
    buffed_spirit = stat_multiplier * (unbuffed_spirit + gear_multi * (
        added_stats + 80 * ('spirit' in raid_buffs)
    ))

    # Now augment secondary stats
    ap_mod = 1.1 * (1 + 0.1 * ('unleashed_rage' in raid_buffs))
    buffed_attack_power = ap_mod * (
        raw_ap_unbuffed + 2 * buffed_strength + buffed_agi
        + 550 * 1.25 * ('might' in raid_buffs) + 180 * ('flask' in consumables)
    )
    added_crit_rating = 14 * ('weightstone' in consumables)
    buffed_crit = (
        raw_crit_unbuffed + buffed_agi / 83.33 + added_crit_rating / 45.91
    )
    buffed_spell_crit = (
        raw_spell_crit_unbuffed + buffed_int / 166.67 
        + added_crit_rating / 45.91 + 5 * ('moonkin_aura' in raid_buffs)
    )
    buffed_hit = (
        unbuffed_hit + 1 * ('heroic_presence' in raid_buffs)
        + 40 / 32.79 * ('hit_food' in consumables)
    )
    buffed_spell_hit = (
        unbuffed_spell_hit + 1 * ('heroic_presence' in raid_buffs) \
            + 40 / 26.23 * ('hit_food' in consumables)
    )
    buffed_mana_pool = raw_mana_unbuffed + buffed_int * 15
    buffed_mp5 = unbuffed_mp5 + 110 * ('wisdom' in raid_buffs)
    buffed_weapon_damage = (
        12 * ('weightstone' in consumables) + weapon_damage
    )
    buffed_arp = unbuffed_arp + 40 * ('arp_food' in consumables)

    return {
        'strength': buffed_strength,
        'agility': buffed_agi,
        'intellect': buffed_int,
        'spirit': buffed_spirit,
        'attackPower': buffed_attack_power,
        'crit': buffed_crit,
        'spellCrit': buffed_spell_crit,
        'hit': buffed_hit,
        'spellHit': buffed_spell_hit,
        'weaponDamage': buffed_weapon_damage,
        'mana': buffed_mana_pool,
        'mp5': buffed_mp5,
        'armorPenRating': buffed_arp
    }


def run_sim(sim, num_replicates):
    # Run the sim for the specified number of replicates
    dps_vals, dmg_breakdown, aura_stats, oom_times = sim.run_replicates(
        num_replicates, detailed_output=True
    )

    # Consolidate DPS statistics
    avg_dps = np.mean(dps_vals)
    mean_dps_str = '%.1f +/- %.1f' % (avg_dps, np.std(dps_vals))
    median_dps_str = '%.1f' % np.median(dps_vals)

    # Consolidate mana statistics
    avg_oom_time = np.mean(oom_times)

    if avg_oom_time > sim.fight_length - 1:
        oom_time_str = 'none'
    else:
        oom_time_str = (
            '%d +/- %d seconds' % (avg_oom_time, np.std(oom_times))
        )

    # Create DPS breakdown table
    dps_table = []

    for ability in dmg_breakdown:
        if ability in ['Claw']:
            continue

        ability_dps = dmg_breakdown[ability]['damage'] / sim.fight_length
        ability_cpm = dmg_breakdown[ability]['casts'] / sim.fight_length * 60.
        ability_dpct = ability_dps * 60. / ability_cpm if ability_cpm else 0.
        dps_table.append(html.Tr([
            html.Td(ability),
            html.Td('%.3f' % dmg_breakdown[ability]['casts']),
            html.Td('%.1f' % ability_cpm),
            html.Td('%.0f' % ability_dpct),
            html.Td('%.1f%%' % (ability_dps / avg_dps * 100))
        ]))

    # Create Aura uptime table
    aura_table = []

    for row in aura_stats:
        aura_table.append(html.Tr([
            html.Td(row[0]),
            html.Td('%.3f' % row[1]),
            html.Td('%.1f%%' % (row[2] * 100))
        ]))

    return (
        dps_vals,
        (mean_dps_str, median_dps_str, oom_time_str, dps_table, aura_table),
    )


def calc_weights(
        sim, num_replicates, dps_vals, time_to_oom, kings, unleashed_rage,
        epic_gems, imp_motw
):
    # Check that sufficient iterations are used for convergence.
    if num_replicates < 20000:
        error_msg = (
            'Stat weight calculation requires the simulation to be run with at'
            ' least 20,000 replicates.'
        )
        return 'Error: ', error_msg, [], ''

    # Do fresh weights calculation
    weights_table = []

    # Calculate DPS increases and weights
    stat_multiplier = (1 + 0.1 * kings) * 1.06 * (1 + 0.01 * imp_motw)
    dps_deltas, stat_weights = sim.calc_stat_weights(
        num_replicates, base_dps_sample=dps_vals, agi_mod=stat_multiplier
    )

    # Parse results
    for stat in dps_deltas:
        if stat == 'Attack Power':
            weight = 1.0
            dps_per_AP = dps_deltas[stat]
        else:
            weight = stat_weights[stat]

        weights_table.append(html.Tr([
            html.Td(stat),
            html.Td('%.2f' % dps_deltas[stat]),
            html.Td('%.2f' % weight),
        ]))

    # Generate 80upgrades import link for raw stats
    url = sim_utils.gen_import_link(
        dps_deltas, multiplier=stat_multiplier, epic_gems=epic_gems
    )
    link = html.A('Eighty Upgrades Import Link', href=url, target='_blank')

    return 'Stat Breakdown', '', weights_table, link


def plot_new_trajectory(sim, show_whites):
    t_vals, _, energy_vals, cp_vals, _, _, log = sim.run(log=True)
    t_fine = np.linspace(0, sim.fight_length, 10000)
    fig = go.Figure()
    fig.add_trace(go.Scatter(
        x=t_fine, y=sim_utils.piecewise_eval(t_fine, t_vals, energy_vals),
        line=dict(color="#d62728")
    ))
    fig.add_trace(go.Scatter(
        x=t_fine, y=sim_utils.piecewise_eval(t_fine, t_vals, cp_vals),
        line=dict(color="#9467bd", dash='dash'), yaxis='y2'
    ))
    fig.update_layout(
        xaxis=dict(title='Time (seconds)'),
        yaxis=dict(
            title='Energy', titlefont=dict(color='#d62728'),
            tickfont=dict(color='#d62728')
        ),
        yaxis2=dict(
            title='Combo points', titlefont=dict(color='#9467bd'),
            tickfont=dict(color='#9467bd'), anchor='x', overlaying='y',
            side='right'
        ),
        showlegend=False,
    )

    # Create combat log table
    log_table = []

    if not show_whites:
        parsed_log = [row for row in log if row[1] != 'melee']
    else:
        parsed_log = log

    for row in parsed_log:
        log_table.append(html.Tr([
            html.Td(entry) for entry in row
        ]))

    return fig, log_table


# Master callback function
@app.callback(
    Output('upload_status', 'children'),
    Output('upload_status', 'style'),
    Output('buff_section', 'is_open'),
    Output('buffed_swing_timer', 'children'),
    Output('buffed_attack_power', 'children'),
    Output('buffed_arp', 'children'),
    Output('buffed_crit', 'children'),
    Output('buffed_miss', 'children'),
    Output('buffed_mana', 'children'),
    Output('buffed_int', 'children'),
    Output('buffed_spirit', 'children'),
    Output('buffed_mp5', 'children'),
    Output('mean_std_dps', 'children'),
    Output('median_dps', 'children'),
    Output('time_to_oom', 'children'),
    Output('dps_breakdown_table', 'children'),
    Output('aura_breakdown_table', 'children'),
    Output('error_str', 'children'),
    Output('error_msg', 'children'),
    Output('stat_weight_table', 'children'),
    Output('import_link', 'children'),
    Output('energy_flow', 'figure'),
    Output('combat_log', 'children'),
    Input('upload-data', 'contents'),
    Input('consumables', 'value'),
    Input('raid_buffs', 'value'),
    Input('other_buffs', 'value'),
    Input('raven_idol', 'value'),
    Input('stat_debuffs', 'value'),
    Input('imp_motw', 'value'),
    Input('trinket_1', 'value'),
    Input('trinket_2', 'value'),
    Input('trinket_icd_precombat_1', 'value'),
    Input('trinket_icd_precombat_2', 'value'),
    Input('run_button', 'n_clicks'),
    Input('weight_button', 'n_clicks'),
    Input('graph_button', 'n_clicks'),
    State('hot_uptime', 'value'),
    State('potion', 'value'),
    State('bonuses', 'value'),
    State('binary_talents', 'value'),
    State('feral_aggression', 'value'),
    State('savage_fury', 'value'),
    State('potp', 'value'),
    State('predatory_instincts', 'value'),
    State('improved_mangle', 'value'),
    State('furor', 'value'),
    State('naturalist', 'value'),
    State('natural_shapeshifter', 'value'),
    State('ilotp', 'value'),
    State('fight_length', 'value'),
    State('boss_armor', 'value'),
    State('num_targets', 'value'),
    State('boss_debuffs', 'value'),
    State('cooldowns', 'value'),
    State('rip_cp', 'value'),
    State('bite_cp', 'value'),
    State('cd_delay', 'value'),
    State('min_roar_offset', 'value'),
    State('roar_clip_leeway', 'value'),
    State('use_rake', 'value'),
    State('mangle_spam', 'value'),
    State('use_biteweave', 'value'),
    State('bite_model', 'value'),
    State('bite_time', 'value'),
    State('bear_mangle', 'value'),
    State('prepop_berserk', 'value'),
    State('preproc_omen', 'value'),
    State('bearweave', 'value'),
    State('berserk_bite_thresh', 'value'),
    State('berserk_ff_thresh', 'value'),
    State('max_ff_delay', 'value'),
    State('lacerate_prio', 'value'),
    State('lacerate_time', 'value'),
    State('powerbear', 'value'),
    State('snek', 'value'),
    State('flowershift', 'value'),
    State('gotw_targets', 'value'),
    State('daggerweave', 'value'),
    State('dagger_ep_loss', 'value'),
    State('num_replicates', 'value'),
    State('latency', 'value'),
    State('epic_gems', 'checked'),
    State('show_whites', 'checked'))
def compute(
        json_file, consumables, raid_buffs, other_buffs, raven_idol,
        stat_debuffs, imp_motw, trinket_1, trinket_2, trinket_icd_precombat_1, 
        trinket_icd_precombat_2, run_clicks, 
        weight_clicks, graph_clicks, hot_uptime, potion, bonuses,
        binary_talents, feral_aggression, savage_fury, potp,
        predatory_instincts, improved_mangle, furor, naturalist,
        natural_shapeshifter, ilotp, fight_length, boss_armor, num_targets,
        boss_debuffs, cooldowns, rip_cp, bite_cp, cd_delay,
        min_roar_offset, roar_clip_leeway, use_rake, mangle_spam,
        use_biteweave, bite_model, bite_time, bear_mangle, prepop_berserk,
        preproc_omen, bearweave, berserk_bite_thresh, berserk_ff_thresh,
        max_ff_delay, lacerate_prio, lacerate_time, powerbear, snek,
        flowershift, gotw_targets, daggerweave, dagger_ep_loss, num_replicates,
        latency, epic_gems, show_whites
):
    ctx = dash.callback_context

    # Parse input stats JSON
    imp_motw = int(imp_motw)
    buffs_present = False
    use_default_inputs = True

    if json_file is None:
        upload_output = (
            'No file uploaded, using default input stats instead.',
            {'color': '#E59F3A', 'width': 300}, True
        )
    else:
        try:
            content_type, content_string = json_file.split(',')
            decoded = base64.b64decode(content_string)
            input_json = json.load(io.StringIO(decoded.decode('utf-8')))
            buffs_present = input_json['exportOptions']['buffs']
            catform_checked = (
                ('form' in input_json['exportOptions'])
                and (input_json['exportOptions']['form'] == 'cat')
            )

            if not catform_checked:
                upload_output = (
                    'Error processing input file! "Cat Form" was not checked '
                    'in the export pop-up window. Using default input stats '
                    'instead.',
                    {'color': '#D35845', 'width': 300}, True
                )
            elif buffs_present:
                pot_present = False

                for entry in input_json['consumables']:
                    if 'Potion' in entry['name']:
                        pot_present = True

                if pot_present:
                    upload_output = (
                        'Error processing input file! Potions should not be '
                        'checked in the Seventy Upgrades buff tab, as they are'
                        ' temporary rather than permanent stat buffs. Using'
                        ' default input stats instead.',
                        {'color': '#D35845', 'width': 300}, True
                    )
                else:
                    upload_output = (
                        'Upload successful. Buffs detected in Seventy Upgrades'
                        ' export, so the "Consumables" and "Raid Buffs" '
                        'sections in the sim input will be ignored.',
                        {'color': '#5AB88F', 'width': 300}, False
                    )
                    use_default_inputs = False
            else:
                upload_output = (
                    'Upload successful. No buffs detected in Seventy Upgrades '
                    'export, so use the  "Consumables" and "Raid Buffs" '
                    'sections in the sim input for buff entry.',
                    {'color': '#5AB88F', 'width': 300}, True
                )
                use_default_inputs = False
        except Exception:
            upload_output = (
                'Error processing input file! Using default input stats '
                'instead.',
                {'color': '#D35845', 'width': 300}, True
            )

    if use_default_inputs:
        input_stats = copy.copy(default_input_stats)
        buffs_present = False
    else:
        input_stats = input_json['stats']

    # If buffs are not specified in the input file, then interpret the input
    # stats as unbuffed and calculate the buffed stats ourselves.
    if not buffs_present:
        input_stats.update(apply_buffs(
            input_stats['attackPower'], input_stats['strength'],
            input_stats['agility'], input_stats['hit'], input_stats["spellHit"],
            input_stats['crit'], input_stats['spellCrit'], input_stats.get('armorPenRating', 0), 
            input_stats['mana'], input_stats['intellect'], input_stats['spirit'],
            input_stats.get('mp5', 0), input_stats.get('weaponDamage', 0),
            raid_buffs, consumables,imp_motw
        ))

    # Determine whether Unleashed Rage and/or Blessing of Kings are present, as
    # these impact stat weights and buff values.
    if buffs_present:
        unleashed_rage = False
        kings = False

        for buff in input_json['buffs']:
            if buff['name'] == 'Blessing of Kings':
                kings = True
            if buff['name'] == 'Unleashed Rage':
                unleashed_rage = True
    else:
        unleashed_rage = 'unleashed_rage' in raid_buffs
        kings = 'kings' in raid_buffs

    # Create Player object based on raid buffed stat inputs and talents
    player, ap_mod, stat_mod, haste_multiplier = create_player(
        input_stats['agility'], input_stats['attackPower'], input_stats['hit'],
        input_stats['spellHit'], input_stats['crit'], input_stats['spellCrit'],
        input_stats.get('weaponDamage', 0),
        input_stats.get('hasteRating', 0),
        input_stats.get('expertiseRating', 0),
        input_stats.get('armorPenRating', 0),input_stats['mana'],
        input_stats['intellect'], input_stats['spirit'],
        input_stats.get('mp5', 0), float(input_stats['mainHandSpeed']),
        unleashed_rage, kings, raven_idol, other_buffs, stat_debuffs,
        cooldowns, bonuses, binary_talents, naturalist, feral_aggression,
        savage_fury, potp, predatory_instincts, improved_mangle, imp_motw, furor,
        natural_shapeshifter, ilotp, potion, gotw_targets
    )

    # Process trinkets
    trinket_list = process_trinkets(
        trinket_1, trinket_2, player, ap_mod, stat_mod, haste_multiplier,
        cd_delay, trinket_icd_precombat_1, trinket_icd_precombat_2
    )

    # Default output is just the buffed player stats with no further calcs
    stats_output = (
        '%.3f seconds' % player.swing_timer,
        '%d' % player.attack_power,
        '%d' % player.armor_pen_rating,
        '%.2f %%' % (player.crit_chance * 100),
        '%.2f %%' % (player.miss_chance * 100),
        '%d' % player.mana_pool, '%d' % player.intellect,
        '%d' % player.spirit, '%d' % player.mp5
    )

    # Create Simulation object based on specified parameters
    bite = bool(use_biteweave)
    bite_time = None if bite_model == 'analytical' else bite_time
    rip_combos = int(rip_cp)

    if 'lust' in cooldowns:
        trinket_list.append(trinkets.Bloodlust(delay=cd_delay))
    if 'unholy_frenzy' in cooldowns:
        trinket_list.append(trinkets.UnholyFrenzy(delay=cd_delay))
    if 'shattering_throw' in cooldowns:
        trinket_list.append(trinkets.ShatteringThrow(delay=cd_delay))
    if 'wastes_idol' in bonuses:
        idol = trinkets.ProcTrinket(
            chance_on_hit=0.75, stat_name='attack_power',
            stat_increment=2 * stat_mod * ap_mod * 61, proc_duration=10,
            cooldown=10, proc_name='Snap and Snarl', shred_only=True,
            swipe_only=True
        )
        trinket_list.append(idol)
        player.proc_trinkets.append(idol)

    mutilation_idol = None

    if 'idol_of_mutilation' in bonuses:
        mutilation_idol = trinkets.RefreshingProcTrinket(
            chance_on_hit=0.70,
            stat_name=['agility', 'attack_power', 'crit_chance'],
            stat_increment=np.array([
                200. * stat_mod,
                200. * stat_mod * ap_mod,
                200. * stat_mod / 83.33 / 100.,
            ]),
            proc_duration=16, cooldown=8, proc_name='Mutilation',
            cat_mangle_only=True,
            shred_only=True
        )
        trinket_list.append(mutilation_idol)
        player.proc_trinkets.append(mutilation_idol)
    if 'mongoose' in bonuses:
        mongoose_ppm = 0.73
        mongoose_enchant = trinkets.RefreshingProcTrinket(
            stat_name=[
                'agility', 'attack_power', 'crit_chance', 'haste_rating'
            ],
            stat_increment=np.array([
                120. * stat_mod,
                120. * stat_mod * ap_mod,
                120. * stat_mod / 83.33 / 100.,
                30
            ]),
            proc_name='Lightning Speed', chance_on_hit=mongoose_ppm / 60.,
            yellow_chance_on_hit=mongoose_ppm / 60.,
            proc_duration=15, cooldown=0
        )
        trinket_list.append(mongoose_enchant)
        player.proc_trinkets.append(mongoose_enchant)
    if 'executioner' in bonuses:
        executioner_enchant = trinkets.RefreshingProcTrinket(
            stat_name='armor_pen_rating', stat_increment=120,
            proc_name='Executioner', chance_on_hit=1./60.,
            yellow_chance_on_hit=1./60., proc_duration=15, cooldown=0
        )
        trinket_list.append(executioner_enchant)
        player.proc_trinkets.append(executioner_enchant)
    if 'berserking' in bonuses:
        berserking_enchant = trinkets.RefreshingProcTrinket(
            stat_name='attack_power', stat_increment=400 * ap_mod,
            proc_name='Berserking', chance_on_hit=1./60.,
            yellow_chance_on_hit=1./60., proc_duration=15, cooldown=0
        )
        trinket_list.append(berserking_enchant)
        player.proc_trinkets.append(berserking_enchant)
    if 'engi_gloves' in bonuses:
        trinket_list.append(trinkets.ActivatedTrinket(
            'haste_rating', 340, 'Hyperspeed Acceleration', 12, 60,
            delay=cd_delay
        ))
    if 'ap_cloak' in bonuses:
        swordguard_embroidery = trinkets.ProcTrinket(
            stat_name='attack_power', stat_increment=400 * ap_mod,
            proc_name='Swordguard Embroidery', chance_on_hit=0.20,
            proc_duration=15, cooldown=55, chance_on_crit=0.2
        )
        trinket_list.append(swordguard_embroidery)
        player.proc_trinkets.append(swordguard_embroidery)

    if potion == 'haste':
        trinket_list.append(trinkets.HastePotion(delay=cd_delay))

    mangle_idol = None

    if 'mangle_idol' in bonuses:
        mangle_idol = trinkets.IdolOfTheCorruptor(stat_mod, ap_mod)
        trinket_list.append(mangle_idol)
        player.proc_trinkets.append(mangle_idol)

    rake_idol = None

    if 'rake_idol' in bonuses:
        agi_gain = 44. * stat_mod
        stack_increments = np.array([
            agi_gain, agi_gain * ap_mod, agi_gain / 83.33 / 100.
        ])
        rake_idol = trinkets.StackingProcTrinket(
            stat_name=['agility', 'attack_power', 'crit_chance'],
            stat_increment=stack_increments, max_stacks=5,
            aura_name='Idol of the Crying Moon', stack_name='Agile',
            chance_on_hit=0.0, yellow_chance_on_hit=1.0, aura_duration=1e9,
            cooldown=1e9
        )
        trinket_list.append(rake_idol)

    target_count = int(round(num_targets))
    allow_bearweave = bool(bearweave) and (target_count < 3)
    sim = ccs.Simulation(
        player, fight_length + 1e-9, 0.001 * latency, boss_armor=boss_armor,
        min_combos_for_rip=rip_combos, min_combos_for_bite=int(bite_cp),
        mangle_spam=bool(mangle_spam), use_rake=bool(use_rake), use_bite=bite,
        bite_time=bite_time, bear_mangle=bool(bear_mangle),
        use_berserk='berserk' in binary_talents,
        prepop_berserk=bool(prepop_berserk), preproc_omen=bool(preproc_omen),
        bearweave=allow_bearweave, berserk_bite_thresh=berserk_bite_thresh,
        berserk_ff_thresh=berserk_ff_thresh, max_ff_delay=max_ff_delay,
        lacerate_prio=bool(lacerate_prio), lacerate_time=lacerate_time,
        powerbear=bool(powerbear), snek=bool(snek) and allow_bearweave,
        flowershift=bool(flowershift), daggerweave=bool(daggerweave),
        dagger_ep_loss=dagger_ep_loss, min_roar_offset=min_roar_offset,
        roar_clip_leeway=roar_clip_leeway, num_targets=target_count,
        trinkets=trinket_list, haste_multiplier=haste_multiplier,
        hot_uptime=hot_uptime / 100., mangle_idol=mangle_idol,
        rake_idol=rake_idol, mutilation_idol=mutilation_idol
    )
    sim.set_active_debuffs(boss_debuffs)
    player.calc_damage_params(**sim.params)

    # If either "Run" or "Stat Weights" button was pressed, then perform a
    # sim run for the specified number of replicates.
    if (ctx.triggered and
            (ctx.triggered[0]['prop_id'] in
             ['run_button.n_clicks', 'weight_button.n_clicks'])):
        dps_vals, dps_output = run_sim(sim, num_replicates)
    else:
        dps_output = ('', '', '', [], [])

    # If "Stat Weights" button was pressed, then calculate weights.
    if (ctx.triggered and
            (ctx.triggered[0]['prop_id'] == 'weight_button.n_clicks')):
        weights_output = calc_weights(
            sim, num_replicates, dps_vals, dps_output[2], kings, unleashed_rage,
            epic_gems, imp_motw
        )
    else:
        weights_output = ('Stat Breakdown', '', [], '')

    # If "Generate Example" button was pressed, do it.
    if (ctx.triggered and
            (ctx.triggered[0]['prop_id'] == 'graph_button.n_clicks')):
        example_output = plot_new_trajectory(sim, show_whites)
    else:
        example_output = ({}, [])

    return (
        upload_output + stats_output + dps_output + weights_output
        + example_output
    )


# Callbacks for disabling rotation options when inappropriate
@app.callback(
    Output('bearweave_options', 'is_open'),
    Output('biteweave_options', 'is_open'),
    Output('berserk_options', 'is_open'),
    Output('omen_options', 'is_open'),
    Output('empirical_options', 'is_open'),
    Output('lacerate_options', 'is_open'),
    Output('bearweave', 'options'),
    Output('lacerate_prio', 'options'),
    Output('flowershift', 'options'),
    Output('flowershift_options', 'is_open'),
    Output('dagger_options', 'is_open'),
    Input('bearweave', 'value'),
    Input('flowershift', 'value'),
    Input('use_biteweave', 'value'),
    Input('bite_model', 'value'),
    Input('lacerate_prio', 'value'),
    Input('daggerweave', 'value'),
    Input('binary_talents', 'value'),
    Input('num_targets', 'value'))
def disable_options(
    bearweave, flowershift, biteweave, bite_model, lacerate_prio, daggerweave,
    binary_talents, num_targets
):
    bearweave_options = {'label': ' enable bearweaving', 'value': 'bearweave'}
    flowershift_options = {
        'label': ' enable flowershifting', 'value': 'flowershift'
    }
    lacerate_options = {
        'label': ' prioritize Lacerate maintenance over Mangle',
        'value': 'lacerate_prio'
    }

    # Disable Lacerateweave and flowershift in UI given recent Blizzard changes
    flowershift_options['disabled'] = False
    bearweave_options['disabled'] = (int(round(num_targets)) > 2)
    lacerate_options['disabled'] = True

    return (
        bool(bearweave), bool(biteweave), 'berserk' in binary_talents,
        'omen' in binary_talents, bite_model == 'empirical',
        bool(lacerate_prio), [bearweave_options], [lacerate_options],
        [flowershift_options], bool(flowershift), bool(daggerweave)
    )
    
#Callback for displaying trinket ICD options when appropriate
@app.callback(
    Output('trinket_icd_text_1', 'style'),
    Output('trinket_icd_group_1', 'style'),
    Output('trinket_icd_text_2', 'style'),
    Output('trinket_icd_group_2', 'style'),
    Output('trinket_icd_precombat_1', 'value'),
    Output('trinket_icd_precombat_2', 'value'),
    Input('trinket_1', 'value'),
    Input('trinket_2', 'value'),
    Input('trinket_icd_precombat_1', 'value'),
    Input('trinket_icd_precombat_2', 'value'),)
def show_trinket_ICD_options(trinket_1, trinket_2, trinket_icd_precombat_1, trinket_icd_precombat_2):
    show_trinket_1_ICD = trinket_1 != 'none' and trinkets.trinket_library[trinket_1]['type'] in ['proc','instant_damage']
    show_trinket_2_ICD = trinket_2 != 'none' and trinkets.trinket_library[trinket_2]['type'] in ['proc','instant_damage']
    trinket_1_style = {} if show_trinket_1_ICD else {'visibility':'hidden'} 
    trinket_2_style = {} if show_trinket_2_ICD else {'visibility':'hidden'}
    if not show_trinket_1_ICD:
        trinket_icd_precombat_1 = 0
    if not show_trinket_2_ICD:
        trinket_icd_precombat_2 = 0
    return (trinket_1_style, trinket_1_style, trinket_2_style, trinket_2_style, trinket_icd_precombat_1, trinket_icd_precombat_2)

if __name__ == '__main__':
    multiprocessing.freeze_support()
    app.run_server(
        host='0.0.0.0', port=8080, debug=True
    )