/*
 *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_MOCK_AUDIO_PROCESSING_H_
#define WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_MOCK_AUDIO_PROCESSING_H_

#include <memory>

#include "webrtc/modules/audio_processing/include/audio_processing.h"

namespace webrtc {

class MockEchoCancellation : public EchoCancellation {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_METHOD1(enable_drift_compensation,
      int(bool enable));
  MOCK_CONST_METHOD0(is_drift_compensation_enabled,
      bool());
  MOCK_METHOD1(set_stream_drift_samples,
      void(int drift));
  MOCK_CONST_METHOD0(stream_drift_samples,
      int());
  MOCK_METHOD1(set_suppression_level,
      int(SuppressionLevel level));
  MOCK_CONST_METHOD0(suppression_level,
      SuppressionLevel());
  MOCK_CONST_METHOD0(stream_has_echo,
      bool());
  MOCK_METHOD1(enable_metrics,
      int(bool enable));
  MOCK_CONST_METHOD0(are_metrics_enabled,
      bool());
  MOCK_METHOD1(GetMetrics,
      int(Metrics* metrics));
  MOCK_METHOD1(enable_delay_logging,
      int(bool enable));
  MOCK_CONST_METHOD0(is_delay_logging_enabled,
      bool());
  MOCK_METHOD2(GetDelayMetrics,
      int(int* median, int* std));
  MOCK_METHOD3(GetDelayMetrics,
      int(int* median, int* std, float* fraction_poor_delays));
  MOCK_CONST_METHOD0(aec_core,
      struct AecCore*());
};

class MockEchoControlMobile : public EchoControlMobile {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_METHOD1(set_routing_mode,
      int(RoutingMode mode));
  MOCK_CONST_METHOD0(routing_mode,
      RoutingMode());
  MOCK_METHOD1(enable_comfort_noise,
      int(bool enable));
  MOCK_CONST_METHOD0(is_comfort_noise_enabled,
      bool());
  MOCK_METHOD2(SetEchoPath,
      int(const void* echo_path, size_t size_bytes));
  MOCK_CONST_METHOD2(GetEchoPath,
      int(void* echo_path, size_t size_bytes));
};

class MockGainControl : public GainControl {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_METHOD1(set_stream_analog_level,
      int(int level));
  MOCK_METHOD0(stream_analog_level,
      int());
  MOCK_METHOD1(set_mode,
      int(Mode mode));
  MOCK_CONST_METHOD0(mode,
      Mode());
  MOCK_METHOD1(set_target_level_dbfs,
      int(int level));
  MOCK_CONST_METHOD0(target_level_dbfs,
      int());
  MOCK_METHOD1(set_compression_gain_db,
      int(int gain));
  MOCK_CONST_METHOD0(compression_gain_db,
      int());
  MOCK_METHOD1(enable_limiter,
      int(bool enable));
  MOCK_CONST_METHOD0(is_limiter_enabled,
      bool());
  MOCK_METHOD2(set_analog_level_limits,
      int(int minimum, int maximum));
  MOCK_CONST_METHOD0(analog_level_minimum,
      int());
  MOCK_CONST_METHOD0(analog_level_maximum,
      int());
  MOCK_CONST_METHOD0(stream_is_saturated,
      bool());
};

class MockHighPassFilter : public HighPassFilter {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
};

class MockLevelEstimator : public LevelEstimator {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_METHOD0(RMS,
      int());
};

class MockNoiseSuppression : public NoiseSuppression {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_METHOD1(set_level,
      int(Level level));
  MOCK_CONST_METHOD0(level,
      Level());
  MOCK_CONST_METHOD0(speech_probability,
      float());
  MOCK_METHOD0(NoiseEstimate, std::vector<float>());
};

class MockVoiceDetection : public VoiceDetection {
 public:
  MOCK_METHOD1(Enable,
      int(bool enable));
  MOCK_CONST_METHOD0(is_enabled,
      bool());
  MOCK_CONST_METHOD0(stream_has_voice,
      bool());
  MOCK_METHOD1(set_stream_has_voice,
      int(bool has_voice));
  MOCK_METHOD1(set_likelihood,
      int(Likelihood likelihood));
  MOCK_CONST_METHOD0(likelihood,
      Likelihood());
  MOCK_METHOD1(set_frame_size_ms,
      int(int size));
  MOCK_CONST_METHOD0(frame_size_ms,
      int());
};

class MockAudioProcessing : public AudioProcessing {
 public:
  MockAudioProcessing()
      : echo_cancellation_(new MockEchoCancellation),
        echo_control_mobile_(new MockEchoControlMobile),
        gain_control_(new MockGainControl),
        high_pass_filter_(new MockHighPassFilter),
        level_estimator_(new MockLevelEstimator),
        noise_suppression_(new MockNoiseSuppression),
        voice_detection_(new MockVoiceDetection) {
  }

  virtual ~MockAudioProcessing() {
  }

  MOCK_METHOD0(Initialize,
      int());
  MOCK_METHOD6(Initialize,
               int(int capture_input_sample_rate_hz,
                   int capture_output_sample_rate_hz,
                   int render_sample_rate_hz,
                   ChannelLayout capture_input_layout,
                   ChannelLayout capture_output_layout,
                   ChannelLayout render_input_layout));
  MOCK_METHOD1(Initialize,
      int(const ProcessingConfig& processing_config));
  MOCK_METHOD1(ApplyConfig, void(const Config& config));
  MOCK_METHOD1(SetExtraOptions, void(const webrtc::Config& config));
  MOCK_METHOD1(set_sample_rate_hz,
      int(int rate));
  MOCK_CONST_METHOD0(input_sample_rate_hz,
      int());
  MOCK_CONST_METHOD0(sample_rate_hz,
      int());
  MOCK_CONST_METHOD0(proc_sample_rate_hz,
      int());
  MOCK_CONST_METHOD0(proc_split_sample_rate_hz,
      int());
  MOCK_CONST_METHOD0(num_input_channels,
      size_t());
  MOCK_CONST_METHOD0(num_output_channels,
      size_t());
  MOCK_CONST_METHOD0(num_reverse_channels,
      size_t());
  MOCK_METHOD1(set_output_will_be_muted,
      void(bool muted));
  MOCK_CONST_METHOD0(output_will_be_muted,
      bool());
  MOCK_METHOD1(ProcessStream,
      int(AudioFrame* frame));
  MOCK_METHOD7(ProcessStream,
      int(const float* const* src,
          size_t samples_per_channel,
          int input_sample_rate_hz,
          ChannelLayout input_layout,
          int output_sample_rate_hz,
          ChannelLayout output_layout,
          float* const* dest));
  MOCK_METHOD4(ProcessStream,
               int(const float* const* src,
                   const StreamConfig& input_config,
                   const StreamConfig& output_config,
                   float* const* dest));
  MOCK_METHOD1(AnalyzeReverseStream,
      int(AudioFrame* frame));
  MOCK_METHOD1(ProcessReverseStream, int(AudioFrame* frame));
  MOCK_METHOD4(AnalyzeReverseStream,
               int(const float* const* data,
                   size_t samples_per_channel,
                   int sample_rate_hz,
                   ChannelLayout layout));
  MOCK_METHOD4(ProcessReverseStream,
               int(const float* const* src,
                   const StreamConfig& input_config,
                   const StreamConfig& output_config,
                   float* const* dest));
  MOCK_METHOD1(set_stream_delay_ms,
      int(int delay));
  MOCK_CONST_METHOD0(stream_delay_ms,
      int());
  MOCK_CONST_METHOD0(was_stream_delay_set,
      bool());
  MOCK_METHOD1(set_stream_key_pressed,
      void(bool key_pressed));
  MOCK_CONST_METHOD0(stream_key_pressed,
      bool());
  MOCK_METHOD1(set_delay_offset_ms,
      void(int offset));
  MOCK_CONST_METHOD0(delay_offset_ms,
      int());
  MOCK_METHOD2(StartDebugRecording,
               int(const char filename[kMaxFilenameSize],
                   int64_t max_log_size_bytes));
  MOCK_METHOD2(StartDebugRecording,
               int(FILE* handle, int64_t max_log_size_bytes));
  MOCK_METHOD0(StopDebugRecording,
      int());
  MOCK_METHOD0(UpdateHistogramsOnCallEnd, void());
  virtual MockEchoCancellation* echo_cancellation() const {
    return echo_cancellation_.get();
  }
  virtual MockEchoControlMobile* echo_control_mobile() const {
    return echo_control_mobile_.get();
  }
  virtual MockGainControl* gain_control() const {
    return gain_control_.get();
  }
  virtual MockHighPassFilter* high_pass_filter() const {
    return high_pass_filter_.get();
  }
  virtual MockLevelEstimator* level_estimator() const {
    return level_estimator_.get();
  }
  virtual MockNoiseSuppression* noise_suppression() const {
    return noise_suppression_.get();
  }
  virtual MockVoiceDetection* voice_detection() const {
    return voice_detection_.get();
  }

 private:
  std::unique_ptr<MockEchoCancellation> echo_cancellation_;
  std::unique_ptr<MockEchoControlMobile> echo_control_mobile_;
  std::unique_ptr<MockGainControl> gain_control_;
  std::unique_ptr<MockHighPassFilter> high_pass_filter_;
  std::unique_ptr<MockLevelEstimator> level_estimator_;
  std::unique_ptr<MockNoiseSuppression> noise_suppression_;
  std::unique_ptr<MockVoiceDetection> voice_detection_;
};

}  // namespace webrtc

#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_MOCK_AUDIO_PROCESSING_H_