// Copyright 2011 Google Inc. All Rights Reserved.
//
// 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: bmcquade@google.com (Bryan McQuade)
//         sligocki@google.com (Shawn Ligocki)
//         jmarantz@google.com (Joshua Marantz)

#ifndef PAGESPEED_KERNEL_HTTP_CACHING_HEADERS_H_
#define PAGESPEED_KERNEL_HTTP_CACHING_HEADERS_H_

#include "base/logging.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {
// TODO(jmarantz): This class is temporarily in net_instaweb so that
// it can conveniently reference GoogleString etc.  We will move
// all the files in pagespeed/... to be in namespace pagespeed in a
// future change.

// Class to embody computing caching info for Resources.
// This class has two advantages over static functions in resource_util:
//  1) It allows computation to be run once, lazily and saved rather than
//     multiple times and thrown away.
//  2) It supplies virtual methods for details of caching policy so that users
//     (including Page Speed Automatic) can tweak parts of the policy by
//     subclassing and overriding these methods.
class CachingHeaders {
 public:
  // All StringPieces must outlive the CachingHeaders class.
  explicit CachingHeaders(int status_code);
  virtual ~CachingHeaders();

  // Implementors supply this method to provide HTTP response header values.
  virtual bool Lookup(const StringPiece& key, StringPieceVector* values) = 0;

  // To obtain correct heuristics on URLs with query-parameters, supply the URL.
  void set_url(StringPiece x) { url_ = x; }

  // Is the resource privately cacheable, either by explicit caching
  // headers or using common caching heuristics? If you want to know
  // if the resource is explicitly marked as cacheable, use
  // GetFreshnessLifetimeMillis() and test to see that the output
  // parameter it positive.
  // TODO(sligocki): Rename to IsBrowserCacheable().
  bool IsCacheable();

  // Is the resource likely to be cached by proxies?
  bool IsProxyCacheable();

  // Is this resource explicitly marked cacheable?
  bool IsExplicitlyCacheable();

  // Get the freshness lifetime of hte given resource, using the
  // algorithm described in the HTTP/1.1 RFC. Returns true if the
  // resource has an explicit freshness lifetime, false otherwise.
  // The out parameter is only valid when this function returns true.
  bool GetFreshnessLifetimeMillis(int64* out_freshness_lifetime_millis);

  // Does the resource have an explicit freshness lifetime? This is just
  // a wrapper around GetFreshnessLifetimeMillis().
  bool HasExplicitFreshnessLifetime();

  // Does the resource have an explicit HTTP header directive that
  // indicates it's not cacheable? For instance, Cache-Control: no-cache or
  // Pragma: no-cache.
  bool HasExplicitNoCacheDirective();

  // Determines whether the caching headers have a must-revalidate directive.
  bool MustRevalidate();

  // Determines whether the caching headers have a proxy-revalidate directive.
  bool ProxyRevalidate();

  // Tweakable methods
  //
  // These methods are virtual so that derived calsses can change the policy
  // decisions regarding what constitutes a static resource type and/or what
  // constitutes a cacheable resource status code.

  // Is the given resource type usually associated wiht static resources?
  virtual bool IsLikelyStaticResourceType() const = 0;

  // Is the given status code known to be associated with
  // static/cacheable resources?
  virtual bool IsCacheableResourceStatusCode() const = 0;

  bool IsRedirectStatusCode() const;

  int status_code() const { return status_code_; }

  // Generates a cache-control string for disabling caching, that is strictly
  // more conservative than the existing cache-control string.
  GoogleString GenerateDisabledCacheControl();

 private:
  void ParseCacheControlIfNecessary();

  // Uses heuristics to test cacheability. Can only be called if no explicit
  // cache headers have been set for resource!
  bool IsHeuristicallyCacheable();

  // Compute values w/o memory. Helper functions to the ones above which lazily
  // compute the result and memoize the result.
  bool ComputeIsCacheable();
  bool ComputeIsProxyCacheable();
  bool ComputeIsHeuristicallyCacheable();
  bool ComputeFreshnessLifetimeMillis(int64* out_freshness_lifetime_millis);
  bool ComputeHasExplicitNoCacheDirective();

  // A variable with added bool for whether or not it's been set.
  template<class T> class Optional {
   public:
    Optional() : has_value_(false) {}
    ~Optional() {}

    bool has_value() const { return has_value_; }

    T value() const {
      // Not meaningful unless has_value() == true.
      DCHECK(has_value());
      return value_;
    }

    void set_value(T value) {
      value_ = value;
      has_value_ = true;
    }

   private:
    T value_;
    bool has_value_;

    DISALLOW_COPY_AND_ASSIGN(Optional);
  };

  int status_code_;
  StringPiece url_;
  bool parsed_cache_control_;

  // Cache-control settings, read directly from the HTTP header.  The bools
  // all default to false & can be set true.  The max_age is left in !was_set
  // state until successfully parsed.
  bool public_;
  bool private_;
  bool no_transform_;
  bool must_revalidate_;
  bool proxy_revalidate_;
  bool no_cache_;
  bool no_store_;
  bool cache_control_parse_error_;
  bool expires_invalid_;
  Optional<int> max_age_seconds_;
  Optional<int64> expires_ms_;

  // Computed caching properties, taking into account response-code, type,
  // vary-headers, pragma, etc.
  Optional<int64> freshness_lifetime_millis_;
  Optional<bool> is_cacheable_;
  Optional<bool> is_proxy_cacheable_;
  Optional<bool> is_explicitly_cacheable_;
  Optional<bool> is_heuristically_cacheable_;
  Optional<bool> has_explicit_no_cache_directive_;

  DISALLOW_COPY_AND_ASSIGN(CachingHeaders);
};

}  // namespace net_instaweb

#endif  // PAGESPEED_KERNEL_HTTP_CACHING_HEADERS_H_