module d.semantic.caster;

import d.semantic.semantic;
import d.semantic.typepromotion;

import d.ir.expression;
import d.ir.symbol;
import d.ir.type;

import source.location;

import source.exception;

Expression buildImplicitCast(
	SemanticPass pass,
	Location location,
	Type to,
	Expression e,
) {
	return buildCast!false(pass, location, to, e);
}

Expression buildExplicitCast(
	SemanticPass pass,
	Location location,
	Type to,
	Expression e,
) {
	return buildCast!true(pass, location, to, e);
}

CastKind implicitCastFrom(SemanticPass pass, Type from, Type to) {
	return ImplicitCaster(pass, to).castFrom(from);
}

CastKind explicitCastFrom(SemanticPass pass, Type from, Type to) {
	return ExplicitCaster(pass, to).castFrom(from);
}

private:

// Conflict with Interface in object.di
alias Interface = d.ir.symbol.Interface;

Expression buildCast(bool isExplicit)(
	SemanticPass pass,
	Location location,
	Type to,
	Expression e,
) in {
	assert(e, "Expression must not be null");
} do {
	// If the expression is polysemous, we try the several meaning and
	// exclude the ones that make no sense.
	if (auto asPolysemous = cast(PolysemousExpression) e) {
		Expression casted;
		foreach(candidate; asPolysemous.expressions) {
			candidate = buildCast!isExplicit(pass, location, to, candidate);
			
			import d.ir.error;
			if (cast(ErrorExpression) candidate) {
				continue;
			}
			
			if (casted) {
				return new CompileError(location, "Ambiguous").expression;
			}
			
			casted = candidate;
		}
		
		if (casted) {
			return casted;
		}
		
		import d.ir.error;
		return new CompileError(location, "No match found").expression;
	}
	
	// When casting an array literal, we try to push down the
	// cast to each element of the literal.
	if (auto al = cast(ArrayLiteral) e) {
		switch (to.kind) with(TypeKind) {
			case Array:
				if (al.values.length != to.size) {
					import d.ir.error;
					return new CompileError(
						al.location,
						"Incorrect element count",
					).expression;
				}
				
				goto case;
				
			case Slice:
				import std.algorithm, std.array;
				auto et = to.element;
				auto values = al.values
					.map!(v => buildCast!isExplicit(pass, location, et, v))
					.array();
				return build!ArrayLiteral(e.location, to, values);
			
			default:
				break;
		}
	}
	
	auto kind = Caster!(isExplicit, delegate CastKind(c, t) {
		alias T = typeof(t);
		static if (is(T : Aggregate)) {
			static struct AliasThisResult {
				Expression expr;
				CastKind level;
			}
			
			auto level = CastKind.Invalid;
			enum InvalidResult = AliasThisResult(null, CastKind.Invalid);
			
			import d.semantic.aliasthis;
			import std.algorithm;
			auto results = AliasThisResolver!((identified) {
				alias T = typeof(identified);
				static if (is(T : Expression)) {
					auto oldE = e;
					scope(exit) e = oldE;
					e = identified;
					
					auto cLevel = c.castFrom(identified.type, to);
					if (cLevel == CastKind.Invalid || cLevel < level) {
						return InvalidResult;
					}
					
					level = cLevel;
					return AliasThisResult(identified, cLevel);
				} else {
					return InvalidResult;
				}
			})(pass).resolve(e, t).filter!(r => r.level == level);
			
			if (level == CastKind.Invalid) {
				return CastKind.Invalid;
			}
			
			Expression candidate;
			foreach(r; results) {
				if (candidate !is null) {
					return CastKind.Invalid;
				}
				
				candidate = r.expr;
			}
			
			assert(candidate, "if no candidate are found, level should be Invalid");
			
			e = candidate;
			return level;
		} else static if (is(T : BuiltinType)) {
			auto to = c.to;
			if (to.kind != TypeKind.Builtin || !canConvertToIntegral(to.builtin)) {
				return CastKind.Invalid;
			}
			
			assert(getSize(to.builtin) < getSize(t));
			
			import d.semantic.vrp;
			return ValueRangePropagator!uint(pass).canFit(e, to)
				? CastKind.Trunc
				: CastKind.Invalid;
		} else {
			return CastKind.Invalid;
		}
	})(pass, to).castFrom(e.type);
	
	switch(kind) with(CastKind) {
		case Exact:
			// FIXME: Because we don't cast type qualifier the proper
			// way, we need to make sure they match.
			e.type = e.type.qualify(to.qualifier);
			return e;
		
		default:
			return new CastExpression(location, kind, to, e);
		
		case Invalid:
			if (to.kind == TypeKind.Error) {
				return to.error.expression;
			}
			
			import d.ir.error;
			if (auto ee = cast(ErrorExpression) e) {
				return ee;
			}
			
			return new CompileError(
				location,
				"Can't cast " ~ e.type.toString(pass.context)
					~ " to " ~ to.toString(pass.context),
			).expression;
	}
}

alias ExplicitCaster = Caster!true;
alias ImplicitCaster = Caster!false;

struct Caster(bool isExplicit, alias bailoutOverride = null) {
	// XXX: Used only to get to super class, should probably go away.
	private SemanticPass pass;
	alias pass this;
	
	Type to;
	
	this(SemanticPass pass, Type to) {
		this.pass = pass;
		this.to = to;
	}
	
	enum hasBailoutOverride = !is(typeof(bailoutOverride) : typeof(null));
	
	CastKind bailout(T)(T t) {
		static if (hasBailoutOverride) {
			return bailoutOverride(this, t);
		} else {
			return CastKind.Invalid;
		}
	}
	
	CastKind bailoutDefault(T)(T t) {
		return CastKind.Invalid;
	}
	
	CastKind castFrom(ParamType from, ParamType to) {
		if (from.isRef != to.isRef) {
			return CastKind.Invalid;
		}
		
		auto k = castFrom(from.getType(), to.getType());
		if (from.isRef && k < CastKind.Qual) {
			return CastKind.Invalid;
		}
		
		return k;
	}
	
	// FIXME: handle qualifiers.
	CastKind castFrom(Type from) {
		from = from.getCanonical();
		to = to.getCanonical();
		
		if (from == to) {
			return CastKind.Exact;
		}
		
		return from.accept(this);
	}
	
	CastKind castFrom(Type from, Type to) {
		this.to = to;
		return castFrom(from);
	}
	
	CastKind visit(BuiltinType t) {
		if (isExplicit && to.kind == TypeKind.Enum) {
			to = to.getCanonicalAndPeelEnum();
			auto k = visit(t);
			return (k == CastKind.Exact)
				? CastKind.Bit
				: k;
		}
		
		// Can cast typeof(null) to class, pointer and function.
		if (t == BuiltinType.Null && to.hasPointerABI()) {
			return CastKind.Bit;
		}
		
		// Can explicitely cast integral to pointer.
		if (isExplicit && (to.kind == TypeKind.Pointer && canConvertToIntegral(t))) {
			return CastKind.IntToPtr;
		}
		
		if (to.kind != TypeKind.Builtin) {
			return CastKind.Invalid;
		}
		
		auto bt = to.builtin;
		if (t == bt) {
			return CastKind.Exact;
		}
		
		final switch(t) with(BuiltinType) {
			case None :
			case Void :
				return CastKind.Invalid;
			
			case Bool :
				if (isIntegral(bt)) {
					return CastKind.UPad;
				}
				
				return CastKind.Invalid;
			
			case Char :
				t = integralOfChar(t);
				goto case Ubyte;
			
			case Wchar :
				t = integralOfChar(t);
				goto case Ushort;
			
			case Dchar :
				t = integralOfChar(t);
				goto case Uint;
			
			case Byte, Ubyte, Short, Ushort, Int, Uint, Long, Ulong, Cent, Ucent :
				if (isExplicit && bt == Bool) {
					return CastKind.IntToBool;
				}
				
				if (!isIntegral(bt)) {
					return CastKind.Invalid;
				}
				
				auto ut = unsigned(t);
				bt = unsigned(bt);
				if (ut == bt) {
					return CastKind.Bit;
				} else if (ut < bt) {
					return isSigned(t)
						? CastKind.SPad
						: CastKind.UPad;
				} else static if (isExplicit) {
					return CastKind.Trunc;
				} else {
					return bailout(t);
				}
			
			case Float, Double, Real :
				assert(0, "Floating point casts are not implemented");
			
			case Null :
				return CastKind.Invalid;
		}
	}
	
	CastKind visitPointerOf(Type t) {
		// You can explicitely cast pointer to class, function.
		if (isExplicit && to.kind != TypeKind.Pointer && to.hasPointerABI()) {
			return CastKind.Bit;
		}
		
		// It is also possible to cast to integral explicitely.
		if (isExplicit && to.kind == TypeKind.Builtin) {
			if (canConvertToIntegral(to.builtin)) {
				return CastKind.PtrToInt;
			}
		}
		
		if (to.kind != TypeKind.Pointer) {
			return CastKind.Invalid;
		}
		
		auto e = to.element.getCanonical();
		
		// Cast to void* is kind of special.
		if (e.kind == TypeKind.Builtin && e.builtin == BuiltinType.Void) {
			return (isExplicit || canConvert(t.qualifier, e.qualifier))
				? CastKind.Bit
				: CastKind.Invalid;
		}
		
		auto subCast = castFrom(t, e);
		switch(subCast) with(CastKind) {
			case Qual:
				if (canConvert(t.qualifier, e.qualifier)) {
					return Qual;
				}
				
				goto default;
			
			case Exact:
				return Qual;
			
			static if (isExplicit) {
				default:
					return Bit;
			} else {
				case Bit :
					if (canConvert(t.qualifier, e.qualifier)) {
						return subCast;
					}
					
					goto default;
				
				default:
					return Invalid;
			}
		}
	}
	
	CastKind visitSliceOf(Type t) {
		if (to.kind != TypeKind.Slice) {
			return CastKind.Invalid;
		}
		
		auto e = to.element.getCanonical();
		
		auto subCast = castFrom(t, e);
		switch(subCast) with(CastKind) {
			case Qual:
				if (canConvert(t.qualifier, e.qualifier)) {
					return Qual;
				}
				
				goto default;
			
			case Exact:
				return Qual;
			
			static if (isExplicit) {
				default:
					return Bit;
			} else {
				case Bit:
					if (canConvert(t.qualifier, e.qualifier)) {
						return subCast;
					}
					
					goto default;
				
				default:
					return Invalid;
			}
		}
	}
	
	CastKind visitArrayOf(uint size, Type t) {
		if (to.kind != TypeKind.Array) {
			return CastKind.Invalid;
		}
		
		if (size != to.size) {
			return CastKind.Invalid;
		}
		
		auto e = to.element.getCanonical();
		
		auto subCast = castFrom(t, e);
		switch(subCast) with(CastKind) {
			case Qual:
				if (canConvert(t.qualifier, e.qualifier)) {
					return Qual;
				}
				
				goto default;
			
			case Exact:
				return Exact;
			
			static if (isExplicit) {
				default:
					return Bit;
			} else {
				case Bit:
					if (canConvert(t.qualifier, e.qualifier)) {
						return subCast;
					}
					
					goto default;
				
				default:
					return Invalid;
			}
		}
	}
	
	CastKind visit(Struct s) {
		if (to.kind == TypeKind.Struct) {
			if (to.dstruct is s) {
				return CastKind.Exact;
			}
		}
		
		return bailout(s);
	}
	
	private auto castClass(Class from, Class to) {
		if (from is to) {
			return CastKind.Exact;
		}
		
		auto upcast = from;
		
		// Stop at object.
		while(upcast !is upcast.base) {
			// Automagically promote to base type.
			upcast = upcast.base;
			
			if (upcast is to) {
				return CastKind.Bit;
			}
		}
		
		static if (isExplicit) {
			auto downcast = to;
			
			// Stop at object.
			while(downcast !is downcast.base) {
				// Automagically promote to base type.
				downcast = downcast.base;
				
				if (downcast is from) {
					return CastKind.Down;
				}
			}
		}
		
		return CastKind.Invalid;
	}
	
	CastKind visit(Class c) {
		if (isExplicit && to.kind == TypeKind.Pointer) {
			auto et = to.element.getCanonical();
			if (et.kind == TypeKind.Builtin &&
				et.builtin == BuiltinType.Void) {
				return CastKind.Bit;
			}
		}
		
		if (to.kind == TypeKind.Class) {
			scheduler.require(c, Step.Signed);
			auto kind = castClass(c, to.dclass);
			if (kind > CastKind.Invalid) {
				return kind;
			}
		}
		
		return bailout(c);
	}
	
	CastKind visit(Enum e) {
		if (to.kind == TypeKind.Enum) {
			if (e is to.denum) {
				return CastKind.Exact;
			}
		}
		
		// Automagically promote to base type.
		return castFrom(e.type);
	}
	
	CastKind visit(TypeAlias a) {
		return castFrom(a.type);
	}
	
	CastKind visit(Interface i) {
		return CastKind.Invalid;
	}
	
	CastKind visit(Union u) {
		return (to.kind == TypeKind.Union && to.dunion is u)
			? CastKind.Exact
			: CastKind.Invalid;
	}
	
	CastKind visit(Function f) {
		assert(0, "Cast to context type do not make any sense.");
	}
	
	CastKind visit(Type[] seq) {
		assert(0, "Cast to sequence type do not make any sense.");
	}
	
	CastKind visit(FunctionType f) {
		if (to.kind == TypeKind.Pointer && f.contexts.length == 0) {
			auto e = to.element.getCanonical();
			static if (isExplicit) {
				return CastKind.Bit;
			} else if (e.kind == TypeKind.Builtin && e.builtin == BuiltinType.Void) {
				// FIXME: qualifier.
				return CastKind.Bit;
			} else {
				return CastKind.Invalid;
			}
		}
		
		if (to.kind != TypeKind.Function) {
			return CastKind.Invalid;
		}
		
		auto tf = to.asFunctionType();
		
		if (f.contexts.length != tf.contexts.length) {
			return CastKind.Invalid;
		}
		
		enum onFail = isExplicit ? CastKind.Bit : CastKind.Invalid;
		
		if (f.parameters.length != tf.parameters.length) {
			return onFail;
		}
		
		if (f.isVariadic != tf.isVariadic) {
			return onFail;
		}
		
		if (f.linkage != tf.linkage) {
			return onFail;
		}
		
		auto k = castFrom(f.returnType, tf.returnType);
		if (k < CastKind.Bit) {
			return onFail;
		}
		
		import std.range;
		foreach(fromc, toc; lockstep(f.contexts, tf.contexts)) {
			// ref context decay to void*
			if (fromc.isRef && !toc.isRef &&
				toc.kind == TypeKind.Pointer) {
				
				auto e = toc.getType().element;
				if (e.kind == TypeKind.Builtin &&
					e.builtin == BuiltinType.Void) {
				
					k = CastKind.Bit;
					continue;
				}
			}
			
			// Contexts are covariant.
			auto kc = castFrom(fromc, toc);
			if (kc < CastKind.Bit) {
				return onFail;
			}
			
			import std.algorithm;
			k = min(k, kc);
		}
		
		foreach(fromp, top; lockstep(f.parameters, tf.parameters)) {
			// Parameters are contrevariant.
			auto kp = castFrom(top, fromp);
			if (kp < CastKind.Bit) {
				return onFail;
			}
			
			import std.algorithm;
			k = min(k, kp);
		}
		
		return (k < CastKind.Exact) ? CastKind.Bit : CastKind.Exact;
	}
	
	CastKind visit(Pattern p) {
		assert(0, "Pattern cannot be casted.");
	}
	
	import d.ir.error;
	CastKind visit(CompileError e) {
		return CastKind.Invalid;
	}
}