/*
   * Returns the mean of the trust opinions of the specified trustee.
   */
  private double retrieveMeanTrustOpinion(final TrustedEntityId trusteeId) throws TrustException {

    final Set<ITrustEvidence> evidenceSet =
        super.trustEvidenceRepo.retrieveLatestEvidence(
            trusteeId, null, TrustEvidenceType.DIRECTLY_TRUSTED, null);
    double sum = 0.0d;
    int count = 0;
    for (final ITrustEvidence evidence : evidenceSet) {
      if (evidence.getInfo() instanceof Double) {
        sum += (Double) evidence.getInfo();
        count++;
      }
    }

    return (count > 0) ? sum / count : 0.0d;
  }
  /**
   * Checks if the specified piece of evidence is relevant for the supplied trustor. More
   * specifically, a piece of evidence is relevant for indirect trust evaluation if:
   *
   * <ol>
   *   <li>type == {@link TrustEvidenceType#DIRECTLY_TRUSTED DIRECTLY_TRUSTED}
   *   <li>trustorId != evidence.subjectId, i.e. ignore trust opinions originating <i>from</i> the
   *       trustor
   *   <li>trustorId != evidence.objectId, i.e. ignore trust opinions <i>about</i> the trustor
   *   <li>evidence.subjectId != evidence.objectId, i.e. ignore self-referencing trust opinions
   * </ol>
   *
   * @param trustorId
   * @param evidence
   * @return <code>true</code> if the specified piece of evidence is relevant for the supplied
   *     trustor; <code>false</code> otherwise.
   */
  private boolean areRelevant(final TrustedEntityId trustorId, final ITrustEvidence evidence) {

    boolean result = false;

    if (TrustEvidenceType.DIRECTLY_TRUSTED == evidence.getType()
        && !trustorId.equals(evidence.getSubjectId())
        && !trustorId.equals(evidence.getObjectId())
        && !evidence.getSubjectId().equals(evidence.getObjectId())) {
      result = true;
    }

    LOG.debug(
        "areRelevant: trustorId={}, evidence={}, result={}",
        new Object[] {trustorId, evidence, result});
    return result;
  }
  private static Set<TrustEvidence> iEvidenceToEvidence(Set<ITrustEvidence> evidenceSet) {

    final Set<TrustEvidence> result = new LinkedHashSet<TrustEvidence>(evidenceSet.size());
    for (final ITrustEvidence evidence : evidenceSet) {
      result.add(
          new TrustEvidence(
              evidence.getSubjectId(),
              evidence.getObjectId(),
              evidence.getType(),
              evidence.getTimestamp(),
              evidence.getInfo(),
              evidence.getSourceId()));
    }

    return result;
  }
  /*
   * @see org.societies.privacytrust.trust.api.engine.IIndirectTrustEngine#evaluate(org.societies.api.privacytrust.trust.model.TrustedEntityId, org.societies.privacytrust.trust.api.evidence.model.ITrustEvidence)
   */
  @Override
  public Set<ITrustedEntity> evaluate(
      final TrustedEntityId trustorId, final ITrustEvidence evidence) throws TrustEngineException {

    if (trustorId == null) {
      throw new NullPointerException("trustorId can't be null");
    }
    if (evidence == null) {
      throw new NullPointerException("evidence can't be null");
    }

    LOG.debug("evaluate: trustorId={}, evidence={}", trustorId, evidence);

    final Set<ITrustedEntity> resultSet = new HashSet<ITrustedEntity>();

    if (!this.areRelevant(trustorId, evidence)) {
      return resultSet;
    }

    try {
      // Does similarity between trustor and subject needs re-evaluation?
      boolean doSimilarityEval = false;
      // Create the trusted entity the evidence object refers to if not already available
      ITrustedEntity trustee =
          (ITrustedEntity) this.trustRepo.retrieveEntity(trustorId, evidence.getObjectId());
      if (trustee == null) {
        trustee = super.trustRepo.createEntity(trustorId, evidence.getObjectId());
      } else {
        doSimilarityEval = true;
      }
      LOG.debug("evaluate: doSimilarity={}", doSimilarityEval);
      resultSet.add(trustee);

      switch (evidence.getType()) {

          // Update value
        case DIRECTLY_TRUSTED:
          // Check if similarity between trustor and subject needs re-evaluation
          if (doSimilarityEval
              && TrustedEntityType.CSS == evidence.getSubjectId().getEntityType()) {
            final ITrustedCss subject =
                (ITrustedCss) super.createEntityIfAbsent(trustorId, evidence.getSubjectId());
            final Double similarity =
                this.trustSimilarityEvaluator.evaluateCosineSimilarity(
                    trustorId, evidence.getSubjectId());
            LOG.debug("evaluate: similarity={}", similarity);
            if (similarity != null && !Double.isNaN(similarity)) {
              subject.setSimilarity(similarity);
              super.trustRepo.updateEntity(subject);
            }
          }
          // Fetch top N users
          final Map<TrustedEntityId, ITrustedCss> topNCssMap = this.retrieveTopNCss(trustorId);
          LOG.debug("evaluate: topNCssMap={}", topNCssMap);
          double weightedOpinionSum = 0d;
          double weightSum = 0d;
          // Retrieve all Indirect Trust Evidence related to the object
          // referenced in the specified TrustEvidence
          final Set<ITrustEvidence> evidenceSet =
              super.trustEvidenceRepo.retrieveLatestEvidence(
                  null, evidence.getObjectId(), evidence.getType(), null);
          LOG.debug("evaluate: evidenceSet={}", evidenceSet);
          for (final ITrustEvidence relatedEvidence : evidenceSet) {
            if (!(relatedEvidence.getInfo() instanceof Double)) {
              LOG.warn("Related evidence " + relatedEvidence + " has no trust value!");
              continue;
            }
            final ITrustedCss opinionSource = topNCssMap.get(relatedEvidence.getSubjectId());
            if (opinionSource == null) {
              LOG.warn(
                  "Could not find CSS trust relationship with related evidence subject '"
                      + relatedEvidence.getSubjectId()
                      + "'");
              continue;
            }
            final Double weight = evaluateWeight(opinionSource);
            Double weightedOpinion = null;
            if (weight != null) {
              final double meanOpinion =
                  this.retrieveMeanTrustOpinion(relatedEvidence.getSubjectId());
              weightedOpinion = weight * ((Double) relatedEvidence.getInfo() - meanOpinion);
              LOG.debug(
                  "evaluate: subjectId={}, meanOpinion={}, weightedOpinion={}",
                  new Object[] {relatedEvidence.getSubjectId(), meanOpinion, weightedOpinion});
            }
            if (weightedOpinion == null) {
              LOG.warn(
                  "Ignoring related evidence " + relatedEvidence + ": Weighted opinion is null");
              continue;
            }
            weightedOpinionSum += weightedOpinion;
            weightSum += Math.abs(weight);
          }
          LOG.debug("evaluate: weightedOpinionSum={}, weightSum={}", weightedOpinionSum, weightSum);
          // t_x,i = avg(t_x) + weighted opinions
          double value =
              super.trustRepo.retrieveMeanTrustValue(trustorId, TrustValueType.DIRECT, null);
          final double confidence;
          if (weightSum > 0) {
            value += weightedOpinionSum / weightSum;
            confidence = 0.5d; // TODO constant or what?
          } else {
            confidence = 0.25d; // TODO constant or what?
          }
          LOG.debug("evaluate: value={}", value);
          if (value > 1) {
            value = 1.0d; // TODO use constant
          } else if (value < 0) {
            value = 0.0d; // TODO use constant
          }
          trustee.getIndirectTrust().setValue(value);
          trustee.getIndirectTrust().setConfidence(confidence);
          break;

        default:
          throw new TrustEngineException("Unsupported type: " + evidence.getType());
      }

      // Add related evidence to trustee
      trustee.addEvidence(evidence);

      // Persist updated TrustedEntities in the Trust Repository
      for (final ITrustedEntity entity : resultSet) {
        super.trustRepo.updateEntity(entity);
      }

    } catch (Exception e) {
      throw new TrustEngineException(
          "Could not evaluate indirect trust evidence " + evidence + ": " + e.getLocalizedMessage(),
          e);
    }

    return resultSet;
  }