func (avalon *AvalonCommand) Process(bot *models.Bot, msg *irc.Message) {
	if !models.CommandTriggered(avalon, msg) {
		return
	}

	subcommand := msg.Subcommand()
	switch subcommand {
	case "disable":
		avalon.DoDisable(bot, msg)
	case "enable":
		avalon.DoEnable(bot, msg)
	case "help", "":
		avalon.DoHelp(bot, msg)
	case "implode":
		avalon.DoImplode(bot, msg)
	case "info":
		avalon.DoInfo(bot, msg)
	case "init":
		avalon.DoInit(bot, msg)
	case "join":
		avalon.DoJoin(bot, msg)
	case "start":
		avalon.DoStart(bot, msg)
	case "status":
		avalon.DoStatus(bot, msg)
	}
}

func (avalon *AvalonCommand) DoStart(bot *models.Bot, msg *irc.Message) {
	err := avalon.IssuedByLobbyLeaderInGameChannel(msg)
	if err != nil {
		bot.Connection.RespondTo(msg, err.Error())
		return
	}

	if avalon.game.GamePhase == cmodels.PhaseWaitingForPlayers {
		err := avalon.game.StartConfig()
		if err != nil {
			bot.Connection.RespondTo(msg, err.Error())
			return
		}

		resp := fmt.Sprintf(closingLobbyFormatString, avalon.game.NumPlayers())
		bot.Connection.RespondTo(msg, resp)

		bot.Connection.RespondTo(msg, configurationHelpString)
	} else if avalon.game.GamePhase == cmodels.PhaseConfiguration {
		resp := fmt.Sprintf(startingGameFormatString, avalon.game.ListPlayers(), avalon.game.ConfigStatus())
		bot.Connection.Say(msg.Channel(), resp)

		avalon.game.AssignPlayers()
		avalon.Reveal(bot, msg)
		avalon.StartFirstQuest()
	}
}

func CommandTriggered(command Command, msg *irc.Message) bool {
	userCommand := strings.ToLower(strings.TrimPrefix(msg.Command(), "!"))
	triggers := command.TriggerStrings()
	for _, trigger := range triggers {
		if userCommand == trigger {
			return true
		}
	}
	return false
}

func (avalon *AvalonCommand) DoImplode(bot *models.Bot, msg *irc.Message) {
	err := avalon.IssuedByLobbyLeaderInGameChannel(msg)
	if err != nil {
		bot.Connection.RespondTo(msg, err.Error())
		return
	}

	resp := fmt.Sprintf("%s: %s", avalon.game.ListPlayers(), gameImplodedString)
	bot.Connection.Say(msg.Channel(), resp)

	avalon.channel = ""
	avalon.game = nil
}

func (avalon *AvalonCommand) DoDisable(bot *models.Bot, msg *irc.Message) {
	err := avalon.IssuedByLobbyLeaderInGameChannel(msg)
	if err != nil {
		bot.Connection.RespondTo(msg, err.Error())
		return
	}

	option := msg.Subsubcommand()
	if option == "" {
		bot.Connection.RespondTo(msg, availableOptionsString)
		return
	}

	err = avalon.game.DisableOption(option)
	if err != nil {
		bot.Connection.RespondTo(msg, err.Error())
	}

	resp := fmt.Sprintf(configOptionsEnabledFormatString, avalon.game.ConfigStatus())
	bot.Connection.RespondTo(msg, resp)
}

func (avalon *AvalonCommand) DoInfo(bot *models.Bot, msg *irc.Message) {
	if avalon.game == nil {
		bot.Connection.RespondTo(msg, noActiveGameString)
		return
	}

	subsub := msg.Subsubcommand()
	switch subsub {
	case "":
		bot.Connection.RespondTo(msg, infoHelpString)
	case "game":
		resp := fmt.Sprintf(infoGameFormatString, avalon.lobbyLeader, avalon.channel)
		bot.Connection.RespondTo(msg, resp)
	case "players":
		plural := ""
		if avalon.game.NumPlayers() > 1 {
			plural = "s"
		}

		resp := fmt.Sprintf(infoPlayersFormatString, avalon.game.NumPlayers(), plural, avalon.game.ListPlayers())
		bot.Connection.RespondTo(msg, resp)
	}
}

func (avalon *AvalonCommand) DoJoin(bot *models.Bot, msg *irc.Message) {
	if msg.IsDirectMessage() {
		bot.Connection.RespondTo(msg, noDMCommandString)
		return
	}

	if avalon.game == nil {
		bot.Connection.RespondTo(msg, noActiveGameString)
		return
	}

	if avalon.game.GamePhase != cmodels.PhaseWaitingForPlayers {
		bot.Connection.RespondTo(msg, lobbyClosedString)
		return
	}

	if avalon.channel == msg.Channel() {
		err := avalon.game.AddPlayer(msg.SenderNick())
		if err != nil {
			if err == cmodels.ErrPlayerExists {
				bot.Connection.RespondTo(msg, alreadyJoinedString)
			} else if err == cmodels.ErrTooManyPlayers {
				bot.Connection.RespondTo(msg, tooManyPlayersString)
			}
			return
		}
		bot.Connection.RespondTo(msg, playerAddedString)

		joinProgress := fmt.Sprintf(joinProgressFormatString, avalon.game.NumPlayers())
		bot.Connection.Say(msg.Channel(), joinProgress)

		if avalon.game.CanStartConfig() {
			resp := fmt.Sprintf(readyToConfigFormatString, avalon.lobbyLeader)
			bot.Connection.Say(msg.Channel(), resp)
		}
	}
}

func (avalon *AvalonCommand) DoInit(bot *models.Bot, msg *irc.Message) {
	if msg.IsDirectMessage() {
		bot.Connection.RespondTo(msg, noDMCommandString)
		return
	}

	if avalon.game != nil {
		bot.Connection.RespondTo(msg, gameInProgressString)
		return
	}

	avalon.channel = msg.Channel()
	avalon.lobbyLeader = msg.SenderNick()

	avalon.game = cmodels.NewAvalonGame()
	avalon.game.AddPlayer(avalon.lobbyLeader)

	bot.Connection.RespondTo(msg, newGameString)
}

func (avalon *AvalonCommand) IssuedByLobbyLeaderInGameChannel(msg *irc.Message) error {
	if msg.IsDirectMessage() {
		return errors.New(noDMCommandString)
	}

	if avalon.game == nil {
		return errors.New(noActiveGameString)
	}

	if avalon.lobbyLeader != msg.SenderNick() {
		return errors.New(onlyLobbyLeaderCanDoThatString)
	}

	if avalon.channel != msg.Channel() {
		resp := fmt.Sprintf(correctChannelFormatString, avalon.channel)
		return errors.New(resp)
	}

	return nil
}