针对计算机对手的计分方法

/**
 * Scorer that is responsible to give score to fields
 * 
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public abstract class AbstractScorer<P, F> implements Scorer {
    /**
     * Determine if this scorer should apply scores to the fields under the given circumstances.
     * 
     * @param scores Score parameters and analyzes for the scoring
     * @return True to work with the parameters, false to exclude this scorer entirely from the current scoring process
     */
    public boolean workWith(ScoreParameters<P> scores) {
        return true;
    }
    /**
     * Determine the score for the given field and parameters. 
     * @param field Field to score
     * @param scores Parameters and analyzes for the scoring
     * @return The score to give to the field
     */
    public abstract double getScoreFor(F field, ScoreParameters<P> scores);

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

/**
 * Score container for a specific field.
 *
 * @param <F> The type to apply scores to.
 */
public class FieldScore<F> implements Comparable<FieldScore<F>> {
    private int rank;
    private double score;
    private final F field;
    private final Map<Scorer, Double> specificScorers;
    private double  normalized;

    public FieldScore(F field) {
        this(field, false);
    }
    /**
     * 
     * @param field Field to score
     * @param detailed If true, details about how much score is given from each scorer will be saved
     */
    public FieldScore(F field, boolean detailed) {
        this.field = field;
        this.specificScorers = detailed ? new HashMap<Scorer, Double>() : null;
    }

    void addScore(AbstractScorer<?, F> scorer, double score, double weight) {
        double add = score * weight;
        this.saveScore(scorer, add);
    }

    private void saveScore(Scorer scorer, double score) {
        this.score += score;
        if (scorer != null && specificScorers != null) {
            this.specificScorers.put(scorer, score);
        }
    }

    void setRank(int rank) {
        this.rank = rank;
    }
    void setNormalized(double normalized) {
        this.normalized = normalized;
    }

    @Override
    public int compareTo(FieldScore<F> other) {
        return Double.compare(this.score, other.score);
    }

    public double getScore() {
        return this.score;
    }

    /**
     * Get the field represented by this {@link FieldScore}
     * @return The field that this object contains score for
     */
    public F getField() {
        return this.field;
    }

    void giveExtraScore(PostScorer<?, F> scorer, double bonus) {
        this.saveScore(scorer, bonus);
    }

    /**
     * Get this field's rank.
     * @return The rank score of this field, where 1 is the best rank
     */
    public int getRank() {
        return rank;
    }

    /**
     * Get this field's normalized score
     * @return Normalized score, from 0 to 1.
     */
    public double getNormalized() {
        return this.normalized;
    }

    /**
     * Get detailed information about which scorer gave what score to this field
     * @return Detailed information, or null if this field did not save details
     */
    public Map<Scorer, Double> getScoreMap() {
        return this.specificScorers == null ? null : new HashMap<Scorer, Double>(this.specificScorers);
    }

    @Override
    public String toString() {
        return "(" + this.field + " score " + this.score + ")";
    }
}

/**
 * 
 *
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public class FieldScoreProducer<P, F> {
    private final ScoreConfig<P, F> config;

    private boolean detailed;
    private final ScoreStrategy<P, F> scoreStrategy;

    public FieldScoreProducer(ScoreConfig<P, F> config, ScoreStrategy<P, F> strat) {
        this.config = config;
        this.scoreStrategy = strat;
    }

    public FieldScores<P, F> score(P params, Map<Class<?>, Object> analyzes) {
        FieldScores<P, F> scores = new FieldScores<P, F>(params, config, scoreStrategy);
        scores.setAnalyzes(analyzes);
        scores.setDetailed(this.detailed);
        scores.determineActiveScorers();
        scores.calculateScores();
        scores.rankScores();
        scores.postHandle();

        for (PreScorer<P> prescore : config.getPreScorers()) {
            prescore.onScoringComplete();
        }

        return scores;
    }

    public boolean isDetailed() {
        return detailed;
    }
    /**
     * Set whether or not each FieldScore should contain detailed information about how much score the field got from all different scorers (including post scorers)
     * @param detailed True if detailed, false otherwise.
     */
    public void setDetailed(boolean detailed) {
        this.detailed = detailed;
    }

    public Map<Class<?>, Object> analyze(P param) {
        Map<Class<?>, Object> analyze = new HashMap<Class<?>, Object>();
        for (PreScorer<P> preScorers : this.config.getPreScorers()) {
            Object data = preScorers.analyze(param);
            if (data == null) 
                continue; // avoid NullPointerException
            analyze.put(data.getClass(), data);
        }
        return analyze;
    }

    public ScoreConfig<P, F> getConfig() {
        return this.config;
    }

    public FieldScores<P, F> analyzeAndScore(P params) {
        return this.score(params, this.analyze(params));
    }
}

/**
 * Class containing scores, information about ranks, analyzes, and which score configuration that was used.
 *
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public class FieldScores<P, F> implements ScoreParameters<P> {
    private final ScoreConfig<P, F> config;
    private final Map<F, FieldScore<F>> scores = new HashMap<F, FieldScore<F>>();
    private final P params;
    private final ScoreStrategy<P, F> scoreStrategy;

    private List<AbstractScorer<P, F>> activeScorers;
    private List<List<FieldScore<F>>> rankedScores;
    private Map<Class<?>, Object> analyzes;
    private boolean detailed;

    @SuppressWarnings("unchecked")
    public <E> E getAnalyze(Class<E> clazz) {
        E value = (E) this.analyzes.get(clazz);
        if (value == null)
            throw new NullPointerException("Analyze " + clazz + " not found. Did you forget to add a PreScorer using ScoreConfigFactory.withPreScorer?");
        return value;
    }

    @Override
    public Map<Class<?>, Object> getAnalyzes() {
        return new HashMap<Class<?>, Object>(this.analyzes);
    }

    FieldScores(P params, ScoreConfig<P, F> config, ScoreStrategy<P, F> strat) {
        this.params = params;
        this.config = config;
        this.scoreStrategy = strat;
    }

    @Override
    public ScoreStrategy<P, F> getScoreStrategy() {
        return scoreStrategy;
    }

    /**
     * Call each {@link AbstractScorer}'s workWith method to determine if that scorer is currently applicable
     */
    void determineActiveScorers() {
        activeScorers = new ArrayList<AbstractScorer<P, F>>();

        for (AbstractScorer<P, F> scorer : config.getScorers().keySet()) {
            if (scorer.workWith(this)) {
                activeScorers.add(scorer);
            }
        }
    }

    /**
     * Process the {@link AbstractScorer}s to let them add their score for each field. Uses the {@link ScoreStrategy} associated with this object to determine which fields should be scored.
     */
    void calculateScores() {
        for (F field : this.scoreStrategy.getFieldsToScore(params)) {
            if (!this.scoreStrategy.canScoreField(this, field))
                continue;

            FieldScore<F> fscore = new FieldScore<F>(field, detailed);
            for (AbstractScorer<P, F> scorer : activeScorers) {
                double computedScore = scorer.getScoreFor(field, this);
                double weight = config.getScorers().get(scorer);
                fscore.addScore(scorer, computedScore, weight);
            }
            scores.put(field, fscore);
        }
    }

    /**
     * Call {@link PostScorer}s to let them do their job, after the main scorers have been processed.
     */
    void postHandle() {
        for (PostScorer<P, F> post : this.config.getPostScorers()) {
            post.handle(this);
            this.rankScores(); // Because post-scorers might change the result, re-rank the scores to always have proper numbers.
        }
    }

    @Override
    public P getParameters() {
        return this.params;
    }

    /**
     * Get a List of all the ranks. Each rank is a list of all the {@link FieldScore} objects in that rank
     * @return A list of all the ranks, where the first item in the list is the best rank
     */
    public List<List<FieldScore<F>>> getRankedScores() {
        return rankedScores;
    }

    /**
     * @return A {@link HashMap} copy of the scores that are contained in this object
     */
    public Map<F, FieldScore<F>> getScores() {
        return new HashMap<F, FieldScore<F>>(this.scores);
    }

    /**
     * Get the {@link FieldScore} object for a specific field.
     * @param field Field to get data for
     * @return FieldScore for the specified field.
     */
    public FieldScore<F> getScoreFor(F field) {
        return scores.get(field);
    }

    /**
     * (Re-)calculates rankings for all the fields, and also calculates a normalization of their score
     */
    public void rankScores() {
        SortedSet<Entry<F, FieldScore<F>>> sorted = ScoreTools.entriesSortedByValues(this.scores, true);
        rankedScores = new LinkedList<List<FieldScore<F>>>();
        if (sorted.isEmpty())
            return;
        double minScore = sorted.last().getValue().getScore();
        double maxScore = sorted.first().getValue().getScore();
        double lastScore = maxScore + 1;

        int rank = 0;
        List<FieldScore<F>> currentRank = new LinkedList<FieldScore<F>>();
        for (Entry<F, FieldScore<F>> score : sorted) {
            if (lastScore != score.getValue().getScore()) {
                lastScore = score.getValue().getScore();
                rank++;
                currentRank = new LinkedList<FieldScore<F>>();
                rankedScores.add(currentRank);
            }
            score.getValue().setRank(rank);
            double normalized = ScoreTools.normalized(score.getValue().getScore(), minScore, maxScore - minScore);

            score.getValue().setNormalized(normalized);
            currentRank.add(score.getValue());
        }
    }

    /**
     * Get all {@link FieldScore} objects for a specific rank
     * @param rank From 1 to getRankLength() 
     * @return A list of all FieldScores for the specified rank
     */
    public List<FieldScore<F>> getRank(int rank) {
        if (rankedScores.isEmpty()) return null;
        return rankedScores.get(rank - 1);
    }
    /**
     * Get the number of ranks
     * @return The number of ranks
     */
    public int getRankCount() {
        return rankedScores.size();
    }
    /**
     * @return The score configuration that was used to calculate these field scores.
     */
    public ScoreConfig<P, F> getConfig() {
        return this.config;
    }

    void setAnalyzes(Map<Class<?>, Object> analyzes) {
        this.analyzes = new HashMap<Class<?>, Object>(analyzes);
    }

    /**
     * @param detailed True to store detailed information about which scorer gives which score to which field. False otherwise
     */
    public void setDetailed(boolean detailed) {
        this.detailed = detailed;
    }
}

/**
 * A scorer that can apply/modify scores after the regular {@link AbstractScorer}s have done their job.
 *
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public abstract class PostScorer<P, F> implements Scorer {
    @Override
    public String toString() {
        return "Post-" + this.getClass().getSimpleName();
    }

    /**
     * Optionally apply any scores to the given {@link FieldScores} object.
     * @param scores The collection of scores to work on.
     */
    public abstract void handle(FieldScores<P, F> scores);

    /**
     * Add score to a field
     * @param fscore {@link FieldScore} container for the field
     * @param score Score to give
     */
    protected void addScore(FieldScore<F> fscore, double score) {
        if (fscore == null) 
            throw new NullPointerException("FieldScore was null.");
        fscore.giveExtraScore(this, score);
    }
    /**
     * Add score to a field
     * @param scores {@link FieldScores} object containing the field
     * @param field Field to apply score for
     * @param score Score to apply
     */
    protected void addScore(FieldScores<P, F> scores, F field, double score) {
        FieldScore<F> fscore = scores.getScoreFor(field);
        this.addScore(fscore, score);
    }
    /**
     * Set score to an exact value for a field
     * @param scores {@link FieldScores} object containing the field
     * @param field Field to apply score for
     * @param score Score to apply
     */
    protected void setScore(FieldScores<P, F> scores, F field, double score) {
        FieldScore<F> fscore = scores.getScoreFor(field);
        if (fscore == null)
            throw new NullPointerException("Field " + field + " does not have any matching FieldScore.");
        fscore.giveExtraScore(this, score - fscore.getScore());
    }
}

/**
 * Interface for performing analyze work before scorers start scoring.
 * @param <P> Score parameter type
 */
public interface PreScorer<P> {
    /**
     * Perform analyze and return result of analyze
     * @param params The score parameters
     * @return The object that can be retrieved by the scorers
     */
    Object analyze(P params);
    /**
     * Method that can be used to clean-up variables and resources. Called when a {@link FieldScores} object has been fully completed.
     */
    void onScoringComplete();
}

/**
 * Score Configuration containing instances of {@link PreScorer}, {@link PostScorer} and {@link AbstractScorer}
 *
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public class ScoreConfig<P, F> {
    private final ScoreSet<P, F> scorers;
    private final List<PostScorer<P, F>> postScorers;
    private final List<PreScorer<P>> preScorers;

    public ScoreConfig(ScoreConfig<P, F> copy) {
        this(copy.preScorers, copy.postScorers, copy.scorers);
    }

    public ScoreConfig(List<PreScorer<P>> preScorers, List<PostScorer<P, F>> postScorers, ScoreSet<P, F> scorers) {
        this.postScorers = new ArrayList<PostScorer<P,F>>(postScorers);
        this.preScorers = new ArrayList<PreScorer<P>>(preScorers);
        this.scorers = new ScoreSet<P, F>(scorers);
    }

    public List<PostScorer<P, F>> getPostScorers() {
        return postScorers;
    }

    public ScoreSet<P, F> getScorers() {
        return scorers;
    }

    public List<PreScorer<P>> getPreScorers() {
        return preScorers;
    }

    @Override
    public String toString() {
        return "Scorers:{PreScorer: " + preScorers + ", PostScorer: " + postScorers + ", Scorers: " + scorers + "}";
    }
}

/**
 * Factory class for creating a {@link ScoreConfig}
 * 
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public class ScoreConfigFactory<P, F> {
    private ScoreSet<P, F>  scoreSet;
    private final List<PostScorer<P, F>> postScorers;
    private final List<PreScorer<P>> preScorers;

    public static <Params, Field> ScoreConfigFactory<Params, Field> newInstance() {
        return new ScoreConfigFactory<Params, Field>();
    }

    public ScoreConfigFactory() {
        this.scoreSet = new ScoreSet<P, F>();
        this.postScorers = new LinkedList<PostScorer<P, F>>();
        this.preScorers = new LinkedList<PreScorer<P>>();
    }

    public ScoreConfigFactory<P, F> withScoreConfig(ScoreConfig<P, F> config) {
        ScoreConfigFactory<P, F> result = this;

        for (PreScorer<P> pre : config.getPreScorers()) {
            if (!preScorers.contains(pre))
                result = withPreScorer(pre);
        }

        for (PostScorer<P, F> post : config.getPostScorers()) {
            if (!postScorers.contains(post))
                result = withPost(post);
        }

        for (Entry<AbstractScorer<P, F>, Double> scorer : config.getScorers().entrySet()) {
            AbstractScorer<P, F> key = scorer.getKey();
            double value = scorer.getValue();
            if (!scoreSet.containsKey(key))
                result = withScorer(key, value);
            else {
                scoreSet.put(key, value + scoreSet.get(key));
            }
        }

        return result;
    }

    public ScoreConfigFactory<P, F> copy() {
        ScoreConfigFactory<P, F> newInstance = new ScoreConfigFactory<P, F>();
        return newInstance.withScoreConfig(this.build());
    }

    /**
     * Add a scorer to this factory
     * @param scorer Scorer to add
     * @return This factory
     */
    public ScoreConfigFactory<P, F> withScorer(AbstractScorer<P, F> scorer) {
        scoreSet.put(scorer, 1.0);
        return this;
    }
    /**
     * Add a scorer with the specified weight to this factory.
     * @param scorer Scorer to add
     * @param weight Weight that should be applied to the scorer
     * @return This factory
     */
    public ScoreConfigFactory<P, F> withScorer(AbstractScorer<P, F> scorer, double weight) {
        scoreSet.put(scorer, weight);
        return this;
    }
    /**
     * Multiply all current {@link AbstractScorer}s in this factory's {@link ScoreSet} weights by a factor
     * @param value Factor to multiply with
     * @return This factory
     */
    public ScoreConfigFactory<P, F> multiplyAll(double value) {
        ScoreSet<P, F> oldScoreSet = scoreSet;
        scoreSet = new ScoreSet<P, F>();
        for (Map.Entry<AbstractScorer<P, F>, Double> ee : oldScoreSet.entrySet()) {
            scoreSet.put(ee.getKey(), ee.getValue() * value);
        }

        return this;
    }

    /**
     * Add a {@link PostScorer} to this factory.
     * @param post PostScorer to add
     * @return This factory
     */
    public ScoreConfigFactory<P, F> withPost(PostScorer<P, F> post) {
        postScorers.add(post);
        return this;
    }

    /**
     * Create a {@link ScoreConfig} from this factory.
     * @return A {@link ScoreConfig} for the {@link PreScorer}s, {@link PostScorer} and {@link AbstractScorer}s that has been added to this factory.
     */
    public ScoreConfig<P, F> build() {
        return new ScoreConfig<P, F>(this.preScorers, this.postScorers, this.scoreSet);
    }

    /**
     * Add a {@link PreScorer} to this factory
     * @param analyzer PreScorer to add
     * @return This factory
     */
    public ScoreConfigFactory<P, F> withPreScorer(PreScorer<P> analyzer) {
        this.preScorers.add(analyzer);
        return this;
    }



}

/**
 * Interface for retrieving analyzes and parameters that are used for scoring 
 * @param <P> Score parameter type
 */
public interface ScoreParameters<P> {
    /**
     * @param clazz The class to get the analyze for
     * @return The analyze for the specified class, or null if none was found
     */
    <E> E getAnalyze(Class<E> clazz);
    /**
     * @return Parameter object that are used in the scoring
     */
    P getParameters();
    /**
     * @return All available analyze objects
     */
    Map<Class<?>, Object> getAnalyzes();
    ScoreStrategy<P, ?> getScoreStrategy();
}

/**
 * Marker for classes that are a part of scoring things, i.e. {@link PostScorer} and {@link AbstractScorer}.
 */
public interface Scorer { }

/**
 * Map of {@link AbstractScorer}s and the weight that should be applied to them.
 *
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public class ScoreSet<P, F> extends LinkedHashMap<AbstractScorer<P, F>, Double> {
    private static final long   serialVersionUID    = 5924233965213820945L;

    ScoreSet() {
    }
    ScoreSet(ScoreSet<P, F> copy) {
        super(copy);
    }
}

/**
 * Responsible for determining which fields to score with the specified params
 * @param <P> Score parameter type
 * @param <F> The type to apply scores to
 */
public interface ScoreStrategy<P, F> {
    /**
     * Determine the collection of fields to score given the specified params
     * @param params Parameter for the scoring
     * @return A collection of fields which to score
     */
    Collection<F> getFieldsToScore(P params);
    /**
     * Determine whether or not scoring of a particular field should be done, allowing {@link PreScorer}s from the analyze to be taken into consideration.
     * @param parameters Parameters, including analyze objects created by {@link PreScorer}s.
     * @param field The field to score or not to score, that is the question.
     * @return True to score field, false to skip scoring of it.
     */
    boolean canScoreField(ScoreParameters<P> parameters, F field);
}

public class ScoreSet<P, F> extends LinkedHashMap<AbstractScorer<P, F>, Double>

private static final ASCENDING_VALUE_COMPARATOR = new Comparator<Map.Entry<K, V>>() {
    @Override
    public int compare(Map.Entry<K, V> e1, Map.Entry<K, V> e2) {
        int res;
        e1.getValue().compareTo(e2.getValue());
        else res = e2.getValue().compareTo(e1.getValue());
        return res != 0 ? -res : 1; // Special fix to preserve items with equal values
    }
}

if (descending) res = e1.getValue().compareTo(e2.getValue());
else res = e2.getValue().compareTo(e1.getValue());

public FieldScore(final F field, final boolean detailed) {
    this.field = field;

FieldScores<P, F> scores = new FieldScores<P, F>(params, config, scoreStrategy);
scores.setAnalyzes(analyzes);
scores.determineActiveScorers();
scores.calculateScores();
scores.rankScores();
scores.postHandle();

public static <K, V extends Comparable<? super V>> SortedSet<Map.Entry<K, V>> entriesSortedByValues(Map<K, V> map, final boolean descending) {
    SortedSet<Map.Entry<K, V>> sortedEntries = new TreeSet<Map.Entry<K, V>>(
        new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> e1, Map.Entry<K, V> e2) {
                int res;
                if (descending) res = e1.getValue().compareTo(e2.getValue());
                else res = e2.getValue().compareTo(e1.getValue());
                return res != 0 ? -res : 1; // Special fix to preserve items with equal values
            }
        }
    );
    sortedEntries.addAll(map.entrySet());
    return sortedEntries;
}

int res;
if (descending) res = e1.getValue().compareTo(e2.getValue());
else res = e2.getValue().compareTo(e1.getValue());
if (res != 0 || e1.equals(e2)) {
    return res;
}

res = Integer.compare(e1.getKey().hashCode(), e2.getKey().hashCode());
if (res != 0 || e1.equals(e2)) {
    return res;
}

res = Integer.compare(e1.getValue().hashCode(), e2.getValue().hashCode());
if (res != 0 || e1.equals(e2)) {
    return res;
}

if (!uniqueIdMap.contains(e1)) {
     uniqueIdMap.put(e1, uniqueIdMap.size());
}
if (!uniqueIdMap.contains(e2)) {
     uniqueIdMap.put(e2, uniqueIdMap.size());
}
return uniqueIdMap.get(e1) - uniqueIdMap.get(e2);

private Map<Map.Entry<K, V>, Integer> uniqueIdMap;