package game

import (
	"fmt"
	"strings"

	"thehouseoficarus/internal/net"
)

func (g *Game) executeGet(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		sess.WriteLine("Get what?")
	} else if args[0] == "all" {
		if len(args) == 1 {
			g.doGetAll(sess)
		} else {
			g.doGetAllNamed(sess, strings.Join(args[1:], " "))
		}
	} else {
		g.doGet(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeDrop(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		sess.WriteLine("Drop what?")
	} else if args[0] == "all" {
		if len(args) == 1 {
			g.doDropAll(sess)
		} else {
			g.doDropAllNamed(sess, strings.Join(args[1:], " "))
		}
	} else {
		g.doDrop(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeAttack(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		p := sess.Player
		target := g.resolveDefaultMob(p.RoomID)
		if target == "" {
			sess.WriteLine("Attack what?")
			return
		}
		g.doAttack(sess, target)
	} else {
		g.doAttack(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeStyle(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		g.doStyle(sess, "")
	} else {
		g.doStyle(sess, args[0])
	}
}

func (g *Game) executeLook(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		g.doLook(sess)
	} else {
		g.doLookTarget(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeMove(sess *net.Session, args []string, rawInput string) {
	g.doMove(sess, strings.TrimSpace(rawInput), 1.0)
}

func (g *Game) executeSay(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		sess.WriteLine("Say what?")
	} else {
		msgStart := strings.Index(strings.ToLower(rawInput), "say ") + 4
		if msgStart >= 4 && msgStart < len(rawInput) {
			g.doSay(sess, rawInput[msgStart:])
		} else {
			g.doSay(sess, strings.Join(args, " "))
		}
	}
}

func (g *Game) executeScore(sess *net.Session, args []string, rawInput string) {
	g.doScore(sess)
}

func (g *Game) executeTask(sess *net.Session, args []string, rawInput string) {
	g.doTask(sess)
}

func (g *Game) executeStats(sess *net.Session, args []string, rawInput string) {
	g.doStats(sess)
}

func (g *Game) executeTech(sess *net.Session, args []string, rawInput string) {
	g.doTech(sess, strings.Join(args, " "))
}

func (g *Game) executeInventory(sess *net.Session, args []string, rawInput string) {
	g.doInventory(sess)
}

func (g *Game) executeQuit(sess *net.Session, args []string, rawInput string) {
	g.doQuit(sess)
}

func (g *Game) executeDescription(sess *net.Session, args []string, rawInput string) {
	g.doDescription(sess)
}

func (g *Game) executeOption(sess *net.Session, args []string, rawInput string) {
	g.doOption(sess, strings.Join(args, " "))
}

func (g *Game) executeColor(sess *net.Session, args []string, rawInput string) {
	g.doColor(sess, strings.Join(args, " "))
}

func (g *Game) executeColortable(sess *net.Session, args []string, rawInput string) {
	g.doColortable(sess)
}

func (g *Game) executePrompt(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		g.doPrompt(sess, "")
	} else {
		msgStart := strings.Index(strings.ToLower(rawInput), "prompt ") + 7
		if msgStart >= 7 && msgStart < len(rawInput) {
			g.doPrompt(sess, rawInput[msgStart:])
		} else {
			g.doPrompt(sess, strings.Join(args, " "))
		}
	}
}

func (g *Game) executeExits(sess *net.Session, args []string, rawInput string) {
	g.doExits(sess)
}

func (g *Game) executeMap(sess *net.Session, args []string, rawInput string) {
	g.doMap(sess)
}

func (g *Game) executeQueued(sess *net.Session, args []string, rawInput string) {
	g.doQueued(sess)
}

func (g *Game) executeHelp(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		g.doHelp(sess, "")
	} else {
		g.doHelp(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeGather(sess *net.Session, args []string, rawInput string) {
	verb := strings.TrimSpace(rawInput)
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		target := g.resolveDefaultTarget(p.RoomID, verb)
		if target == "" {
			sess.WriteLine(fmt.Sprintf("%s what?", verb))
			return
		}
		g.startAction(sess, verb, target)
	} else {
		g.startAction(sess, verb, strings.Join(args, " "))
	}
}

func (g *Game) executeUse(sess *net.Session, args []string, rawInput string) {
	if g.tryFinishingBlow(sess, strings.Join(args, " ")) {
		return
	}
	g.doUse(sess, strings.Join(args, " "))
}

func (g *Game) executeCook(sess *net.Session, args []string, rawInput string) {
	g.doCook(sess, strings.Join(args, " "))
}

func (g *Game) executeSmelt(sess *net.Session, args []string, rawInput string) {
	g.doSmelt(sess, strings.Join(args, " "))
}

func (g *Game) executeSmith(sess *net.Session, args []string, rawInput string) {
	g.doSmith(sess, strings.Join(args, " "))
}

func (g *Game) executeCraft(sess *net.Session, args []string, rawInput string) {
	g.doCraft(sess, strings.Join(args, " "))
}

func (g *Game) executeEat(sess *net.Session, args []string, rawInput string) {
	g.doEat(sess, strings.Join(args, " "))
}

func (g *Game) executeDrink(sess *net.Session, args []string, rawInput string) {
	g.doDrink(sess, args)
}

func (g *Game) executeFletch(sess *net.Session, args []string, rawInput string) {
	g.doFletch(sess, strings.Join(args, " "))
}

func (g *Game) executeClean(sess *net.Session, args []string, rawInput string) {
	g.doClean(sess, strings.Join(args, " "))
}

func (g *Game) executeMix(sess *net.Session, args []string, rawInput string) {
	g.doMix(sess, strings.Join(args, " "))
}

func (g *Game) executeIdentify(sess *net.Session, args []string, rawInput string) {
	g.doIdentify(sess, strings.Join(args, " "))
}

func (g *Game) executeAutotrigger(sess *net.Session, args []string, rawInput string) {
	g.doAutotrigger(sess, strings.Join(args, " "))
}

func (g *Game) executeMods(sess *net.Session, args []string, rawInput string) {
	showAll := len(args) > 0 && args[0] == "all"
	g.doMods(sess, showAll)
}

func (g *Game) executeSneak(sess *net.Session, args []string, rawInput string) {
	g.doSneak(sess)
}

func (g *Game) executeTrigger(sess *net.Session, args []string, rawInput string) {
	g.doTrigger(sess, strings.Join(args, " "))
}

func (g *Game) executeTalk(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		sess.WriteLine("Talk to whom?")
	} else {
		g.startAction(sess, "talk", strings.Join(args, " "))
	}
}

func (g *Game) executeBurn(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	g.doBurn(sess, p, strings.Join(args, " "))
}

func (g *Game) executeStoke(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	g.doStoke(sess, p, strings.Join(args, " "))
}

func (g *Game) executeAlias(sess *net.Session, args []string, rawInput string) {
	g.doAlias(sess, args)
}

func (g *Game) executeUnalias(sess *net.Session, args []string, rawInput string) {
	g.doUnalias(sess, args)
}

func (g *Game) executeSearch(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		sess.WriteLine("Search what?")
	} else {
		g.doSearch(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeSteal(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		g.doSteal(sess, "")
	} else {
		g.doSteal(sess, strings.Join(args, " "))
	}
}

func (g *Game) executePlant(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		sess.WriteLine("Plant what?")
	} else {
		g.doPlant(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeHarvest(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		g.doHarvest(sess, "")
	} else {
		g.doHarvest(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeRake(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		g.doRake(sess, "")
	} else {
		g.doRake(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeWater(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		g.doWater(sess, "")
	} else {
		g.doWater(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeCure(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	if len(args) == 0 {
		g.doCure(sess, "")
	} else {
		g.doCure(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeInspect(sess *net.Session, args []string, rawInput string) {
	if len(args) == 0 {
		g.doInspect(sess, "")
	} else {
		g.doInspect(sess, strings.Join(args, " "))
	}
}

func (g *Game) executeWalk(sess *net.Session, args []string, rawInput string) {
	g.doWalk(sess, args)
}

func (g *Game) executeBank(sess *net.Session, args []string, rawInput string) {
	g.doBank(sess)
}

func (g *Game) executeConstruct(sess *net.Session, args []string, rawInput string) {
	g.doConstruct(sess, strings.Join(args, " "))
}

func (g *Game) executeJack(sess *net.Session, args []string, rawInput string) {
	p := sess.Player
	g.cancelAction(p)
	g.doJack(sess, strings.Join(args, " "))
}

func (g *Game) executeWear(sess *net.Session, args []string, rawInput string) {
	g.doWear(sess, strings.Join(args, " "))
}

func (g *Game) executeRemove(sess *net.Session, args []string, rawInput string) {
	g.doRemove(sess, strings.Join(args, " "))
}