module d.semantic.type;

import d.semantic.semantic;

import d.ast.identifier;
import d.ast.type;

import d.ir.type;

struct TypeVisitor {
	private SemanticPass pass;
	alias pass this;
	
	private TypeQualifier qualifier;
	
	this(SemanticPass pass, TypeQualifier qualifier = TypeQualifier.Mutable) {
		this.pass = pass;
		this.qualifier = qualifier;
	}
	
	import d.ast.declaration;
	TypeVisitor withStorageClass(StorageClass stc) {
		return TypeVisitor(
			pass,
			stc.hasQualifier
				? qualifier.add(stc.qualifier)
				: qualifier,
		);
	}
	
	Type visit(AstType t) {
		return t.accept(this).qualify(t.qualifier);
	}
	
	ParamType visit(ParamAstType t) {
		return visit(t.getType()).getParamType(t.paramKind);
	}
	
	Type visit(BuiltinType t) {
		return Type.get(t, qualifier);
	}
	
	Type visit(Identifier i) {
		import d.semantic.identifier;
		return IdentifierResolver(pass)
			.build(i)
			.apply!(delegate Type(identified) {
				static if(is(typeof(identified) : Type)) {
					return identified.qualify(qualifier);
				} else {
					import d.ir.error;
					return getError(
						identified,
						i.location,
						i.toString(pass.context) ~ " ("
							~ typeid(identified).toString()
							~ ") isn't an type",
					).type;
				}
			})();
	}
	
	Type visitPointerOf(AstType t) {
		return visit(t).getPointer(qualifier);
	}
	
	Type visitSliceOf(AstType t) {
		return visit(t).getSlice(qualifier);
	}
	
	Type visitArrayOf(AstExpression size, AstType t) {
		auto type = visit(t);
		
		import d.semantic.expression;
		return buildArray(ExpressionVisitor(pass).visit(size), type);
	}
	
	import d.ir.expression;
	private Type buildArray(Expression size, Type t) {
		import d.semantic.caster, d.semantic.expression;
		auto s = evalIntegral(buildImplicitCast(
			pass,
			size.location,
			pass.object.getSizeT().type,
			size,
		));
		
		assert(s <= uint.max, "Array larger than uint.max are not supported");
		return t.getArray(cast(uint) s, qualifier);
	}
	
	Type visitMapOf(AstType key, AstType t) {
		visit(t);
		visit(key);
		assert(0, "Map are not implemented.");
	}
	
	Type visitBracketOf(Identifier ikey, AstType t) {
		auto type = visit(t);
		
		import d.semantic.identifier, d.ir.symbol;
		return IdentifierResolver(pass)
			.build(ikey)
			.apply!(delegate Type(identified) {
				alias T = typeof(identified);
				static if (is(T : Type)) {
					assert(0, "Not implemented.");
				} else static if (is(T: Expression)) {
					return buildArray(identified, type);
				} else if (auto v = cast(ValueTemplateParameter) identified) {
					return Pattern(type, v).getType();
				} else {
					import d.ir.error;
					return getError(
						identified,
						ikey.location,
						ikey.toString(pass.context)
							~ " isn't an type or an expression",
					).type;
				}
			})();
	}
	
	Type visit(FunctionAstType t) {
		auto ctxCount = t.contexts.length;
		auto f = t.getFunction();
		
		ParamType[] paramTypes;
		paramTypes.length = f.parameters.length;
		
		auto oldQualifier = qualifier;
		scope(exit) qualifier = oldQualifier;
		
		foreach(i; 0 .. ctxCount) {
			paramTypes[i] = visit(f.parameters[i]);
		}
		
		qualifier = TypeQualifier.Mutable;
		
		auto returnType = visit(t.returnType);
		foreach (i; ctxCount .. paramTypes.length) {
			paramTypes[i] = visit(f.parameters[i]);
		}
		
		return FunctionType(t.linkage, returnType, paramTypes, t.isVariadic)
			.getDelegate(ctxCount)
			.getType(oldQualifier);
	}
	
	import d.ast.expression;
	Type visit(AstExpression e) {
		import d.semantic.expression;
		return ExpressionVisitor(pass).visit(e).type.qualify(qualifier);
	}
	
	Type visitTypeOfReturn() {
		assert(0, "typeof(return) is not implemented.");
	}
}