package player;

import edu.neu.ccs.demeterf.demfgen.lib.List;
import gen.AcceptedChallenge;
import gen.OfferedChallenge;
import gen.PlayerContext;
import gen.PlayerID;
import gen.PlayerTrans;
import gen.ProvidedChallenge;
import gen.Transaction;
import player.tasks.AcceptTask;
import player.tasks.OfferTask;
import player.tasks.ProvideTask;
import player.tasks.ReofferTask;
import player.tasks.SolveTask;

/**
 * Player class, responsible for taking a single turn. We deligate to separate
 * Tasks classes to make things a little easier to understand. See
 * {@link player.tasks Tasks}.
 */
public class Player {

    private final PlayerContext context;

    private PlayerID playerID(){
        return context.getPlayerID();
    }

    /** Construct a new player with the given Context */
    public Player(PlayerContext ctxt) {
        context = ctxt;
    }

    /** Take a turn for this player */
    public PlayerTrans play(){
        List<Transaction> accs = acceptChallenges();
        if (accs.isEmpty()) {
            accs = reofferChallenges();
        }
        return new PlayerTrans(playerID(), offerChallenges().append(
                accs.append(provideChallenges().append(solveChallenges()))));
    }

    /** Offer new Challenges... that are not currently offered */
    public List<Transaction> offerChallenges(){
        return (List) new OfferTask().offer(context);
    }

    /** Accept Challenges that seem reasonable/profitable */
    public List<Transaction> acceptChallenges(){
        return (List) new AcceptTask().accept(context);
    }

    /** Reoffer other Player's Challenges */
    public List<Transaction> reofferChallenges(){
        final ReofferTask reoff = new ReofferTask();
        return context.getOthersOfferedChallenges().map(
                new List.Map<OfferedChallenge, Transaction>() {

                    @Override
                    public Transaction map(OfferedChallenge ch){
                        return reoff.reoffer(ch, context.getConfig());
                    }
                });
    }

    /** Provide Problem instances for accepted Challenges */
    public List<Transaction> provideChallenges(){
        final ProvideTask prov = new ProvideTask();
        return context.getAcceptedChallenges().map(
                new List.Map<AcceptedChallenge, Transaction>() {

                    @Override
                    public Transaction map(AcceptedChallenge ch){
                        return prov.provide(ch);
                    }
                });
    }

    /** Solve provided Problem instances */
    public List<Transaction> solveChallenges(){
        final SolveTask solve = new SolveTask();
        return context.getProvidedChallenges().map(
                new List.Map<ProvidedChallenge, Transaction>() {

                    @Override
                    public Transaction map(ProvidedChallenge ch){
                        return solve.solve(ch);
                    }
                });
    }
}