package game

import "fmt"

// rings.c — routines dealing specifically with rings.

// ringOn puts a ring on a hand (rings.c ring_on).
func (g *RogueGame) ringOn() {
	p := &g.Player
	obj := g.getItem("put on", KindRing)
	// Make certain that it is something that we want to wear
	if obj == nil {
		return
	}

	if obj.Kind != KindRing {
		if !g.Options.Terse {
			g.msg("it would be difficult to wrap that around a finger")
		} else {
			g.msg("not a ring")
		}

		return
	}

	// find out which hand to put it on
	if g.isCurrent(obj) {
		return
	}

	var ring int

	switch {
	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
		if ring = g.gethand(); ring < 0 {
			return
		}
	case p.CurRing[Left] == nil:
		ring = Left
	case p.CurRing[Right] == nil:
		ring = Right
	default:
		if !g.Options.Terse {
			g.msg("you already have a ring on each hand")
		} else {
			g.msg("wearing two")
		}

		return
	}

	p.CurRing[ring] = obj

	// Calculate the effect it has on the poor guy.
	switch obj.RingKind() {
	case RingAddStrength:
		g.changeStrength(obj.Bonus)
	case RingSeeInvisible:
		g.invisOn()
	case RingAggravateMonsters:
		g.aggravate()
	}

	if !g.Options.Terse {
		g.addmsgf("you are now wearing ")
	}

	g.msg("%s (%c)", g.invName(obj, true), obj.PackCh)
}

// ringOff takes off a ring (rings.c ring_off).
func (g *RogueGame) ringOff() {
	p := &g.Player

	var ring int

	switch {
	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
		if g.Options.Terse {
			g.msg("no rings")
		} else {
			g.msg("you aren't wearing any rings")
		}

		return
	case p.CurRing[Left] == nil:
		ring = Right
	case p.CurRing[Right] == nil:
		ring = Left
	default:
		if ring = g.gethand(); ring < 0 {
			return
		}
	}

	g.Msgs.Mpos = 0

	obj := p.CurRing[ring]
	if obj == nil {
		g.msg("not wearing such a ring")

		return
	}

	if g.dropCheck(obj) {
		g.msg("was wearing %s(%c)", g.invName(obj, true), obj.PackCh)
	}
}

// gethand asks which hand the hero is interested in (rings.c gethand).
func (g *RogueGame) gethand() int {
	for {
		if g.Options.Terse {
			g.msg("left or right ring? ")
		} else {
			g.msg("left hand or right hand? ")
		}

		c := g.readchar()
		if c == Escape {
			return -1
		}

		g.Msgs.Mpos = 0

		if c == 'l' || c == 'L' {
			return Left
		}

		if c == 'r' || c == 'R' {
			return Right
		}

		if g.Options.Terse {
			g.msg("L or R")
		} else {
			g.msg("please type L or R")
		}
	}
}

// ringEat reports how much food the ring on the given hand uses up
// (rings.c ring_eat).
func (g *RogueGame) ringEat(hand int) int {
	ring := g.Player.CurRing[hand]
	if ring == nil {
		return 0
	}

	eat := g.data.ringUses[ring.RingKind()]
	if eat < 0 {
		if g.rnd(-eat) == 0 {
			eat = 1
		} else {
			eat = 0
		}
	}

	if ring.RingKind() == RingSlowDigestion {
		eat = -eat
	}

	return eat
}

// ringNum prints ring bonuses (rings.c ring_num). The unused game
// parameter keeps the nameit prfunc signature.
func ringNum(_ *RogueGame, obj *Object) string {
	if !obj.Flags.Has(Known) {
		return ""
	}

	switch obj.RingKind() {
	case RingProtection, RingAddStrength, RingIncreaseDamage, RingDexterity:
		return fmt.Sprintf(" [%s]", num(obj.Bonus, 0, Ring))
	}

	return ""
}