// 
// CodeProviderImpl.cs
// 
// Authors:
// 	Alexander Chebaturkin (chebaturkin@gmail.com)
// 
// Copyright (C) 2011 Alexander Chebaturkin
// 
// 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;
using System.Collections.Generic;
using System.Linq;
using Mono.CodeContracts.Static.AST;
using Mono.CodeContracts.Static.AST.Visitors;
using Mono.CodeContracts.Static.ControlFlow;
using Mono.CodeContracts.Static.DataStructures;

namespace Mono.CodeContracts.Static.Providers {
	class CodeProviderImpl : IMethodCodeProvider<CodeProviderImpl.PC, ExceptionHandler> {
		public static readonly CodeProviderImpl Instance = new CodeProviderImpl ();

		#region IMethodCodeProvider<PC,ExceptionHandler> Members
		public Result Decode<Visitor, Data, Result> (PC pc, Visitor visitor, Data data)
			where Visitor : IAggregateVisitor<PC, Data, Result>
		{
			Node nested;
			Node node = Decode (pc, out nested);
			if (IsAtomicNested (nested))
				node = nested;
			else if (nested != null)
				return visitor.Aggregate (pc, new PC (nested), nested is Block, data);

			if (node == null)
				return visitor.Nop (pc, data);

			switch (node.NodeType) {
			case NodeType.Block:
			case NodeType.Nop:
				return visitor.Nop (pc, data);
			case NodeType.Clt:
			case NodeType.Lt:
				return visitor.Binary (pc, BinaryOperator.Clt, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Cgt:
			case NodeType.Gt:
				return visitor.Binary (pc, BinaryOperator.Cgt, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Ceq:
			case NodeType.Eq:
				return visitor.Binary (pc, BinaryOperator.Ceq, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Ne:
				return visitor.Binary (pc, BinaryOperator.Cne_Un, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Ge:
				return visitor.Binary (pc, BinaryOperator.Cge, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Le:
				return visitor.Binary (pc, BinaryOperator.Cle, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Add:
				return visitor.Binary (pc, BinaryOperator.Add, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Sub:
				return visitor.Binary (pc, BinaryOperator.Sub, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Rem:
				return visitor.Binary (pc, BinaryOperator.Rem, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Rem_Un:
				return visitor.Binary (pc, BinaryOperator.Rem_Un, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Mul:
				return visitor.Binary (pc, BinaryOperator.Mul, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Div:
				return visitor.Binary (pc, BinaryOperator.Div, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Div_Un:
				return visitor.Binary (pc, BinaryOperator.Div_Un, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.And:
				return visitor.Binary (pc, BinaryOperator.And, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Or:
				return visitor.Binary (pc, BinaryOperator.Or, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Shr:
				return visitor.Binary (pc, BinaryOperator.Shr, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Xor:
				return visitor.Binary (pc, BinaryOperator.Xor, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Shl:
				return visitor.Binary (pc, BinaryOperator.Shl, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Shr_Un:
				return visitor.Binary (pc, BinaryOperator.Shr_Un, Dummy.Value, Dummy.Value, Dummy.Value, data);
			case NodeType.Literal:
				var literal = (Literal) node;
				if (literal.Value == null)
					return visitor.LoadNull (pc, Dummy.Value, data);
				if (literal.Type == CoreSystemTypes.Instance.TypeBoolean && (bool) literal.Value)
					return visitor.LoadConst (pc, CoreSystemTypes.Instance.TypeInt32, 1, Dummy.Value, data);

				return visitor.LoadConst (pc, literal.Type, literal.Value, Dummy.Value, data);
			case NodeType.This:
			case NodeType.Parameter:
				return visitor.LoadArg (pc, (Parameter) node, false, Dummy.Value, data);
			case NodeType.Local:
				return visitor.LoadLocal (pc, (Local) node, Dummy.Value, data);
			case NodeType.Branch:
				var branch = (Branch) node;
				if (branch.Condition != null)
					return visitor.BranchTrue (pc, new PC (branch.Target), Dummy.Value, data);
				return visitor.Branch (pc, new PC (branch.Target), branch.LeavesExceptionBlock, data);
			case NodeType.ExpressionStatement:
				break;
			case NodeType.Box:
				break;
			case NodeType.Return:
				return visitor.Return (pc, Dummy.Value, data);
			case NodeType.Neg:
				return visitor.Unary (pc, UnaryOperator.Neg, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Not:
			case NodeType.LogicalNot:
				return visitor.Unary (pc, UnaryOperator.Not, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv:
				break;
			case NodeType.Conv_I1:
				return visitor.Unary (pc, UnaryOperator.Conv_i1, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv_I2:
				return visitor.Unary (pc, UnaryOperator.Conv_i2, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv_I4:
				return visitor.Unary (pc, UnaryOperator.Conv_i4, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv_I8:
				return visitor.Unary (pc, UnaryOperator.Conv_i8, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv_R4:
				return visitor.Unary (pc, UnaryOperator.Conv_r4, false, Dummy.Value, Dummy.Value, data);
			case NodeType.Conv_R8:
				return visitor.Unary (pc, UnaryOperator.Conv_r8, false, Dummy.Value, Dummy.Value, data);
			case NodeType.MethodContract:
				return visitor.Nop (pc, data);
			case NodeType.Requires:
				return visitor.Assume (pc, EdgeTag.Requires, Dummy.Value, data);
			case NodeType.Call:
				var call = (MethodCall) node;
				Method method = GetMethodFrom (call.Callee);
				if (method.HasGenericParameters)
					throw new NotImplementedException ();
				if (method.Name != null && method.DeclaringType.Name != null && method.DeclaringType.Name.EndsWith ("Contract")) {
					switch (method.Name) {
					case "Assume":
						if (method.Parameters.Count == 1)
							return visitor.Assume (pc, EdgeTag.Assume, Dummy.Value, data);
						break;
					case "Assert":
						if (method.Parameters.Count == 1)
							return visitor.Assert (pc, EdgeTag.Assert, Dummy.Value, data);
						break;
					}
				}
				Indexable<Dummy> parameters = DummyIndexable (method);
				return visitor.Call (pc, method, false, GetVarargs (call, method), Dummy.Value, parameters, data);

			case NodeType.AssignmentStatement:
				var assign = ((AssignmentStatement) node);
				var local = assign.Target as Local;
				if (local != null)
					return visitor.StoreLocal (pc, local, Dummy.Value, data);
				var parameter = assign.Target as Parameter;
				if (parameter != null)
					return visitor.StoreArg (pc, parameter, Dummy.Value, data);

				var binding = assign.Target as MemberBinding;
				if (binding != null) {
					if (binding.BoundMember.IsStatic)
						return visitor.StoreStaticField (pc, (Field) binding.BoundMember, Dummy.Value, data);
					else
						return visitor.StoreField (pc, (Field) binding.BoundMember, Dummy.Value, Dummy.Value, data);
				}

				throw new NotImplementedException ();
			case NodeType.Construct:
				Method ctor = GetMethodFrom (((Construct) node).Constructor);
				if (!(ctor.DeclaringType is ArrayTypeNode))
					return visitor.NewObj (pc, ctor, Dummy.Value, DummyIndexable (ctor), data);
				var arrayType = (ArrayTypeNode) ctor.DeclaringType;
				return visitor.NewArray (pc, arrayType, Dummy.Value, DummyIndexable (ctor), data);
			default:
				return visitor.Nop (pc, data);
			}

			throw new NotImplementedException ();
		}

		public bool Next (PC pc, out PC nextLabel)
		{
			Node nested;
			if (Decode (pc, out nested) == null && pc.Node != null) {
				nextLabel = new PC (pc.Node, pc.Index + 1);
				return true;
			}
			nextLabel = new PC ();
			return false;
		}

		public int GetILOffset (PC current)
		{
			throw new NotImplementedException ();
		}
		#endregion

		private static Indexable<Dummy> DummyIndexable (Method method)
		{
			return new Indexable<Dummy> (Enumerable.Range (0, method.Parameters.Count).Select (it => Dummy.Value).ToList ());
		}

		private static Indexable<TypeNode> GetVarargs (MethodCall call, Method method)
		{
			int methodCount = method.Parameters.Count;
			int callCount = call.Arguments.Count;

			if (callCount <= methodCount)
				return new Indexable<TypeNode> (null);

			var array = new TypeNode[callCount - methodCount];
			for (int i = methodCount; i < callCount; i++)
				array [i - methodCount] = call.Arguments [i - methodCount].Type;

			return new Indexable<TypeNode> (array);
		}

		private Method GetMethodFrom (Expression callee)
		{
			return (Method) ((MemberBinding) callee).BoundMember;
		}

		private static bool IsAtomicNested (Node nested)
		{
			if (nested == null)
				return false;
			switch (nested.NodeType) {
			case NodeType.Local:
			case NodeType.Parameter:
			case NodeType.Literal:
			case NodeType.This:
				return true;
			default:
				return false;
			}
		}

		private Node Decode (PC pc, out Node nested)
		{
			Node node = DecodeInflate (pc, out nested);

			return node;
		}

		/// <summary>
		/// Decodes pc
		/// </summary>
		/// <param name="pc"></param>
		/// <param name="nested"></param>
		/// <returns>If node has nested, returns null and (nested = child). If last child given, node equals pc.Node</returns>
		private static Node DecodeInflate (PC pc, out Node nested)
		{
			Node node = pc.Node;
			if (node == null) {
				nested = null;
				return null;
			}

			int index = pc.Index;
			switch (node.NodeType) {
			case NodeType.MethodContract:
				var methodContract = (MethodContract) node;
				if (index < methodContract.RequiresCount) {
					nested = methodContract.Requires [index];
					return null;
				}
				if (index == methodContract.RequiresCount) {
					nested = null;
					return methodContract;
				}

				//todo: aggregate ensures
				nested = null;
				return methodContract;

			case NodeType.Requires:
				var requires = (Requires) node;
				if (index == 0) {
					nested = requires.Assertion;
					return null;
				}
				nested = null;
				return requires;
			case NodeType.Block:
				var block = (Block) node;
				if (block.Statements == null) {
					nested = null;
					return block;
				}
				nested = index >= block.Statements.Count ? null : block.Statements [index];
				return index + 1 < block.Statements.Count ? null : block;
			case NodeType.Return:
				var ret = (Return) node;
				if (ret.Expression != null && index == 0) {
					nested = ret.Expression;
					return null;
				}
				nested = null;
				return ret;
			case NodeType.AssignmentStatement:
				var assign = (AssignmentStatement) node;
				int innerIndex = index;
				{
					var bind = assign.Target as MemberBinding;
					if (bind != null) {
						++innerIndex;
						if (bind.BoundMember.IsStatic)
							++innerIndex;
						if (innerIndex == 1) {
							nested = bind.TargetObject;
							return null;
						}
					} else if (assign.Target is Variable)
						innerIndex += 2;
					else {
						nested = null;
						return assign;
					}
				}
				if (innerIndex == 2) {
					nested = assign.Source;
					return null;
				}

				nested = null;
				return assign;
			case NodeType.ExpressionStatement:
				var expressionStatement = (ExpressionStatement) node;
				nested = expressionStatement.Expression;
				return expressionStatement;
			case NodeType.MethodCall:
			case NodeType.Call:
			case NodeType.Calli:
			case NodeType.CallVirt:
				var methodCall = (MethodCall) node;
				var binding = (MemberBinding) methodCall.Callee;
				if (binding.BoundMember.IsStatic) {
					if (index < methodCall.Arguments.Count) {
						nested = methodCall.Arguments [index];
						return null;
					}

					nested = null;
					return methodCall;
				}

				if (index == 0) {
					nested = binding.TargetObject;
					return null;
				}
				if (index < methodCall.Arguments.Count + 1) {
					nested = methodCall.Arguments [index - 1];
					return null;
				}
				nested = null;
				return methodCall;
			case NodeType.MemberBinding:
				var bind1 = ((MemberBinding) node);
				if (index == 0 && !bind1.BoundMember.IsStatic) {
					nested = bind1.TargetObject;
					return null;
				}
				nested = null;
				return bind1;
			case NodeType.Construct:
				var construct = (Construct) node;
				if (index < construct.Arguments.Count) {
					nested = construct.Arguments [index];
					return null;
				}
				nested = null;
				return construct;
			case NodeType.Branch:
				var branch = ((Branch) node);
				if (branch.Condition != null && index == 0) {
					nested = branch.Condition;
					return null;
				}
				nested = null;
				return branch;
			default:
				var binary = node as BinaryExpression;
				if (binary != null) {
					if (index == 0) {
						nested = binary.Left;
						return null;
					}
					if (index == 1) {
						nested = binary.Right;
						return null;
					}
					nested = null;
					return binary;
				}

				var unary = node as UnaryExpression;
				if (unary != null) {
					if (index == 0) {
						nested = unary.Operand;
						return null;
					}

					nested = null;
					return unary;
				}

				//todo: ternary
				nested = null;
				return node;
			}
		}

		public PC Entry (Method method)
		{
			return new PC (method.Body);
		}

		#region Implementation of IMethodCodeProvider<PC,Local,Parameter,Method,FieldReference,TypeReference,Dummy>
		public bool IsFaultHandler (ExceptionHandler handler)
		{
			return handler.HandlerType == NodeType.FaultHandler;
		}

		public bool IsFilterHandler (ExceptionHandler handler)
		{
			return handler.HandlerType == NodeType.Filter;
		}

		public bool IsFinallyHandler (ExceptionHandler handler)
		{
			return handler.HandlerType == NodeType.Finally;
		}

		public PC FilterExpressionStart (ExceptionHandler handler)
		{
			return new PC (handler.FilterExpression);
		}

		public PC HandlerEnd (ExceptionHandler handler)
		{
			throw new NotImplementedException ();
		}

		public PC HandlerStart (ExceptionHandler handler)
		{
			throw new NotImplementedException ();
		}

		public PC TryStart (ExceptionHandler handler)
		{
			throw new NotImplementedException ();
		}

		public PC TryEnd (ExceptionHandler handler)
		{
			throw new NotImplementedException ();
		}

		public bool IsCatchHandler (ExceptionHandler handler)
		{
			return handler.HandlerType == NodeType.Catch;
		}

		public TypeNode CatchType (ExceptionHandler handler)
		{
			return handler.FilterType;
		}

		public bool IsCatchAllHandler (ExceptionHandler handler)
		{
			if (!IsCatchHandler (handler))
				return false;
			if (handler.FilterType != null)
				return false;

			return true;
		}

		public IEnumerable<ExceptionHandler> GetTryBlocks (Method method)
		{
			yield break;
		}
		#endregion

		#region Nested type: PC
		public struct PC : IEquatable<PC> {
			public readonly int Index;
			public readonly Node Node;

			public PC (Node Node)
				: this (Node, 0)
			{
			}

			public PC (Node node, int index)
			{
				this.Node = node;
				this.Index = index;
			}

			#region IEquatable<PC> Members
			public bool Equals (PC other)
			{
				return Equals (other.Node, this.Node) && other.Index == this.Index;
			}
			#endregion

			public override bool Equals (object obj)
			{
				if (ReferenceEquals (null, obj))
					return false;
				if (obj.GetType () != typeof (PC))
					return false;
				return Equals ((PC) obj);
			}

			public override int GetHashCode ()
			{
				unchecked {
					return ((this.Node != null ? this.Node.GetHashCode () : 0)*397) ^ this.Index;
				}
			}
		}
		#endregion
	}
}