// 
// System.Web.HttpCachePolicy
//
// Authors:
//	Tim Coleman (tim@timcoleman.com)
//	Gonzalo Paniagua Javier (gonzalo@ximian.com)
//
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Security.Permissions;
using System.Text;
using System.Web.UI;
using System.Web.Util;

namespace System.Web
{
	// CAS - no InheritanceDemand here as the class is sealed
	[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
	public sealed class HttpCachePolicy
	{
		internal HttpCachePolicy ()
		{
		}

		HttpCacheVaryByContentEncodings vary_by_content_encodings = new HttpCacheVaryByContentEncodings ();
		HttpCacheVaryByHeaders vary_by_headers = new HttpCacheVaryByHeaders ();
		HttpCacheVaryByParams vary_by_params = new HttpCacheVaryByParams ();
		ArrayList validation_callbacks;
		StringBuilder cache_extension;
		internal HttpCacheability Cacheability;
		string etag;
		bool etag_from_file_dependencies;
		bool last_modified_from_file_dependencies;

		//
		// Used externally
		//
		internal bool have_expire_date;
		internal DateTime expire_date;
		internal bool have_last_modified;
		internal DateTime last_modified;

		//bool LastModifiedFromFileDependencies;
		HttpCacheRevalidation revalidation;
		string vary_by_custom;
		bool HaveMaxAge;
		TimeSpan MaxAge;
		bool HaveProxyMaxAge;
		TimeSpan ProxyMaxAge;
		ArrayList fields;
		bool sliding_expiration;
		int duration;
		bool allow_response_in_browser_history;
		bool allow_server_caching = true;
		bool set_no_store;
		bool set_no_transform;
		bool valid_until_expires;
		bool omit_vary_star;
		
		public HttpCacheVaryByContentEncodings VaryByContentEncodings {
			get { return vary_by_content_encodings; }
		}

		public HttpCacheVaryByHeaders VaryByHeaders {
			get { return vary_by_headers; }
		}

		public HttpCacheVaryByParams VaryByParams {
			get { return vary_by_params; }
		}

		internal bool AllowServerCaching {
			get { return allow_server_caching; }
		}

		internal int Duration {
			get { return duration; }
			set { duration = value; }
		}

		internal bool Sliding {
			get { return sliding_expiration; }
		}

		internal DateTime Expires {
			get { return expire_date; }
		}

		internal ArrayList ValidationCallbacks {
			get { return validation_callbacks; }
		}

		internal bool OmitVaryStar {
			get { return omit_vary_star; }
		}

		internal bool ValidUntilExpires {
			get { return valid_until_expires; }
		}

		internal int ExpireMinutes ()
		{
			if (!have_expire_date)
				return 0;

			return (expire_date - DateTime.Now).Minutes;
		}

		public void AddValidationCallback (HttpCacheValidateHandler handler, object data)
		{
			if (handler == null)
				throw new ArgumentNullException ("handler");

			if (validation_callbacks == null)
				validation_callbacks = new ArrayList ();

			validation_callbacks.Add (new Pair (handler, data));
		}

		public void AppendCacheExtension (string extension)
		{
			if (extension == null)
				throw new ArgumentNullException ("extension");

			if (cache_extension == null)
				cache_extension = new StringBuilder (extension);
			else
				cache_extension.Append (", " + extension);
		}

		//
		// This one now allows the full range of Cacheabilities.
		//
		public void SetCacheability (HttpCacheability cacheability)
		{
			if (cacheability < HttpCacheability.NoCache || cacheability > HttpCacheability.ServerAndPrivate)
				throw new ArgumentOutOfRangeException ("cacheability");

			if (Cacheability > 0 && cacheability > Cacheability)
				return;

			Cacheability = cacheability;
		}

		public void SetCacheability (HttpCacheability cacheability, string field)
		{
			if (field == null)
				throw new ArgumentNullException ("field");

			if (cacheability != HttpCacheability.NoCache && cacheability != HttpCacheability.Private)
				throw new ArgumentException ("Must be NoCache or Private", "cacheability");

			if (fields == null)
				fields = new ArrayList ();

			fields.Add (new Pair (cacheability, field));
		}

		public void SetETag (string etag)
		{
			if (etag == null)
				throw new ArgumentNullException ("etag");

			if (this.etag != null)
				throw new InvalidOperationException ("The ETag header has already been set");

			if (etag_from_file_dependencies)
				throw new InvalidOperationException ("SetEtagFromFileDependencies has already been called");

			this.etag = etag;
		}

		public void SetETagFromFileDependencies ()
		{
			if (this.etag != null)
				throw new InvalidOperationException ("The ETag header has already been set");

			etag_from_file_dependencies = true;
		}

		public void SetExpires (DateTime date)
		{
			if (have_expire_date && date > expire_date)
				return;

			have_expire_date = true;
			expire_date = date;
		}

		public void SetLastModified (DateTime date)
		{
			if (date > DateTime.Now)
				throw new ArgumentOutOfRangeException ("date");

			if (have_last_modified && date < last_modified)
				return;

			have_last_modified = true;
			last_modified = date;
		}

		public void SetLastModifiedFromFileDependencies ()
		{
			last_modified_from_file_dependencies = true;
		}

		public void SetMaxAge (TimeSpan date)
		{
			if (date < TimeSpan.Zero)
				throw new ArgumentOutOfRangeException ("date");

			if (HaveMaxAge && MaxAge < date)
				return;

			MaxAge = date;
			HaveMaxAge = true;
		}

		public void SetNoServerCaching ()
		{
			allow_server_caching = false;
		}

		public void SetNoStore ()
		{
			set_no_store = true;
		}

		public void SetNoTransforms ()
		{
			set_no_transform = true;
		}

		public void SetProxyMaxAge (TimeSpan delta)
		{
			if (delta < TimeSpan.Zero)
				throw new ArgumentOutOfRangeException ("delta");

			if (HaveProxyMaxAge && ProxyMaxAge < delta)
				return;

			ProxyMaxAge = delta;
			HaveProxyMaxAge = true;
		}

		public void SetRevalidation (HttpCacheRevalidation revalidation)
		{
			if (revalidation < HttpCacheRevalidation.AllCaches ||
			    revalidation > HttpCacheRevalidation.None)
				throw new ArgumentOutOfRangeException ("revalidation");

			if (this.revalidation > revalidation)
				this.revalidation = revalidation;
		}

		public void SetSlidingExpiration (bool slide)
		{
			sliding_expiration = slide;
		}

		public void SetValidUntilExpires (bool validUntilExpires)
		{
			valid_until_expires = validUntilExpires;
		}

		public void SetVaryByCustom (string custom)
		{
			if (custom == null)
				throw new ArgumentNullException ("custom");

			if (vary_by_custom != null)
				throw new InvalidOperationException ("VaryByCustom has already been set.");

			vary_by_custom = custom;
		}

		internal string GetVaryByCustom ()
		{
			return vary_by_custom;
		}

		public void SetAllowResponseInBrowserHistory (bool allow)
		{
			if (Cacheability == HttpCacheability.NoCache || Cacheability == HttpCacheability.ServerAndNoCache) 
				allow_response_in_browser_history = allow;
		}

		internal void SetHeaders (HttpResponse response, NameValueCollection headers)
		{
			bool noCache = false;
			string cc = null;

			switch (Cacheability) {
			case HttpCacheability.Public:
				cc = "public";
				break;

			case HttpCacheability.NoCache:
			case HttpCacheability.ServerAndNoCache:
				noCache = true;
				cc = "no-cache";
				break;

			case HttpCacheability.Private:
			case HttpCacheability.ServerAndPrivate:
			default:
				cc = "private";
				break;
			}

			if (noCache) {
				response.CacheControl = cc;
				if (!allow_response_in_browser_history) {
					headers.Add ("Expires", "-1");
					headers.Add ("Pragma", "no-cache");
				}
			} else {
				if (HaveMaxAge)
					cc = String.Concat (cc, ", max-age=", ((long) MaxAge.TotalSeconds).ToString ());

				if (have_expire_date) {
					string expires = TimeUtil.ToUtcTimeString (expire_date);
					headers.Add ("Expires", expires);
				}
			}

			if (set_no_store)
				cc = String.Concat (cc, ", no-store");
			if (set_no_transform)
				cc = String.Concat (cc, ", no-transform");

			headers.Add ("Cache-Control", cc);

			if (last_modified_from_file_dependencies || etag_from_file_dependencies)
				HeadersFromFileDependencies (response);

			if (etag != null)
				headers.Add ("ETag", etag);

			if (have_last_modified)
				headers.Add ("Last-Modified", TimeUtil.ToUtcTimeString (last_modified));

			if (!vary_by_params.IgnoreParams) {
				string vb = vary_by_params.GetResponseHeaderValue ();
				if (vb != null)
					headers.Add ("Vary", vb);
			}
		}

		void HeadersFromFileDependencies (HttpResponse response)
		{
			string [] fileDeps = response.FileDependencies;

			if (fileDeps == null || fileDeps.Length == 0)
				return;

			bool doEtag = etag != null && etag_from_file_dependencies;
			if (!doEtag && !last_modified_from_file_dependencies)
				return;

			DateTime latest_mod = DateTime.MinValue, mod;
			StringBuilder etagsb = new StringBuilder ();
			
			foreach (string f in fileDeps) {
				if (!File.Exists (f))
					continue;
				try {
					mod = File.GetLastWriteTime (f);
				} catch {
					// ignore
					continue;
				}

				if (last_modified_from_file_dependencies && mod > latest_mod)
					latest_mod = mod;
				if (doEtag)
					etagsb.AppendFormat ("{0}", mod.Ticks.ToString ("x"));
			}

			if (last_modified_from_file_dependencies && latest_mod > DateTime.MinValue) {
				last_modified = latest_mod;
				have_last_modified = true;
			}

			if (doEtag && etagsb.Length > 0)
				etag = etagsb.ToString ();
		}

		public void SetOmitVaryStar (bool omit)
		{
			omit_vary_star = omit;
		}
	}
}