// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CC_TEST_PIXEL_COMPARATOR_H_
#define CC_TEST_PIXEL_COMPARATOR_H_

#include "base/compiler_specific.h"
#include "third_party/skia/include/core/SkBitmap.h"

namespace cc {

// Interface for pixel comparators.
class PixelComparator {
 public:
  virtual ~PixelComparator() = default;

  virtual bool Compare(const SkBitmap& actual_bmp,
                       const SkBitmap& expected_bmp) const = 0;
};

// Exact pixel comparator. Counts the number of pixel with an error.
class ExactPixelComparator : public PixelComparator {
 public:
  // Returns true if the two bitmaps are identical. Otherwise, returns false
  // and report the number of pixels with an error on LOG(ERROR).
  bool Compare(const SkBitmap& actual_bmp,
               const SkBitmap& expected_bmp) const override;

 protected:
  // Exclude alpha channel from comparison?
  bool discard_alpha_ = false;
};

class AlphaDiscardingExactPixelComparator : public ExactPixelComparator {
 public:
  AlphaDiscardingExactPixelComparator() { discard_alpha_ = true; }
};

// Different platforms have slightly different pixel output, due to different
// graphics implementations. Slightly different pixels (in BGR space) are still
// counted as a matching pixel by this simple manhattan distance threshold.
// If, at any pixel, the sum of the absolute differences in each color component
// (excluding alpha) exceeds the threshold the test is failed.
class ManhattanDistancePixelComparator : public PixelComparator {
 public:
  explicit ManhattanDistancePixelComparator(int tolerance = 25);
  ~ManhattanDistancePixelComparator() override = default;

  // Returns true if the two bitmaps are identical within the specified
  // manhattan distance. Otherwise, returns false and report the first pixel
  // that differed by more than the tolerance distance using a LOG(ERROR).
  // Differences in the alpha channel are ignored.
  bool Compare(const SkBitmap& actual_bmp,
               const SkBitmap& expected_bmp) const override;

 private:
  const int tolerance_;
};

// Fuzzy pixel comparator. Counts small and arbitrary errors separately and
// computes average and maximum absolute errors per color channel. It can be
// configured to discard alpha channel. If alpha channel is not discarded
// (by default), alpha changing among fully transparent, translucent and fully
// opaque (e.g. 0 to 1, 254 to 255) are always reported.
class FuzzyPixelComparator : public PixelComparator {
 public:
  FuzzyPixelComparator& DiscardAlpha() {
    discard_alpha_ = true;
    return *this;
  }
  // Sets the limits for percentages of pixels with errors:
  // - large errors: >small_abs_error_limit_,
  // - small errors: >0 and <= small_abs_error_limit_.
  // If small_abs_error_limit_ is zero (by default),
  // `large_error_pixels_percentage_limit` is for all errors.
  FuzzyPixelComparator& SetErrorPixelsPercentageLimit(
      float large_error_pixels_percentage_limit,
      float small_error_pixels_percentage_limit = 0) {
    large_error_pixels_percentage_limit_ = large_error_pixels_percentage_limit;
    small_error_pixels_percentage_limit_ = small_error_pixels_percentage_limit;
    return *this;
  }
  // Sets limit for average absolute error (excluding identical pixels).
  // The default is 255.0, which means it's not checked.
  FuzzyPixelComparator& SetAvgAbsErrorLimit(float avg_abs_error_limit) {
    avg_abs_error_limit_ = avg_abs_error_limit;
    return *this;
  }
  // Sets limits of the largest absolute error and the small absolute error.
  // The default of `max_abs_error_limit` is 255, which means it's not checked
  // by default. The default of `small_abs_eror_limit` is 0, which means all
  // errors are treated as large errors by default.
  FuzzyPixelComparator& SetAbsErrorLimit(int max_abs_error_limit,
                                         int small_abs_error_limit = 0) {
    max_abs_error_limit_ = max_abs_error_limit;
    small_abs_error_limit_ = small_abs_error_limit;
    return *this;
  }

  // Computes error metrics and returns true if the errors don't exceed the
  // specified limits. Otherwise, returns false and reports the error metrics on
  // LOG(ERROR).
  bool Compare(const SkBitmap& actual_bmp,
               const SkBitmap& expected_bmp) const override;

 private:
  // Exclude alpha channel from comparison?
  bool discard_alpha_ = false;
  float large_error_pixels_percentage_limit_ = 0;
  // Limit for percentage of pixels with a small error
  // (>0 and <= small_abs_error_limit_).
  float small_error_pixels_percentage_limit_ = 0;
  float avg_abs_error_limit_ = 255.0;
  int max_abs_error_limit_ = 255;
  int small_abs_error_limit_ = 0;
};

// All pixels can be off by one, but any more than that is an error.
class FuzzyPixelOffByOneComparator : public FuzzyPixelComparator {
 public:
  FuzzyPixelOffByOneComparator() {
    SetErrorPixelsPercentageLimit(100.f);
    SetAbsErrorLimit(1);
  }

 protected:
  using FuzzyPixelComparator::DiscardAlpha;
  using FuzzyPixelComparator::SetAbsErrorLimit;
  using FuzzyPixelComparator::SetAvgAbsErrorLimit;
  using FuzzyPixelComparator::SetErrorPixelsPercentageLimit;
};

class AlphaDiscardingFuzzyPixelOffByOneComparator
    : public FuzzyPixelOffByOneComparator {
 public:
  AlphaDiscardingFuzzyPixelOffByOneComparator() { DiscardAlpha(); }
};
}  // namespace cc

#endif  // CC_TEST_PIXEL_COMPARATOR_H_