# Source: app/controllers/Teams.controller.js

    const { Controller } = require('libflitter')

    /**
     * Teams Controller
     * -------------------------------------------------------------
     * This controller contains logic related to viewing and managing
     * the user's team, team lineups, and team players.
     *
     * @extends Controller
     */
    class Teams extends Controller {
        static get services() {
            return [...super.services, 'models']
        }

        /**
         * Save changes to the current user's team and return it as API data.
         * @param req
         * @param res
         * @param next
         * @return {Promise<*>}
         */
        async save_my_team(req, res, next) {
            req.user_team.team_name = String(req.body.team_name).trim()
            await req.user_team.save()
            return res.api(await req.user_team.to_api())
        }

        /**
         * Return the API data for the current user's team.
         * Requires an authenticated user.
         * @param req
         * @param res
         * @param next
         * @return {Promise<void>}
         */
        async get_my_team(req, res, next) {
            return res.api(await req.user_team.to_api())
        }

        /**
         * Return the API data for the players on the current user's team.
         * @param req
         * @param res
         * @param next
         * @return {Promise<*>}
         */
        async get_my_team_players(req, res, next) {
            const players = await req.user_team.players()
            return res.api(await Promise.all(players.map(x => x.to_api(true))))
        }

        /**
         * Return the API data for the current lineup for the current user's team.
         * @param req
         * @param res
         * @param next
         * @return {Promise<*>}
         */
        async get_my_team_current_lineup(req, res, next) {
            const lineup = await req.user_team.lineup()
            return res.api(await lineup.to_api())
        }

        /**
         * Saves the lineup for the current user's team and returns it as API data.
         * @param req
         * @param res
         * @param next
         * @return {Promise<void>}
         */
        async save_my_team_lineup(req, res, next) {
            if ( !Array.isArray(req.body.starting_players) ) {
                return res.status(400)
                    .message('Missing required field: starting_players')
                    .api()
            }

            if ( !Array.isArray(req.body.benched_players) ) {
                return res.status(400)
                    .message('Missing required field: benched_players')
                    .api()
            }

            // fetch the team players & the current lineup
            const player_ids = (await req.user_team.players()).map(x => x.id)
            const lineup = await req.user_team.lineup()
            lineup.clear_lineup()

            // Add all the starting players to the lineup
            for ( const player of req.body.starting_players ) {
                if ( !player.id || !player.position ) continue;

                const lineup_record = {
                    player_id: player.id,
                    position: player.position,
                }

                // Don't allow adding other teams' players to the lineup
                if ( !player_ids.includes(lineup_record.player_id) ) {
                    return res.status(400)
                        .message(`Sorry, the player ${lineup_record.player_id} is not on your team.`)
                        .api()
                }

                lineup.start_player(lineup_record)
            }

            // Bench all the other players
            for ( const player of req.body.benched_players ) {
                if ( !player.id ) continue;

                if ( !player_ids.includes(player.id) ) {
                    return res.status(400)
                        .message(`Sorry, the player ${player.id} is not on your team.`)
                        .api()
                }

                lineup.bench_player(player)
            }

            // Save the partial lineup
            await lineup.save()

            // Fetch a fresh version to fill in any missing players
            const corrected_lineup = await req.user_team.lineup()

            return res.api(await corrected_lineup.to_api())
        }

        /**
         * Return the API data for a list of all teams.
         * @param req
         * @param res
         * @return {Promise<*>}
         */
        async list_all_teams(req, res) {
            const TeamModel = this.models.get('Team')
            const teams = await TeamModel.find()
            return res.api(teams)
        }

        /**
         * API endpoint for creating a new team.
         * @todo remove this - happens automatically per-user
         * @param req
         * @param res
         * @return {Promise<*>}
         */
        async create_team(req, res) {
            const TeamModel = this.models.get('Team')

            if ( !req.body.team_name || !req.body.team_num ) {
                return res.status(400)
                    .message('Missing team_name or team_num')
                    .api()
            }

            const duplicate_team = await TeamModel.findOne({
                team_num: req.body.team_num,
            })

            if ( duplicate_team ) {
                return res.status(400)
                    .message('That team number is already in use!')
                    .api()
            }

            const team = new TeamModel({
                team_name: req.body.team_name,
                team_num: req.body.team_num,
            })

            await team.save()
            return res.api(team)
        }
    }

    module.exports = Teams