include "scg-csp-game.beh";

Transaction{{ }}
OfferTrans{{ }}
AcceptTrans{{ }}
ProvideTrans{{ }}
SolveTrans{{ }}
ReofferTrans{{}}


PlayerSpec{{
    /** Get the Name of this Player */
    public String getName(){ return name; }
    /** Get the Address of this Player's Server */
    public String getAddress(){ return address; }
    /** Get the Port of this Player's Server */
    public int getPort(){ return port; }
    
    /** Returns a Predicate that compares another PlayerSpec by name */
    public List.Pred<PlayerSpec> sameNamePred(){ return new SameName(); }
    /** Predicate for PlayerSpecs that compares Names */
    private class SameName extends List.Pred<PlayerSpec>{
        public boolean huh(PlayerSpec that)
        { return name.equals(that.name); }
    }
}}
PlayersFile{{
    /** Get the List of PlayerSpecs */
    public List<PlayerSpec> getPlayerSpecs(){ return players; }
}}
PasswordEntry{{
    /** Add to the given Map */
    public Map<String,String> addTo(Map<String,String> m){
        return m.put(name,passhash);
    }
}}
PasswordFile{{
    /** Get a Map of Player-Name / Password-Hash */
    public Map<String,String> getPasswordMap(){
        return passwds.fold(new List.Fold<PasswordEntry,Map<String,String>>(){
            public Map<String,String> fold(PasswordEntry e, Map<String,String> m){
                return e.addTo(m);
            }
        }, Map.<String,String>create());
    }
}}
PlayerTrans{{ }}
PlayerStore{{ }}

Round{{
    /** Create a new Round from the given Number and Player Transactions */
    public static Round create(int n, List<PlayerTrans> ts)
    { return new Round(n, ts); }
    /** Create the Initial Round (0) */
    public static Round initial(){ return forNumber(0); }
    /** Create an empty Round for the given Number */
    public static Round forNumber(int i)
    { return create(i, List.<PlayerTrans>create()); }
    
    /** Add a new Transaction to this Round */
    public Round addTrans(PlayerTrans t)
    { return create(num, trans.push(t)); }
}}

AdminState{{
    /** Create an AdminState from the given Maps... */
    public static AdminState create(Map<PlayerID, PlayerSpec> specs, Map<PlayerID, PlayerStore>  strs,
                                    Map<PlayerID, Double> acc, Round curr){
        return new AdminState(specs,strs,acc,curr);
    }
    /** Create the initial (empty) AdminState */
    public static AdminState initial(){
        return initial(Map.<PlayerID,PlayerSpec>create());
    }
    /** Create the initial (empty) AdminState With players drawn from the given File */
    public static AdminState initial(String playerFile) throws ParseException,java.io.IOException{
        List<PlayerSpec> plyrs = PlayersFile.parse(new java.io.FileInputStream(playerFile)).getPlayerSpecs();
        Map<PlayerID,PlayerSpec> specs = plyrs.fold(new List.Fold<PlayerSpec,Map<PlayerID,PlayerSpec>>(){
            int start = (int)(Math.random()*100);
            public Map<PlayerID,PlayerSpec> fold(PlayerSpec s, Map<PlayerID,PlayerSpec> m){
                return m.put(new PlayerID(start++), s);
            }
        }, Map.<PlayerID,PlayerSpec>create());
        return initial(specs);
    }
    /** Create the initial (empty) AdminState With the given players */
    public static AdminState initial(Map<PlayerID,PlayerSpec> plyrs){
        return create(plyrs, Map.<PlayerID,PlayerStore>create(),
                      Map.<PlayerID,Double>create(), Round.initial());
    }

}}

PlayerContext{{

    public static String CONFIG_KEY = "config",
                  BALANCE_KEY = "balance",
                  PLAYERID_KEY = "playerid",
                  OUROFFERED_KEY = "yourOffered",
                  OTHERESOFFERED_KEY = "othersOffered",
                  ACCEPTED_KEY = "accepted",
                  PROVIDED_KEY = "provided";

    /** */
    public static PlayerContext create(Map<String, List<String>> heads) throws Exception{
        Config cfg = Config.parse(onlyOne(heads, PlayerContext.CONFIG_KEY));
        PlayerID pid = PlayerID.parse(onlyOne(heads, PlayerContext.PLAYERID_KEY));
        double bal = Double.parseDouble(onlyOne(heads, PlayerContext.BALANCE_KEY));
        List<OfferedChallenge> ouroff = allfor(heads, PlayerContext.OUROFFERED_KEY).map(new OfferParse());
        List<OfferedChallenge> othoff = allfor(heads, PlayerContext.OTHERESOFFERED_KEY).map(new OfferParse());
        List<AcceptedChallenge> acc = allfor(heads, PlayerContext.OTHERESOFFERED_KEY).map(new AcceptParse());
        List<ProvidedChallenge> prov = allfor(heads, PlayerContext.OTHERESOFFERED_KEY).map(new ProvideParse());
        
        return new PlayerContext(cfg,pid,bal,ouroff,othoff,acc,prov);
    }
    /** */
    public static PlayerContext create(java.util.Map<String, java.util.List<String>> heads) throws Exception{
        Map<String, List<String>> fmap = Map.create();
        for(java.util.Map.Entry<String, java.util.List<String>> e:heads.entrySet()){
            fmap = fmap.put(e.getKey(), List.create((Iterable<String>)e.getValue()));
        }
        return create(fmap);
    }
    /** */
    private static String onlyOne(Map<String,List<String>> hs, String key){
        if(hs.containsKey(key)){
            List<String> val = hs.get(key);
            if(val.length() == 1)return val.top();
            throw new RuntimeException(" Found "+val.length()+" Values for Context key '"+key+"'");
        }
        throw new RuntimeException("Empty Context key '"+key+"'");
    }
    /** */
    private static List<String> allfor(Map<String,List<String>> hs, String key){
        return hs.containsKey(key) ? hs.get(key) : List.<String>create();
    }
    /** */
    static class OfferParse extends List.Map<String,OfferedChallenge>{
        public OfferedChallenge map(String s){
            try{ return OfferedChallenge.parse(s); }
            catch(gen.ParseException e){ throw new RuntimeException(e); }
        }
    }
    /** */
    static class AcceptParse extends List.Map<String,AcceptedChallenge>{
        public AcceptedChallenge map(String s){
            try{ return AcceptedChallenge.parse(s); }
            catch(gen.ParseException e){ throw new RuntimeException(e); }
        }
    }
    /** */
    static class ProvideParse extends List.Map<String,ProvidedChallenge>{
        public ProvidedChallenge map(String s){
            try{ return ProvidedChallenge.parse(s); }
            catch(gen.ParseException e){ throw new RuntimeException(e); }
        }
    }
    /** */
    public String forHTTP(){
        return (PlayerContext.CONFIG_KEY+": "+getConfig()+"\n"+
                PlayerContext.PLAYERID_KEY+": "+getPlayerID()+"\n"+
                PlayerContext.BALANCE_KEY+": "+getBalance()+"\n"+
                PlayerContext.OUROFFERED_KEY+": "+getOurOfferedChallenges()+"\n"+
                PlayerContext.OTHERESOFFERED_KEY+": "+getOthersOfferedChallenges()+"\n"+
                PlayerContext.ACCEPTED_KEY+": "+getAcceptedChallenges()+"\n"+
                PlayerContext.PROVIDED_KEY+": "+getProvidedChallenges());      
    }
    /**  */
    public Config getConfig(){ return config; }
    /**  */
    public PlayerID getPlayerID(){ return id; }
    /**  */
    public double getBalance(){ return balance; }
    /**  */
    public List<OfferedChallenge> getAllOfferedChallenges(){ return ourOffered.append(theirOffered); }
    /**  */
    public List<OfferedChallenge> getOurOfferedChallenges(){ return ourOffered; }
    /**  */
    public List<OfferedChallenge> getOthersOfferedChallenges(){ return theirOffered; }
    /**  */
    public List<AcceptedChallenge> getAcceptedChallenges(){ return accepted; }
    /**  */
    public List<ProvidedChallenge> getProvidedChallenges(){ return provided; }
}}