// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <vector>

#include <gflags/gflags.h>
#include <gtest/gtest.h>

#include "base/command_line.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "monitor_reconfig/resolution_selector.h"

DEFINE_bool(logtostderr, false,
            "Print debugging messages to stderr (suppressed otherwise)");

namespace monitor_reconfig {

using std::string;
using std::vector;

class ResolutionSelectorTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    lcd_resolution_ = new ResolutionSelector::Mode;
    external_resolution_ = new ResolutionSelector::Mode;
    screen_resolution_ = new ResolutionSelector::Mode;
  }

  // Add a mode to |lcd_modes_|.
  void AddLcdMode(int width, int height, int id) {
    lcd_modes_.push_back(
        ResolutionSelector::Mode(
            width, height, StringPrintf("%dx%d", width, height), id));
  }

  // Add a mode to |external_modes_|.
  void AddExternalMode(int width, int height, int id) {
    external_modes_.push_back(
        ResolutionSelector::Mode(
            width, height, StringPrintf("%dx%d", width, height), id));
  }

  // Ask |selector_| for the best resolutions and store them in
  // |lcd_resolution_|, |external_resolution_|, and |screen_resolution_|.
  // The return value from |FindBestResolutions()| is returned.
  bool GetResolutions() {
    return selector_.FindBestResolutions(lcd_modes_,
                                         external_modes_,
                                         lcd_resolution_,
                                         external_resolution_,
                                         screen_resolution_);
  }

  ResolutionSelector selector_;

  vector<ResolutionSelector::Mode> lcd_modes_;
  vector<ResolutionSelector::Mode> external_modes_;

  ResolutionSelector::Mode* lcd_resolution_;
  ResolutionSelector::Mode* external_resolution_;
  ResolutionSelector::Mode* screen_resolution_;
};

// We should use the LCD's max resolution when there's no external output
// connected.
TEST_F(ResolutionSelectorTest, NoExternalOutput) {
  AddLcdMode(1024, 768, 50);
  AddLcdMode(800, 600, 51);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("1024x768", lcd_resolution_->name);
  EXPECT_EQ("", external_resolution_->name);
  EXPECT_EQ("1024x768", screen_resolution_->name);
}

// When both outputs have the same max resolution, we should use it.
TEST_F(ResolutionSelectorTest, MatchingTopResolutions) {
  AddLcdMode(1024, 768, 50);
  AddLcdMode(800, 600, 51);
  AddExternalMode(1024, 768, 60);
  AddExternalMode(800, 600, 61);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("1024x768", lcd_resolution_->name);
  EXPECT_EQ("1024x768", external_resolution_->name);
  EXPECT_EQ("1024x768", screen_resolution_->name);
}

// We should use the highest shared resolution when the LCD has the higher
// max resolution.
TEST_F(ResolutionSelectorTest, LcdHasHigherResolution) {
  AddLcdMode(1024, 768, 50);
  AddLcdMode(800, 600, 51);
  AddLcdMode(640, 480, 52);
  AddExternalMode(800, 600, 60);
  AddExternalMode(640, 480, 61);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("800x600", lcd_resolution_->name);
  EXPECT_EQ("800x600", external_resolution_->name);
  EXPECT_EQ("800x600", screen_resolution_->name);
}

// We should use the highest shared resolution when the external output has
// the higher max resolution.
TEST_F(ResolutionSelectorTest, ExternalHasHigherResolution) {
  AddLcdMode(800, 600, 50);
  AddLcdMode(640, 480, 51);
  AddExternalMode(1024, 768, 60);
  AddExternalMode(800, 600, 61);
  AddExternalMode(640, 480, 62);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("800x600", lcd_resolution_->name);
  EXPECT_EQ("800x600", external_resolution_->name);
  EXPECT_EQ("800x600", screen_resolution_->name);
}

// When the maximum resolution offered by the two outputs is different, we
// should use the max resolution from the lower-res output.
TEST_F(ResolutionSelectorTest, MismatchedMaxResolution) {
  AddLcdMode(1024, 600, 50);
  AddLcdMode(800, 600, 51);
  AddExternalMode(1280, 720, 60);
  AddExternalMode(1024, 768, 61);
  AddExternalMode(800, 600, 62);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("1024x600", lcd_resolution_->name);
  EXPECT_EQ("1024x768", external_resolution_->name);
  EXPECT_EQ("1024x600", screen_resolution_->name);
}

// When the external output is large enough that we think it's a monitor,
// we should just use its maximum resolution instead of trying to find a
// size that'll also work for the LCD output.
TEST_F(ResolutionSelectorTest, ExternalOutputIsMonitor) {
  AddLcdMode(1024, 768, 50);
  AddLcdMode(800, 600, 51);
  AddExternalMode(1600, 1200, 60);
  AddExternalMode(1280, 960, 61);
  AddExternalMode(1024, 768, 62);
  ASSERT_GE(external_modes_[0].width * external_modes_[0].height,
            ResolutionSelector::kMaxProjectorPixels);
  ASSERT_TRUE(GetResolutions());
  EXPECT_EQ("", lcd_resolution_->name);
  EXPECT_EQ("1600x1200", external_resolution_->name);
  EXPECT_EQ("1600x1200", screen_resolution_->name);
}

// We should just fail if there's no common resolution between the two
// outputs.
TEST_F(ResolutionSelectorTest, FailIfNoCommonResolution) {
  AddLcdMode(1024, 768, 50);
  AddExternalMode(1280, 600, 60);
  EXPECT_FALSE(GetResolutions());
}

}  // namespace monitor_reconfig

int main(int argc, char** argv) {
  google::ParseCommandLineFlags(&argc, &argv, true);
  CommandLine::Init(argc, argv);
  logging::InitLogging(NULL,
                       FLAGS_logtostderr ?
                         logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG :
                         logging::LOG_NONE,
                       logging::DONT_LOCK_LOG_FILE,
                       logging::APPEND_TO_OLD_LOG_FILE);
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}