package game

import "fmt"

// sticks.c — zap wands and staffs.

// doZap performs a zap with a wand (sticks.c do_zap).
func (g *RogueGame) doZap() {
	p := &g.Player
	obj := g.getItem("zap with", int(Stick))
	if obj == nil {
		return
	}
	if obj.Type != Stick {
		g.After = false
		g.msg("you can't zap with that!")
		return
	}
	if obj.Charges() == 0 {
		g.msg("nothing happens")
		return
	}
	switch obj.Which {
	case WsLight:
		// Reddy Kilowatt wand.  Light up the room
		g.Items.Sticks[WsLight].Know = true
		if p.Room.Flags.Has(IsGone) {
			g.msg("the corridor glows and then fades")
		} else {
			p.Room.Flags.Clear(IsDark)
			// Light the room and put the player back up
			g.enterRoom(p.Pos)
			g.addmsg("the room is lit")
			if !g.Options.Terse {
				g.addmsg(" by a shimmering %s light", g.pickColor("blue"))
			}
			g.endmsg()
		}
	case WsDrain:
		// take away 1/2 of hero's hit points, then take it away evenly
		// from the monsters in the room (or next to hero if he is in a
		// passage)
		if p.Stats.HP < 2 {
			g.msg("you are too weak to use it")
			return
		}
		g.drain()
	case WsInvis, WsPolymorph, WsTelAway, WsTelTo, WsCancel:
		y := p.Pos.Y
		x := p.Pos.X
		for stepOk(g.Level.VisibleChar(y, x)) {
			y += g.Delta.Y
			x += g.Delta.X
		}
		if tp := g.Level.MonsterAt(y, x); tp != nil {
			monster := tp.Type
			if monster == 'F' {
				p.Flags.Clear(IsHeld)
			}
			switch obj.Which {
			case WsInvis:
				tp.Flags.Set(IsInvis)
				if g.cansee(y, x) {
					g.mvaddch(y, x, tp.OldCh)
				}
			case WsPolymorph:
				pp := tp.Pack
				detachMon(&g.Level.Monsters, tp)
				if g.seeMonst(tp) {
					g.mvaddch(y, x, g.Level.Char(y, x))
				}
				oldch := tp.OldCh
				g.Delta.Y = y
				g.Delta.X = x
				monster = byte(g.rnd(26) + 'A')
				g.newMonster(tp, monster, g.Delta)
				if g.seeMonst(tp) {
					g.mvaddch(y, x, monster)
				}
				tp.OldCh = oldch
				tp.Pack = pp
				if g.seeMonst(tp) {
					g.Items.Sticks[WsPolymorph].Know = true
				}
			case WsCancel:
				tp.Flags.Set(IsCanc)
				tp.Flags.Clear(IsInvis | CanHuh)
				tp.Disguise = tp.Type
				if g.seeMonst(tp) {
					g.mvaddch(y, x, tp.Disguise)
				}
			case WsTelAway, WsTelTo:
				var newPos Coord
				if obj.Which == WsTelAway {
					for {
						newPos, _ = g.findFloor(nil, 0, true)
						if newPos != p.Pos {
							break
						}
					}
				} else {
					newPos.Y = p.Pos.Y + g.Delta.Y
					newPos.X = p.Pos.X + g.Delta.X
				}
				tp.Dest = &p.Pos
				tp.Flags.Set(IsRun)
				g.relocate(tp, newPos)
			}
		}
	case WsMissile:
		g.Items.Sticks[WsMissile].Know = true
		bolt := newObject()
		bolt.Type = '*'
		bolt.HurlDmg = "1x4"
		bolt.HPlus = 100
		bolt.DPlus = 1
		bolt.Flags = IsMissl
		if p.CurWeapon != nil {
			bolt.Launch = p.CurWeapon.Which
		}
		g.doMotion(bolt, g.Delta.Y, g.Delta.X)
		if tp := g.Level.MonsterAt(bolt.Pos.Y, bolt.Pos.X); tp != nil &&
			!g.saveThrow(VsMagic, &tp.Stats) {
			g.hitMonster(bolt.Pos, bolt)
		} else if g.Options.Terse {
			g.msg("missle vanishes")
		} else {
			g.msg("the missle vanishes with a puff of smoke")
		}
	case WsHasteM, WsSlowM:
		y := p.Pos.Y
		x := p.Pos.X
		for stepOk(g.Level.VisibleChar(y, x)) {
			y += g.Delta.Y
			x += g.Delta.X
		}
		if tp := g.Level.MonsterAt(y, x); tp != nil {
			if obj.Which == WsHasteM {
				if tp.On(IsSlow) {
					tp.Flags.Clear(IsSlow)
				} else {
					tp.Flags.Set(IsHaste)
				}
			} else {
				if tp.On(IsHaste) {
					tp.Flags.Clear(IsHaste)
				} else {
					tp.Flags.Set(IsSlow)
				}
				tp.Turn = true
			}
			g.Delta.Y = y
			g.Delta.X = x
			g.runto(g.Delta)
		}
	case WsElect, WsFire, WsCold:
		var name string
		switch obj.Which {
		case WsElect:
			name = "bolt"
		case WsFire:
			name = "flame"
		default:
			name = "ice"
		}
		g.fireBolt(p.Pos, &g.Delta, name)
		g.Items.Sticks[obj.Which].Know = true
	case WsNop:
	}
	obj.SetCharges(obj.Charges() - 1)
}

// drain does the drain-hit-points-from-player schtick (sticks.c drain).
func (g *RogueGame) drain() {
	p := &g.Player
	// First count how many things we need to spread the hit points among
	var corp *Room
	if g.Level.Char(p.Pos.Y, p.Pos.X) == Door {
		corp = &g.Level.Passages[*g.Level.FlagsAt(p.Pos.Y, p.Pos.X)&FPNum]
	}
	inpass := p.Room.Flags.Has(IsGone)
	var drainee []*Monster
	for _, mp := range g.Level.Monsters {
		if mp.Room == p.Room || mp.Room == corp ||
			(inpass && g.Level.Char(mp.Pos.Y, mp.Pos.X) == Door &&
				&g.Level.Passages[*g.Level.FlagsAt(mp.Pos.Y, mp.Pos.X)&FPNum] == p.Room) {
			drainee = append(drainee, mp)
		}
	}
	cnt := len(drainee)
	if cnt == 0 {
		g.msg("you have a tingling feeling")
		return
	}
	p.Stats.HP /= 2
	cnt = p.Stats.HP / cnt
	// Now zot all of the monsters
	for _, mp := range drainee {
		if mp.Stats.HP -= cnt; mp.Stats.HP <= 0 {
			g.killed(mp, g.seeMonst(mp))
		} else {
			g.runto(mp.Pos)
		}
	}
}

// fireBolt fires a bolt in a given direction from a specific starting
// place (sticks.c fire_bolt).
func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
	p := &g.Player
	fromHero := start == p.Pos

	bolt := newObject()
	bolt.Type = Weapon
	bolt.Which = Flame
	bolt.HurlDmg = "6x6"
	bolt.HPlus = 100
	bolt.DPlus = 0
	g.Items.Weapons[Flame].Name = name
	var dirch byte
	switch dir.Y + dir.X {
	case 0:
		dirch = '/'
	case 1, -1:
		if dir.Y == 0 {
			dirch = '-'
		} else {
			dirch = '|'
		}
	case 2, -2:
		dirch = '\\'
	}
	pos := start
	hitHero := !fromHero
	used := false
	changed := false
	var spotpos []Coord
	for len(spotpos) < BoltLength && !used {
		pos.Y += dir.Y
		pos.X += dir.X
		spotpos = append(spotpos, pos)
		ch := g.Level.VisibleChar(pos.Y, pos.X)
		bounce := false
		switch ch {
		case Door:
			// this code is necessary if the hero is on a door and he
			// fires at the wall the door is in, it would otherwise loop
			// infinitely
			if p.Pos != pos {
				bounce = true
			}
		case '|', '-', ' ':
			bounce = true
		}
		if bounce {
			if !changed {
				hitHero = !hitHero
			}
			changed = false
			dir.Y = -dir.Y
			dir.X = -dir.X
			spotpos = spotpos[:len(spotpos)-1]
			g.msg("the %s bounces", name)
			continue
		}
		if tp := g.Level.MonsterAt(pos.Y, pos.X); !hitHero && tp != nil {
			hitHero = true
			changed = !changed
			tp.OldCh = g.Level.Char(pos.Y, pos.X)
			if !g.saveThrow(VsMagic, &tp.Stats) {
				bolt.Pos = pos
				used = true
				if tp.Type == 'D' && name == "flame" {
					g.addmsg("the flame bounces")
					if !g.Options.Terse {
						g.addmsg(" off the dragon")
					}
					g.endmsg()
				} else {
					g.hitMonster(pos, bolt)
				}
			} else if ch != 'M' || tp.Disguise == 'M' {
				if fromHero {
					g.runto(pos)
				}
				if g.Options.Terse {
					g.msg("%s misses", name)
				} else {
					g.msg("the %s whizzes past %s", name, g.setMname(tp))
				}
			}
		} else if hitHero && pos == p.Pos {
			hitHero = false
			changed = !changed
			if !g.save(VsMagic) {
				if p.Stats.HP -= g.roll(6, 6); p.Stats.HP <= 0 {
					if fromHero {
						g.death('b')
					} else {
						g.death(g.Level.MonsterAt(start.Y, start.X).Type)
					}
				}
				used = true
				if g.Options.Terse {
					g.msg("the %s hits", name)
				} else {
					g.msg("you are hit by the %s", name)
				}
			} else {
				g.msg("the %s whizzes by you", name)
			}
		}
		g.mvaddch(pos.Y, pos.X, dirch)
		g.refresh()
	}
	// erase the bolt trail
	for _, c2 := range spotpos {
		g.mvaddch(c2.Y, c2.X, g.Level.Char(c2.Y, c2.X))
	}
}

// fixStick sets up a new wand or staff (sticks.c fix_stick).
func (g *RogueGame) fixStick(cur *Object) {
	if g.Items.WandType[cur.Which] == "staff" {
		cur.Damage = "2x3"
	} else {
		cur.Damage = "1x1"
	}
	cur.HurlDmg = "1x1"

	switch cur.Which {
	case WsLight:
		cur.SetCharges(g.rnd(10) + 10)
	default:
		cur.SetCharges(g.rnd(5) + 3)
	}
}

// chargeStr returns the charge-count suffix for an identified stick
// (sticks.c charge_str).
func chargeStr(g *RogueGame, obj *Object) string {
	if !obj.Flags.Has(IsKnow) {
		return ""
	}
	if g.Options.Terse {
		return fmt.Sprintf(" [%d]", obj.Charges())
	}
	return fmt.Sprintf(" [%d charges]", obj.Charges())
}