/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Author: sligocki@google.com (Shawn Ligocki)

#include "net/instaweb/rewriter/public/css_rewrite_test_base.h"

#include "base/logging.h"
#include "net/instaweb/rewriter/public/css_url_extractor.h"
#include "net/instaweb/rewriter/public/resource_namer.h"
#include "pagespeed/kernel/base/gtest.h"
#include "pagespeed/kernel/base/hasher.h"
#include "pagespeed/kernel/base/statistics.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/timer.h"
#include "pagespeed/kernel/base/wildcard.h"
#include "pagespeed/kernel/html/html_parse_test_base.h"
#include "pagespeed/kernel/http/content_type.h"
#include "pagespeed/kernel/http/google_url.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

CssRewriteTestBase::~CssRewriteTestBase() {}

// Check that inline CSS gets rewritten correctly.
bool CssRewriteTestBase::ValidateRewriteInlineCss(
    StringPiece id, StringPiece css_input, StringPiece expected_css_output,
    int flags) {
  static const char prefix[] =
      "<head>\n"
      "  <title>Example style outline</title>\n"
      "  <!-- Style starts here -->\n"
      "  <style type='text/css'>";
  static const char suffix1[] = "</style>";
  static const char suffix2[] =
      "\n"
      "  <!-- Style ends here -->\n"
      "</head>";

  GoogleString html_url = StrCat(kTestDomain, id, ".html");

  CheckFlags(flags);
  GoogleString html_input  = StrCat(prefix, css_input, suffix1, suffix2);
  GoogleString html_output = StrCat(prefix, expected_css_output, suffix1,
                                    DebugMessage(html_url), suffix2);

  return ValidateWithStats(id, html_input, html_output,
                           css_input, expected_css_output, flags);
}

void CssRewriteTestBase::ResetStats() {
  num_blocks_rewritten_->Clear();
  num_fallback_rewrites_->Clear();
  num_parse_failures_->Clear();
  num_rewrites_dropped_->Clear();
  total_bytes_saved_->Clear();
  total_original_bytes_->Clear();
  num_uses_->Clear();
  num_flatten_imports_charset_mismatch_->Clear();
  num_flatten_imports_invalid_url_->Clear();
  num_flatten_imports_limit_exceeded_->Clear();
  num_flatten_imports_minify_failed_->Clear();
  num_flatten_imports_recursion_->Clear();
  num_flatten_imports_complex_queries_->Clear();
}

bool CssRewriteTestBase::ValidateWithStats(
    StringPiece id,
    StringPiece html_input, StringPiece expected_html_output,
    StringPiece css_input, StringPiece expected_css_output,
    int flags) {
  ResetStats();

  // Rewrite
  bool success = ValidateExpected(id, html_input, expected_html_output);

  // Check stats
  if (success && !FlagSet(flags, kNoStatCheck)) {
    if (FlagSet(flags, kExpectSuccess)) {
      EXPECT_EQ(1, num_blocks_rewritten_->Get()) << css_input;
      EXPECT_EQ(0, num_fallback_rewrites_->Get()) << css_input;
      EXPECT_EQ(0, num_parse_failures_->Get()) << css_input;
      EXPECT_EQ(0, num_rewrites_dropped_->Get()) << css_input;
      EXPECT_EQ(static_cast<int>(css_input.size()) -
                static_cast<int>(expected_css_output.size()),
                total_bytes_saved_->Get()) << css_input;
      EXPECT_EQ(css_input.size(), total_original_bytes_->Get()) << css_input;
      EXPECT_EQ(1, num_uses_->Get()) << css_input;
    } else if (FlagSet(flags, kExpectCached)) {
      EXPECT_EQ(0, num_blocks_rewritten_->Get()) << css_input;
      EXPECT_EQ(0, num_fallback_rewrites_->Get()) << css_input;
      EXPECT_EQ(0, num_parse_failures_->Get()) << css_input;
      EXPECT_EQ(0, total_bytes_saved_->Get()) << css_input;
      EXPECT_EQ(0, total_original_bytes_->Get()) << css_input;
      EXPECT_EQ(1, num_uses_->Get()) << css_input;  // The only non-zero value.
    } else if (FlagSet(flags, kExpectNoChange)) {
      EXPECT_EQ(0, num_blocks_rewritten_->Get()) << css_input;
      EXPECT_EQ(0, num_fallback_rewrites_->Get()) << css_input;
      EXPECT_EQ(0, num_parse_failures_->Get()) << css_input;
      // TODO(sligocki): Test num_rewrites_dropped_. Currently a couple tests
      // have kExpectNoChange, but fail at a different place in the code, so
      // they do not trigger the num_rewrites_dropped_ variable.
      // EXPECT_EQ(1, num_rewrites_dropped_->Get()) << css_input;
      EXPECT_EQ(0, total_bytes_saved_->Get()) << css_input;
      EXPECT_EQ(0, total_original_bytes_->Get()) << css_input;
      EXPECT_EQ(0, num_uses_->Get()) << css_input;
    } else if (FlagSet(flags, kExpectFallback)) {
      EXPECT_EQ(0, num_blocks_rewritten_->Get()) << css_input;
      EXPECT_EQ(1, num_fallback_rewrites_->Get()) << css_input;
      EXPECT_EQ(1, num_parse_failures_->Get()) << css_input;
      EXPECT_EQ(0, num_rewrites_dropped_->Get()) << css_input;
      EXPECT_EQ(0, total_bytes_saved_->Get()) << css_input;
      EXPECT_EQ(0, total_original_bytes_->Get()) << css_input;
      EXPECT_EQ(1, num_uses_->Get()) << css_input;
    } else {
      CHECK(FlagSet(flags, kExpectFailure));
      EXPECT_EQ(0, num_blocks_rewritten_->Get()) << css_input;
      EXPECT_EQ(0, num_fallback_rewrites_->Get()) << css_input;
      EXPECT_EQ(1, num_parse_failures_->Get()) << css_input;
      EXPECT_EQ(0, num_rewrites_dropped_->Get()) << css_input;
      EXPECT_EQ(0, total_bytes_saved_->Get()) << css_input;
      EXPECT_EQ(0, total_original_bytes_->Get()) << css_input;
      EXPECT_EQ(0, num_uses_->Get()) << css_input;
    }
  }

  // Check each of the import flattening statistics. Since each of these
  // is controlled individually they are not gated by kNoStatCheck above,
  // although if the results were fetched from the cache the flattener
  // doesn't count these as new errors so skip this check in that case.
  if (!FlagSet(flags, kExpectCached)) {
    EXPECT_EQ(FlagSet(flags, kFlattenImportsCharsetMismatch) ? 1 : 0,
              num_flatten_imports_charset_mismatch_->Get()) << css_input;
    EXPECT_EQ(FlagSet(flags, kFlattenImportsInvalidUrl) ? 1 : 0,
              num_flatten_imports_invalid_url_->Get()) << css_input;
    EXPECT_EQ(FlagSet(flags, kFlattenImportsLimitExceeded) ? 1 : 0,
              num_flatten_imports_limit_exceeded_->Get()) << css_input;
    EXPECT_EQ(FlagSet(flags, kFlattenImportsMinifyFailed) ? 1 : 0,
              num_flatten_imports_minify_failed_->Get()) << css_input;
    EXPECT_EQ(FlagSet(flags, kFlattenImportsRecursion) ? 1 : 0,
              num_flatten_imports_recursion_->Get()) << css_input;
    EXPECT_EQ(FlagSet(flags, kFlattenImportsComplexQueries) ? 1 : 0,
              num_flatten_imports_complex_queries_->Get()) << css_input;
  }

  // TODO(sligocki): This success value does not reflect failures in the
  // stats checks. Perhaps it should.
  return success;
}

void CssRewriteTestBase::GetNamerForCss(StringPiece leaf_name,
                                        StringPiece expected_css_output,
                                        ResourceNamer* namer) {
  namer->set_id(RewriteOptions::kCssFilterId);
  namer->set_hash(hasher()->Hash(expected_css_output));
  namer->set_ext("css");
  namer->set_name(leaf_name);
}

GoogleString CssRewriteTestBase::ExpectedUrlForNamer(
    const ResourceNamer& namer) {
  return Encode("", namer.id(), namer.hash(), namer.name(), namer.ext());
}

GoogleString CssRewriteTestBase::ExpectedUrlForCss(
    StringPiece id, StringPiece expected_css_output) {
  ResourceNamer namer;
  GetNamerForCss(StrCat(id, ".css"), expected_css_output, &namer);
  return ExpectedUrlForNamer(namer);
}

GoogleString CssRewriteTestBase::MakeHtmlWithExternalCssLink(
    StringPiece css_url, int flags, bool insert_debug_message) {
  GoogleString link_extras("");
  if (FlagSet(flags, kLinkCharsetIsUTF8)) {
    link_extras = " charset='utf-8'";
  }
  if (FlagSet(flags, kLinkScreenMedia) && FlagSet(flags, kLinkPrintMedia)) {
    StrAppend(&link_extras, " media='screen,print'");
  } else if (FlagSet(flags, kLinkScreenMedia)) {
    StrAppend(&link_extras, " media='screen'");
  } else if (FlagSet(flags, kLinkPrintMedia)) {
    StrAppend(&link_extras, " media='print'");
  }
  GoogleString meta_tag("");
  if (FlagSet(flags, kMetaCharsetUTF8)) {
    StrAppend(&meta_tag, "  <meta charset=\"utf-8\">");
  }
  if (FlagSet(flags, kMetaCharsetISO88591)) {
    StrAppend(&meta_tag, "  <meta charset=ISO-8859-1>");
  }
  if (FlagSet(flags, kMetaHttpEquiv)) {
    StrAppend(&meta_tag,
              "  <meta http-equiv=\"Content-Type\" "
              "content=\"text/html; charset=UTF-8\">");
  }
  if (FlagSet(flags, kMetaHttpEquivUnquoted)) {
    // Same as the previous one but content's value isn't quoted!
    StrAppend(&meta_tag,
              "  <meta http-equiv=\"Content-Type\" "
              "content=text/html; charset=ISO-8859-1>");
  }

  // This helper method is used to produce both input and expected_output HTML.
  // For input HTML we do not want to insert a debug message.
  // For expected_output HTML we do.
  GoogleString debug_message;
  if (insert_debug_message) {
    debug_message = DebugMessage(css_url);
  }

  return StringPrintf("<head>\n"
                      "  <title>Example style outline</title>\n"
                      "%s"
                      "  <!-- Style starts here -->\n"
                      "  <link rel='stylesheet' type='text/css' href='%.*s'%s>"
                      "%s\n"
                      "  <!-- Style ends here -->\n"
                      "</head>",
                      meta_tag.c_str(),
                      static_cast<int>(css_url.size()), css_url.data(),
                      link_extras.c_str(), debug_message.c_str());
}

GoogleString CssRewriteTestBase::MakeIndentedCssWithImage(
    StringPiece image_url) {
  return StrCat("body {\n"
                "  background-image: url(", image_url, ");\n"
                "}\n");
}

GoogleString CssRewriteTestBase::MakeMinifiedCssWithImage(
    StringPiece image_url) {
  return StrCat("body{background-image:url(", image_url, ")}");
}

GoogleString CssRewriteTestBase::ExtractCssBackgroundImage(
    StringPiece in_css) {
  const char css_template[] = "*{background-image:url(*)}*";
  GoogleString image_url;
  if (!Wildcard(css_template).Match(in_css)) {
    return image_url;
  }
  StringVector extracted_urls;
  CssUrlExtractor url_extractor;
  url_extractor.ExtractUrl(in_css, &extracted_urls);
  // Although the CssUrlExtractor returns a StringVector, we expect only one
  // url in the input string.
  if (extracted_urls.size() == 1) {
    image_url = extracted_urls[0];
  }

  return image_url;
}

// Check that external CSS gets rewritten correctly.
void CssRewriteTestBase::ValidateRewriteExternalCssUrl(
    StringPiece id, StringPiece css_url,
    StringPiece css_input, StringPiece expected_css_output, int flags) {
  CheckFlags(flags);

  // Set input file.
  if (!FlagSet(flags, kNoClearFetcher)) {
    ClearFetcherResponses();
  }
  SetResponseWithDefaultHeaders(css_url, kContentTypeCss, css_input, 300);
  GoogleString html_input = MakeHtmlWithExternalCssLink(css_url, flags, false);

  // Do we expect the URL to be rewritten?
  bool rewrite_url = (FlagSet(flags, kExpectSuccess) ||
                      FlagSet(flags, kExpectCached) ||
                      FlagSet(flags, kExpectFallback));

  GoogleString expected_new_url;
  if (rewrite_url) {
    ResourceNamer namer;
    GoogleUrl css_gurl(css_url);
    GetNamerForCss(css_gurl.LeafWithQuery(), expected_css_output, &namer);
    expected_new_url = Encode(css_gurl.AllExceptLeaf(), namer.id(),
                              namer.hash(), namer.name(), namer.ext());
  } else {
    css_url.CopyToString(&expected_new_url);
  }

  GoogleString expected_html_output =
      MakeHtmlWithExternalCssLink(expected_new_url, flags, true);
  ValidateWithStats(id, html_input, expected_html_output,
                    css_input, expected_css_output, flags);

  if (rewrite_url) {
    // Check the new output resource.
    GoogleString actual_output;
    // TODO(sligocki): This will only work with mock_hasher.
    ResponseHeaders headers_out;
    EXPECT_TRUE(FetchResourceUrl(expected_new_url, &actual_output,
                                 &headers_out)) << css_url;
    EXPECT_EQ(expected_css_output, actual_output) << css_url;

    // Non-fallback CSS should have very long caching headers
    if (!FlagSet(flags, kExpectFallback)) {
      EXPECT_TRUE(headers_out.IsProxyCacheable());
      EXPECT_LE(Timer::kYearMs, headers_out.cache_ttl_ms());
    }

    // Serve from new context.
    if (!FlagSet(flags, kNoOtherContexts)) {
      ServeResourceFromManyContexts(expected_new_url, expected_css_output);
    }
  }
}

// Helper to test for how we handle trailing junk
void CssRewriteTestBase::TestCorruptUrl(const char* new_suffix) {
  DebugWithMessage("");
  const char kInput[] = " div { } ";
  const char kOutput[] = "div{}";
  // Compute normal version
  ValidateRewriteExternalCss("rep", kInput, kOutput, kExpectSuccess);

  // Fetch with messed up extension
  GoogleString css_url = ExpectedUrlForCss("rep", kOutput);
  ASSERT_TRUE(StringCaseEndsWith(css_url, ".css"));
  GoogleString munged_url =
      ChangeSuffix(css_url, false /*replace*/, ".css", new_suffix);

  GoogleString output;
  EXPECT_TRUE(FetchResourceUrl(StrCat(kTestDomain, munged_url), &output));

  // Now see that output is correct
  ValidateRewriteExternalCss(
      "rep", kInput, kOutput,
      kExpectSuccess | kNoClearFetcher | kNoStatCheck);
}

}  // namespace net_instaweb