using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using Raven.Abstractions.Indexing;

using Raven.Abstractions.Linq;

using Raven.Database.Indexing;

using Raven.Json.Linq;



namespace Raven.Database.Linq

{

	public abstract class AbstractTransformer

	{

		private TransformerDefinition transformerDefinition;

		private byte[] cachedBytes;

		public IndexingFunc TransformResultsDefinition { get; set; }

		public string SourceCode { get; set; }



    public string Name { get { return transformerDefinition.Name; } }

		public string ViewText { get; set; }



		// ReSharper disable once InconsistentNaming

		protected DynamicNullObject __dynamic_null = new DynamicNullObject();





		public IEnumerable<dynamic> TransfromWith(IEnumerable<string> transformers, dynamic maybeItems)

		{

			return Enumerable.Aggregate(transformers, maybeItems, 

				(Func<dynamic, string, dynamic>)((items, transformer) => TransfromWith(transformer, items)));

		}



		public IEnumerable<dynamic> TransfromWith(string transformer, dynamic maybeItems)

		{

			if (CurrentTransformationScope.Current == null)

				throw new InvalidOperationException("TransfromWith was accessed without CurrentTransformationScope.Current being set");



			var storedTransformer = CurrentTransformationScope.Current.Database.IndexDefinitionStorage.GetTransformer(transformer);

			if (storedTransformer == null)

				throw new InvalidOperationException("No transformer with the name: " + transformer);



			var enumerable = maybeItems as IEnumerable;

			if ( enumerable != null && AnonymousObjectToLuceneDocumentConverter.ShouldTreatAsEnumerable(enumerable))

				return AllowAccessToResultsEvenIfTheyAreStupidInternalAnonymousTypes(storedTransformer.TransformResultsDefinition(enumerable.Cast<dynamic>()));



			return AllowAccessToResultsEvenIfTheyAreStupidInternalAnonymousTypes(storedTransformer.TransformResultsDefinition(new[] { maybeItems }));

		}



		// need to work around this: http://www.heartysoft.com/ashic/blog/2010/5/anonymous-types-c-sharp-4-dynamic

		private IEnumerable<object> AllowAccessToResultsEvenIfTheyAreStupidInternalAnonymousTypes(IEnumerable<object> items)

		{

			foreach (var item in items)

			{

				if (item == null)

					yield return new DynamicNullObject();

				if (item is ValueType ||

					item is string || 

					item is RavenJToken || 

					item is DynamicJsonObject || 

					item is DynamicNullObject ||

					item is IDictionary )

					yield return item;

				// assume that this is anonymous type, hence all internals, hence can't be access by the calling transformer

				var json = RavenJObject.FromObject(item);

				yield return new DynamicJsonObject(json);

			}

		}



		// Required for RavenDB-1519

		protected dynamic LoadDocument<TIgnored>(object key)

		{

			return LoadDocument(key);

		}



		protected dynamic LoadDocument(object key)

		{

			if (CurrentTransformationScope.Current == null)

				throw new InvalidOperationException("LoadDocument was called without CurrentTransformationScope.Current being set: " + key);



			return CurrentTransformationScope.Current.Retriever.Load(key);

		}



		[Obsolete("Use Parameter instead.")]

	    protected RavenJToken Query(string key)

	    {

			return Parameter(key);

		}



		[Obsolete("Use ParameterOrDefault instead.")]

		protected RavenJToken QueryOrDefault(string key, object val)

		{

			return ParameterOrDefault(key, val);

		}



	    protected RavenJToken Parameter(string key)

	    {

            if (CurrentTransformationScope.Current == null)

                throw new InvalidOperationException("Query was accessed without CurrentTransformationScope.Current being set");



	        RavenJToken value;

	        if(CurrentTransformationScope.Current.Retriever.TransformerParameters.TryGetValue(key, out value) == false)

                throw new InvalidOperationException("Query parameter "+key+ " was accessed, but it wasn't provided for this query.");

	        return value;



	    }



        protected RavenJToken ParameterOrDefault(string key, object val)

        {

            if (CurrentTransformationScope.Current == null)

                throw new InvalidOperationException("Query was accessed without CurrentTransformationScope.Current being set");



            RavenJToken value;

            if (CurrentTransformationScope.Current.Retriever.TransformerParameters.TryGetValue(key, out value) == false)

                return RavenJToken.FromObject(val);

            return value;



        }



	    public object Include(object key)

		{

			if (CurrentTransformationScope.Current == null)

				throw new InvalidOperationException("Include was called without CurrentTransformationScope.Current being set: " + key);



			return CurrentTransformationScope.Current.Retriever.Include(key);

	

		}



		protected IEnumerable<dynamic> Recurse(object item, Func<dynamic, dynamic> func)

		{

			return new RecursiveFunction(item, func).Execute();

		}



		public void Init(TransformerDefinition def)

		{

			transformerDefinition = def;

		}



		public byte[] GetHashCodeBytes()

		{

			if (cachedBytes != null)

				return cachedBytes;

			return cachedBytes = BitConverter.GetBytes(GetHashCode());

		}



		protected bool Equals(AbstractTransformer other)

		{

			return Equals(transformerDefinition, other.transformerDefinition);

		}



		public override bool Equals(object obj)

		{

			if (ReferenceEquals(null, obj)) return false;

			if (ReferenceEquals(this, obj)) return true;

			if (obj.GetType() != this.GetType()) return false;

			return Equals((AbstractTransformer)obj);

		}



		public override int GetHashCode()

		{

			return (transformerDefinition != null ? transformerDefinition.GetHashCode() : 0);

		}

	}

}