mage

var ItemSetChronomancerRegalia = core.NewItemSet(core.ItemSet{
	Name:                    "Chronomancer Regalia",
	DisabledInChallengeMode: true,
	Bonuses: map[int32]core.ApplySetBonus{

		2: func(agent core.Agent, setBonusAura *core.Aura) {
			mage := agent.(MageAgent).GetMage()

			arcaneBlastMod := mage.AddDynamicMod(core.SpellModConfig{
				Kind:       core.SpellMod_PowerCost_Pct,
				ClassMask:  MageSpellArcaneBlast,
				FloatValue: 0,
			})

			arcaneAura := mage.GetOrRegisterAura(core.Aura{
				Label:     "Profound Magic",
				ActionID:  core.ActionID{SpellID: 145252},
				Duration:  time.Second * 10,
				MaxStacks: 4,
				OnStacksChange: func(aura *core.Aura, sim *core.Simulation, oldStacks int32, newStacks int32) {
					arcaneBlastMod.UpdateFloatValue(0.25 * float64(newStacks))
				},
			})

			setBonusAura.MakeDependentProcTriggerAura(&mage.Unit, core.ProcTrigger{
				Name:           "Profound Magic - Consume",
				ClassSpellMask: MageSpellArcaneBlast,
				Callback:       core.CallbackOnSpellHitDealt,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					arcaneAura.Deactivate(sim)
				},
			})

			setBonusAura.MakeDependentProcTriggerAura(&mage.Unit, core.ProcTrigger{
				Name:           "Item - Mage T16 2P Bonus",
				ClassSpellMask: MageSpellArcaneMissilesCast,
				Callback:       core.CallbackOnSpellHitDealt,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					arcaneAura.Activate(sim)
					arcaneAura.AddStack(sim)
				},
			})

			fireAura := core.MakeStackingAura(&mage.Character, core.StackingStatAura{
				Aura: core.Aura{
					Label:     "Potent Flames",
					ActionID:  core.ActionID{SpellID: 145254},
					Duration:  time.Second * 5,
					MaxStacks: 5,
				},
				BonusPerStack: stats.Stats{stats.HasteRating: 750},
			})

			mage.OnSpellRegistered(func(spell *core.Spell) {
				if !spell.Matches(MageSpellPyroblast) {
					return
				}

				mage.InstantPyroblastAura.ApplyOnExpire(func(_ *core.Aura, sim *core.Simulation) {
					if setBonusAura.IsActive() {
						fireAura.Activate(sim)
						fireAura.AddStack(sim)
					}
				})
			})

			frostClassMask := MageSpellIceLance | MageSpellFrostbolt | MageSpellFrostfireBolt | MageSpellConeOfCold
			frostAura := mage.GetOrRegisterAura(core.Aura{
				Label:    "Frozen Thoughts",
				ActionID: core.ActionID{SpellID: 146557},
				Duration: time.Second * 15,
			}).AttachSpellMod(core.SpellModConfig{
				Kind:       core.SpellMod_DamageDone_Pct,
				ClassMask:  frostClassMask,
				FloatValue: 0.25,
			})

			setBonusAura.MakeDependentProcTriggerAura(&mage.Unit, core.ProcTrigger{
				Name:           "Frozen Thoughts - Consume",
				ClassSpellMask: frostClassMask,
				Callback:       core.CallbackOnSpellHitDealt,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					frostAura.Deactivate(sim)
				},
			})

			mage.OnSpellRegistered(func(spell *core.Spell) {
				if !spell.Matches(MageSpellFrostbolt) {
					return
				}
				if mage.BrainFreezeAura == nil {
					return
				}
				mage.BrainFreezeAura.ApplyOnExpire(func(_ *core.Aura, sim *core.Simulation) {
					if setBonusAura.IsActive() {
						frostAura.Activate(sim)
					}
				})
			})

			setBonusAura.ExposeToAPL(145251)
		},

		4: func(agent core.Agent, setBonusAura *core.Aura) {
			mage := agent.(MageAgent).GetMage()

			mage.T16_4pc = setBonusAura

			frigidBlast := mage.RegisterSpell(core.SpellConfig{
				ActionID:    core.ActionID{SpellID: 145264},
				SpellSchool: core.SpellSchoolFrost,
				ProcMask:    core.ProcMaskSpellProc,
				Flags:       core.SpellFlagPassiveSpell,

				DamageMultiplier: 1,
				CritMultiplier:   mage.DefaultCritMultiplier(),
				ThreatMultiplier: 1,

				BonusCoefficient: 1.5,

				ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
					baseDamage := mage.CalcAndRollDamageRange(sim, 1.5, 0.15000000596)
					spell.CalcAndDealDamage(sim, target, baseDamage, spell.OutcomeMagicCrit)
				},
			})

			mage.OnSpellRegistered(func(spell *core.Spell) {
				if !spell.Matches(MageSpellFrostbolt) {
					return
				}
				if mage.BrainFreezeAura == nil {
					return
				}
				mage.BrainFreezeAura.ApplyOnExpire(func(_ *core.Aura, sim *core.Simulation) {
					if setBonusAura.IsActive() {
						frigidBlast.Cast(sim, mage.CurrentTarget)
					}
				})
			})

			fireAura := mage.GetOrRegisterAura(core.Aura{
				Label:    "Fiery Adept",
				ActionID: core.ActionID{SpellID: 145261},
				Duration: time.Second * 15,
			}).AttachSpellMod(core.SpellModConfig{
				Kind:       core.SpellMod_BonusCrit_Percent,
				ClassMask:  MageSpellPyroblast | MageSpellPyroblastDot,
				FloatValue: 100,
			})

			setBonusAura.MakeDependentProcTriggerAura(&mage.Unit, core.ProcTrigger{
				Name:               "Fiery Adept - Consume",
				ClassSpellMask:     MageSpellPyroblast,
				RequireDamageDealt: true,
				Callback:           core.CallbackOnSpellHitDealt,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					fireAura.Deactivate(sim)
				},
			})

			setBonusAura.MakeDependentProcTriggerAura(&mage.Unit, core.ProcTrigger{
				Name:           "Item - Mage T16 4P Bonus",
				ClassSpellMask: MageSpellInfernoBlast,
				Callback:       core.CallbackOnSpellHitDealt,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					fireAura.Activate(sim)
				},
			})

			setBonusAura.ExposeToAPL(145257)
		},
	},
})

var ItemSetGladiatorsRegalia = core.NewItemSet(core.ItemSet{
	Name:                    "Gladiator's Regalia",
	DisabledInChallengeMode: true,
	Bonuses: map[int32]core.ApplySetBonus{
		2: func(agent core.Agent, setBonusAura *core.Aura) {},

		4: func(agent core.Agent, setBonusAura *core.Aura) {
			setBonusAura.AttachSpellMod(core.SpellModConfig{
				Kind:      core.SpellMod_Cooldown_Flat,
				ClassMask: MageSpellAlterTime,
				TimeValue: -90 * time.Second,
			})

			setBonusAura.ExposeToAPL(131619)
		},
	},
})

var ItemSetRegaliaOfTheBurningScroll = core.NewItemSet(core.ItemSet{
	Name:                    "Regalia of the Burning Scroll",
	DisabledInChallengeMode: true,
	Bonuses: map[int32]core.ApplySetBonus{

		2: func(_ core.Agent, setBonusAura *core.Aura) {
			setBonusAura.AttachSpellMod(core.SpellModConfig{
				Kind:       core.SpellMod_DamageDone_Pct,
				ClassMask:  MageSpellIceLance,
				FloatValue: 0.12,
			}).AttachSpellMod(core.SpellModConfig{
				Kind:       core.SpellMod_DamageDone_Pct,
				ClassMask:  MageSpellArcaneMissilesTick,
				FloatValue: 0.07,
			}).AttachSpellMod(core.SpellModConfig{
				Kind:       core.SpellMod_DamageDone_Pct,
				ClassMask:  MageSpellPyroblast | MageSpellPyroblastDot,
				FloatValue: 0.08,
			})
			setBonusAura.ExposeToAPL(123097)
		},

		4: func(agent core.Agent, setBonusAura *core.Aura) {
			mage := agent.(MageAgent).GetMage()

			setBonusAura.AttachSpellMod(core.SpellModConfig{
				FloatValue: 0.5,
				Kind:       core.SpellMod_Cooldown_Multiplier,
				ClassMask:  MageSpellIcyVeins,
			}).AttachSpellMod(core.SpellModConfig{
				FloatValue: 1 - 0.2,
				Kind:       core.SpellMod_Cooldown_Multiplier,
				ClassMask:  MageSpellCombustion,
			})

			mage.OnSpellRegistered(func(spell *core.Spell) {
				if !spell.Matches(MageSpellArcanePower) {
					return
				}

				setBonusAura.ApplyOnGain(func(_ *core.Aura, _ *core.Simulation) {
					mage.ArcanePowerDamageMod.UpdateFloatValue(mage.ArcanePowerDamageMod.GetFloatValue() + 0.1)
				}).ApplyOnExpire(func(_ *core.Aura, _ *core.Simulation) {
					mage.ArcanePowerDamageMod.UpdateFloatValue(mage.ArcanePowerDamageMod.GetFloatValue() - 0.1)
				})
			})

			setBonusAura.ExposeToAPL(123101)
		},
	},
})

var ItemSetRegaliaOfTheChromaticHydra = core.NewItemSet(core.ItemSet{
	Name:                    "Regalia of the Chromatic Hydra",
	DisabledInChallengeMode: true,
	Bonuses: map[int32]core.ApplySetBonus{

		2: func(agent core.Agent, setBonusAura *core.Aura) {
			mage := agent.(MageAgent).GetMage()
			statValue := 1800.0
			aura := mage.NewTemporaryStatsAura(
				"Time Lord",
				core.ActionID{SpellID: 138317},
				stats.Stats{stats.HasteRating: statValue, stats.CritRating: statValue, stats.MasteryRating: statValue},
				time.Second*30,
			)

			mage.OnSpellRegistered(func(spell *core.Spell) {
				if !spell.Matches(MageSpellAlterTime) {
					return
				}

				spell.RelatedSelfBuff.ApplyOnExpire(func(_ *core.Aura, sim *core.Simulation) {
					if setBonusAura.IsActive() {
						aura.Activate(sim)
					}
				})
			})

			setBonusAura.ExposeToAPL(138316)
		},

		4: func(agent core.Agent, setBonusAura *core.Aura) {
			mage := agent.(MageAgent).GetMage()

			mage.T15_4pc = setBonusAura
			setBonusAura.ApplyOnGain(func(_ *core.Aura, _ *core.Simulation) {
				mage.T15_4PC_ArcaneChargeEffect += 0.05
			}).ApplyOnExpire(func(_ *core.Aura, _ *core.Simulation) {
				mage.T15_4PC_ArcaneChargeEffect -= 0.05
			})

			setBonusAura.ExposeToAPL(138376)
		},
	},
})