/**
 * This module converts a package containing D Model definitions to
 * $(REF SerializedModels, dorm,declarative)
 */
module dorm.declarative.conversion;

import dorm.annotations;
import dorm.declarative;
import dorm.exception;
import dorm.model;
import dorm.types;

import std.algorithm : remove;
import std.conv;
import std.datetime;
import std.meta;
import std.traits;
import std.typecons;

version (unittest) import dorm.model;

/** 
 * Entry point to the Model (class) to SerializedModels (declarative) conversion
 * code. Manually calling this should not be neccessary as the
 * $(REF RegisterModels, dorm,declarative,entrypoint) mixin will call this instead.
 */
SerializedModels processModelsToDeclarations(alias mod)()
{
	SerializedModels ret;

	static foreach (member; __traits(allMembers, mod))
	{
		static if (__traits(compiles, is(__traits(getMember, mod, member) : Model))
			&& is(__traits(getMember, mod, member) : Model)
			&& !__traits(isAbstractClass, __traits(getMember, mod, member)))
		{
			processModel!(
				__traits(getMember, mod, member),
				SourceLocation(__traits(getLocation, __traits(getMember, mod, member)))
			)(ret);
		}
	}

	return ret;
}

private void processModel(TModel : Model, SourceLocation loc)(
	ref SerializedModels models)
{
	ModelFormat serialized = DormLayout!TModel;
	serialized.definedAt = loc;
	models.models ~= serialized;
}

private enum DormLayoutImpl(TModel : Model) = function() {
	ModelFormat serialized;
	serialized.tableName = DormModelTableName!TModel;

	alias attributes = __traits(getAttributes, TModel);

	static foreach (attribute; attributes)
	{
		static if (isDormModelAttribute!attribute)
		{
			static assert(false, "Unsupported attribute " ~ attribute.stringof ~ " on " ~ TModel.stringof ~ "." ~ member);
		}
	}

	string errors;

	static foreach (field; LogicalFields!(TModel, 2))
	{
		try
		{
			processField!(TModel, field, field)(serialized);
		}
		catch (Exception e)
		{
			errors ~= "\n\t" ~ e.msg;
		}
	}

	static if (!__traits(isAbstractClass, TModel))
		errors ~= serialized.lint("\n\t");

	struct Ret
	{
		string errors;
		ModelFormat ret;
	}

	return Ret(errors, serialized);
}();

template DormLayout(TModel : Model)
{
	private enum Impl = DormLayoutImpl!TModel;
	static if (Impl.errors.length)
		static assert(false, "Model Definition of `"
			~ TModel.stringof ~ "` contains errors:" ~ Impl.errors);
	else
		enum ModelFormat DormLayout = Impl.ret;
}

/// Equivalent to `DormLayout!TModel.tableName`
enum DormModelTableName(TModel : Model) = TModel.stringof.toSnakeCase;

enum DormFields(TModel : Model) = DormLayout!TModel.fields;
enum DormForeignKeys(TModel : Model) = (() {
	auto all = DormFields!TModel;
	foreach_reverse (i, field; all)
		if (!field.isForeignKey)
			all = all.remove(i);
	return all;
})();

enum DormFieldIndex(TModel : Model, string sourceName) = findFieldIdx(DormFields!TModel, sourceName);
enum hasDormField(TModel : Model, string sourceName) = DormFieldIndex!(TModel, sourceName) != -1;
enum DormField(TModel : Model, string sourceName) = DormFields!TModel[DormFieldIndex!(TModel, sourceName)];

enum DormPrimaryKeyIndex(TModel : Model) = findPrimaryFieldIdx(DormFields!TModel);
enum DormPrimaryKey(TModel : Model) = DormFields!TModel[DormPrimaryKeyIndex!TModel];

/// Equivalent to DormPrimaryKey!TModel.sourceColumn, but does not analyze the
/// model, thus avoiding cyclic lookups. Note: does not do any sanity checks,
/// like checking if there are two primary keys.
template DormPrimaryKeyName(TModel : Model)
{
	static foreach (field; LogicalFields!TModel)
		static if (hasUDA!(__traits(getMember, TModel, field), primaryKey))
			enum DormPrimaryKeyName = field;
}

/// Used internally, basically converts the field name to snake case or returns
/// the @columnName value if the field has been annotated with it.
static template DormColumnNameImpl(alias field)
{
	enum DormColumnNameImpl = {
		string ret = __traits(identifier, field).toSnakeCase;

		alias attributes = __traits(getAttributes, field);
		static foreach (attribute; attributes)
			static if (is(typeof(attribute) == columnName))
				ret = attribute.name;
		return ret;
	}();
}

/// Returns all fields with `@constructValue` annotations. Used internally in
/// Model to determine which fields to look at in the constructor.
enum string[] DormModelConstructors(TModel : Model) = {
	string[] ret;
	static foreach (field; LogicalFields!(TModel, 1))
	{{
		alias fieldAlias = __traits(getMember, TModel, field);

		alias attributes = __traits(getAttributes, fieldAlias);
		static foreach (attribute; attributes)
		{{
			static if (is(attribute == constructValue!fn, alias fn))
				ret ~= field;
		}}
	}}
	return ret;
}();

enum DormListFieldsForError(TModel : Model) = formatFieldList(DormFields!TModel);

private auto findFieldIdx(ModelFormat.Field[] fields, string name)
{
	foreach (i, ref field; fields)
		if (field.sourceColumn == name)
			return i;
	return -1;
}

private auto findPrimaryFieldIdx(ModelFormat.Field[] fields)
{
	foreach (i, ref field; fields)
		if (field.isPrimaryKey)
			return i;
	return -1;
}

private auto formatFieldList(ModelFormat.Field[] fields)
{
	string ret;
	foreach (field; fields)
		ret ~= "\n- " ~ field.toPrettySourceString;
	return ret;
}

/// Returns the name of all public member fields, through all base classes (i.e.
/// returns identifiers of public .tupleof members)
template LogicalFields(TModel, int cacheHack = 0)
{
	// cacheHack exists because DormLayout needs a different cache due to cyclic things
	static if (is(TModel : Model))
		alias Classes = AliasSeq!(TModel, BaseClassesTuple!TModel);
	else
		alias Classes = AliasSeq!(TModel);
	alias LogicalFields = AliasSeq!();

	static foreach_reverse (Class; Classes)
	{
		static foreach (field; __traits(derivedMembers, Class))
		{
			static if (
				// isTemplate does not compile for circular references, but those are assumed to be fields
				!__traits(compiles, __traits(isTemplate, __traits(getMember, Class, field)))
				|| (is(typeof(__traits(getMember, Class, field)))
				&& !is(typeof(&__traits(getMember, Class, field)))
				&& !__traits(isTemplate, __traits(getMember, Class, field))
				&& __traits(getProtection, __traits(getMember, Class, field)) == "public"))
				LogicalFields = AliasSeq!(LogicalFields, field);
		}
	}
}

private struct ProcessFieldResult
{
	bool include, checkForOtherPrimaryKey;
	ModelFormat.Field field;
}

private void processField(TModel, string fieldName, string directFieldName)(ref ModelFormat serialized)
{
	alias fieldAlias = __traits(getMember, TModel, directFieldName);

	ProcessFieldResult result = processFieldImpl!(TModel, fieldName, directFieldName)();

	static if (hasUDA!(fieldAlias, embedded))
	{
		serialized.embeddedStructs ~= fieldName;
		alias TSubModel = typeof(fieldAlias);
		static foreach (subfield; LogicalFields!(TSubModel, 2))
		{
			processField!(TSubModel, fieldName ~ "." ~ subfield, subfield)(serialized);
		}
	}

	with (result) if (include)
	{
		if (checkForOtherPrimaryKey)
		{
			foreach (other; serialized.fields)
			{
				if (other.isPrimaryKey)
					throw new DormModelException("Duplicate primary key found in Model " ~ TModel.stringof
						~ ":\n- first defined here:\n"
						~ other.sourceColumn ~ " in " ~ other.definedAt.toString
						~ "\n- then attempted to redefine here:\n"
						~ typeof(fieldAlias).stringof ~ " " ~ fieldName ~ " in " ~ field.definedAt.toString
						~ "\nMaybe you wanted to define a `TODO: compositeKey`?");
			}
		}

		// https://github.com/myOmikron/drorm/issues/8
		if (field.hasFlag(AnnotationFlag.autoIncrement) && !field.hasFlag(AnnotationFlag.primaryKey))
				throw new DormModelException(field.sourceReferenceName(TModel.stringof)
					~ " has @autoIncrement annotation, but is missing required @primaryKey annotation.");

		if (field.type == InvalidDBType)
			throw new DormModelException(SourceLocation(__traits(getLocation, fieldAlias)).toErrorString
				~ "Cannot resolve DORM Model DBType from " ~ typeof(fieldAlias).stringof
				~ " `" ~ directFieldName ~ "` in " ~ TModel.stringof);

		foreach (ai, lhs; field.annotations)
		{
			foreach (bi, rhs; field.annotations)
			{
				if (ai == bi) continue;
				if (!lhs.isCompatibleWith(rhs))
					throw new DormModelException("Incompatible annotation: "
						~ lhs.to!string ~ " conflicts with " ~ rhs.to!string
						~ " on " ~ field.sourceReferenceName(TModel.stringof));
			}
		}

		serialized.fields ~= field;
	}
}

private ProcessFieldResult processFieldImpl(TModel, string fieldName, string directFieldName)()
{
	import uda = dorm.annotations;

	alias fieldAlias = __traits(getMember, TModel, directFieldName);

	alias attributes = __traits(getAttributes, fieldAlias);

	bool include = true;
	ModelFormat.Field field;

	field.definedAt = SourceLocation(__traits(getLocation, fieldAlias));
	field.columnName = directFieldName.toSnakeCase;
	field.sourceType = typeof(fieldAlias).stringof;
	field.sourceColumn = fieldName;
	field.type = guessDBType!(typeof(fieldAlias));

	static if (is(typeof(fieldAlias) == Nullable!T, T))
	{
		alias UnnullType = T;
		enum isNullable = true;
	}
	else
	{
		alias UnnullType = typeof(fieldAlias);
		enum isNullable = false;
	}

	bool checkForOtherPrimaryKey = false;

	bool explicitNotNull = false;
	bool nullable = false;
	bool mustBeNullable = false;
	bool hasNonNullDefaultValue = false;
	static if (isNullable || is(typeof(fieldAlias) : Model))
		nullable = true;

	static if (is(UnnullType == enum))
		field.annotations ~= DBAnnotation(Choices([
				__traits(allMembers, UnnullType)
			]));
	else static if (is(UnnullType : ModelRefImpl!(_id, _TModel, _TSelect),
		alias _id, _TModel, _TSelect))
	{
		ForeignKeyImpl foreignKeyImpl;
		auto foreignKeyInfo = processFieldImpl!(_TModel, UnnullType.primaryKeySourceName, UnnullType.primaryKeySourceName);
		assert(foreignKeyInfo.include, "Refering to a foreign key that's not included in the result!");
		field.type = foreignKeyInfo.field.type;
		field.annotations ~= foreignKeyInfo.field.foreignKeyAnnotations;
		foreignKeyImpl.column = foreignKeyInfo.field.columnName;
		foreignKeyImpl.table = DormModelTableName!_TModel;
	}

	enum bool isForeignKey = is(typeof(foreignKeyImpl));

	void setDefaultValue(T)(T value)
	{
		static if (__traits(compiles, value !is null))
		{
			if (value !is null)
				hasNonNullDefaultValue = true;
		}
		else
			hasNonNullDefaultValue = true;

		field.annotations ~= DBAnnotation(defaultValue(value));
	}

	static foreach (attribute; attributes)
	{{
		static if (__traits(isSame, attribute, uda.autoCreateTime))
		{
			field.type = ModelFormat.Field.DBType.datetime;
			field.annotations ~= DBAnnotation(AnnotationFlag.autoCreateTime);
			hasNonNullDefaultValue = true;
		}
		else static if (__traits(isSame, attribute, uda.autoUpdateTime))
		{
			field.type = ModelFormat.Field.DBType.datetime;
			field.annotations ~= DBAnnotation(AnnotationFlag.autoUpdateTime);
			mustBeNullable = true;
		}
		else static if (__traits(isSame, attribute, uda.timestamp))
		{
			field.type = ModelFormat.Field.DBType.datetime;
			mustBeNullable = true;
		}
		else static if (__traits(isSame, attribute, uda.primaryKey))
		{
			nullable = true;
			field.annotations ~= DBAnnotation(AnnotationFlag.primaryKey);
			checkForOtherPrimaryKey = true;
		}
		else static if (__traits(isSame, attribute, uda.autoIncrement))
		{
			field.annotations ~= DBAnnotation(AnnotationFlag.autoIncrement);
			hasNonNullDefaultValue = true;
		}
		else static if (__traits(isSame, attribute, uda.unique))
		{
			field.annotations ~= DBAnnotation(AnnotationFlag.unique);
		}
		else static if (__traits(isSame, attribute, uda.embedded))
		{
			static if (!is(typeof(fieldAlias) == struct))
				static assert(false, "@embedded is only supported on structs");
			include = false;
		}
		else static if (__traits(isSame, attribute, uda.ignored))
		{
			include = false;
		}
		else static if (__traits(isSame, attribute, uda.notNull))
		{
			explicitNotNull = true;
		}
		else static if (is(attribute == constructValue!fn, alias fn))
		{
			field.internalAnnotations ~= InternalAnnotation(ConstructValueRef(fieldName));
		}
		else static if (is(attribute == validator!fn, alias fn))
		{
			field.internalAnnotations ~= InternalAnnotation(ValidatorRef(fieldName));
		}
		else static if (__traits(isSame, attribute, defaultFromInit))
		{
			static if (is(TModel == struct))
			{
				setDefaultValue(__traits(getMember, TModel.init, directFieldName));
			}
			else static if (__traits(compiles, __traits(getMember, new TModel(), directFieldName)))
			{
				setDefaultValue(__traits(getMember, new TModel(), directFieldName));
			}
			else
			{
				if (include)
				{
					throw new DormModelException(field.sourceReferenceName(TModel.stringof)
						~ " is annotated with `@defaultFromInit`, but failed construction. "
						~ "Consider moving this field into a struct and using `@embedded` to use it "
						~ "or remove incompatible attributes. (Implicit Patches work as well)");
				}
			}
		}
		else static if (is(typeof(attribute) == maxLength)
			|| is(typeof(attribute) == DefaultValue!T, T)
			|| is(typeof(attribute) == index))
		{
			static if (is(typeof(attribute) == DefaultValue!U, U)
				&& !is(U == typeof(null)))
			{
				hasNonNullDefaultValue = true;
			}
			field.annotations ~= DBAnnotation(attribute);
		}
		else static if (is(typeof(attribute) == Choices))
		{
			field.type = ModelFormat.Field.DBType.choices;
			field.annotations ~= DBAnnotation(attribute);
		}
		else static if (is(typeof(attribute) == columnName))
		{
			field.columnName = attribute.name;
		}
		else static if (is(typeof(attribute) == uda.onUpdate)
			&& isForeignKey)
		{
			foreignKeyImpl.onUpdate = attribute.type;
		}
		else static if (is(typeof(attribute) == uda.onDelete)
			&& isForeignKey)
		{
			foreignKeyImpl.onDelete = attribute.type;
		}
		else static if (isDormFieldAttribute!attribute)
		{
			static assert(false, "Unsupported attribute " ~ attribute.stringof ~ " on " ~ TModel.stringof ~ "." ~ fieldName);
		}
	}}

	static if (isForeignKey)
		field.annotations ~= DBAnnotation(foreignKeyImpl);

	if (include)
	{
		if (!nullable || explicitNotNull)
		{
			if (mustBeNullable && !hasNonNullDefaultValue)
			{
				throw new DormModelException(field.sourceReferenceName(TModel.stringof)
					~ " may be null. Change it to Nullable!(" ~ typeof(fieldAlias).stringof
					~ ") or annotate with defaultValue, autoIncrement or autoCreateTime");
			}
			field.annotations = DBAnnotation(AnnotationFlag.notNull) ~ field.annotations;
		}
	}

	return ProcessFieldResult(
		include,
		checkForOtherPrimaryKey,
		field
	);
}

private string toSnakeCase(string s)
{
	import std.array;
	import std.ascii;

	auto ret = appender!(char[]);
	int upperCount;
	char lastChar;
	foreach (char c; s)
	{
		scope (exit)
			lastChar = c;
		if (upperCount)
		{
			if (isUpper(c))
			{
				ret ~= toLower(c);
				upperCount++;
			}
			else
			{
				if (isDigit(c))
				{
					ret ~= '_';
					ret ~= c;
				}
				else if (isLower(c) && upperCount > 1 && ret.data.length)
				{
					auto last = ret.data[$ - 1];
					ret.shrinkTo(ret.data.length - 1);
					ret ~= '_';
					ret ~= last;
					ret ~= c;
				}
				else
				{
					ret ~= toLower(c);
				}
				upperCount = 0;
			}
		}
		else if (isUpper(c))
		{
			if (ret.data.length
				&& ret.data[$ - 1] != '_'
				&& !lastChar.isUpper)
			{
				ret ~= '_';
				ret ~= toLower(c);
				upperCount++;
			}
			else
			{
				if (ret.data.length)
					upperCount++;
				ret ~= toLower(c);
			}
		}
		else if (c == '_')
		{
			if (ret.data.length)
				ret ~= '_';
		}
		else if (isDigit(c))
		{
			if (ret.data.length && !ret.data[$ - 1].isDigit && ret.data[$ - 1] != '_')
				ret ~= '_';
			ret ~= c;
		}
		else
		{
			if (ret.data.length && ret.data[$ - 1].isDigit && ret.data[$ - 1] != '_')
				ret ~= '_';
			ret ~= c;
		}
	}

	auto slice = ret.data;
	while (slice.length && slice[$ - 1] == '_')
		slice = slice[0 .. $ - 1];
	return slice.idup;
}

unittest
{
	assert("".toSnakeCase == "");
	assert("a".toSnakeCase == "a");
	assert("A".toSnakeCase == "a");
	assert("AB".toSnakeCase == "ab");
	assert("JsonValue".toSnakeCase == "json_value");
	assert("HTTPHandler".toSnakeCase == "http_handler");
	assert("Test123".toSnakeCase == "test_123");
	assert("foo_bar".toSnakeCase == "foo_bar");
	assert("foo_Bar".toSnakeCase == "foo_bar");
	assert("Foo_Bar".toSnakeCase == "foo_bar");
	assert("FOO_bar".toSnakeCase == "foo_bar");
	assert("FOO__bar".toSnakeCase == "foo__bar");
	assert("do_".toSnakeCase == "do");
	assert("fooBar_".toSnakeCase == "foo_bar");
	assert("_do".toSnakeCase == "do");
	assert("_fooBar".toSnakeCase == "foo_bar");
	assert("_FooBar".toSnakeCase == "foo_bar");
	assert("HTTP2".toSnakeCase == "http_2");
	assert("HTTP2Foo".toSnakeCase == "http_2_foo");
	assert("HTTP2foo".toSnakeCase == "http_2_foo");
}

private enum InvalidDBType = cast(ModelFormat.Field.DBType)int.max;

private template guessDBType(T)
{
	static if (is(T == enum))
		enum guessDBType = ModelFormat.Field.DBType.choices;
	else static if (is(T == BitFlags!U, U))
		enum guessDBType = ModelFormat.Field.DBType.set;
	else static if (is(T == Nullable!U, U))
	{
		static if (__traits(compiles, guessDBType!U))
			enum guessDBType = guessDBType!U;
		else
			static assert(false, "cannot resolve DBType from nullable " ~ U.stringof);
	}
	else static if (__traits(compiles, guessDBTypeBase!T))
		enum guessDBType = guessDBTypeBase!T;
	else
		enum guessDBType = InvalidDBType;
}

private enum guessDBTypeBase(T : const(char)[]) = ModelFormat.Field.DBType.varchar;
private enum guessDBTypeBase(T : const(ubyte)[]) = ModelFormat.Field.DBType.varbinary;
private enum guessDBTypeBase(T : byte) = ModelFormat.Field.DBType.int8;
private enum guessDBTypeBase(T : short) = ModelFormat.Field.DBType.int16;
private enum guessDBTypeBase(T : int) = ModelFormat.Field.DBType.int32;
private enum guessDBTypeBase(T : long) = ModelFormat.Field.DBType.int64;
private enum guessDBTypeBase(T : ubyte) = ModelFormat.Field.DBType.int16;
private enum guessDBTypeBase(T : ushort) = ModelFormat.Field.DBType.int32;
private enum guessDBTypeBase(T : uint) = ModelFormat.Field.DBType.int64;
private enum guessDBTypeBase(T : float) = ModelFormat.Field.DBType.floatNumber;
private enum guessDBTypeBase(T : double) = ModelFormat.Field.DBType.doubleNumber;
private enum guessDBTypeBase(T : bool) = ModelFormat.Field.DBType.boolean;
private enum guessDBTypeBase(T : Date) = ModelFormat.Field.DBType.date;
private enum guessDBTypeBase(T : DateTime) = ModelFormat.Field.DBType.datetime;
private enum guessDBTypeBase(T : SysTime) = ModelFormat.Field.DBType.datetime;
private enum guessDBTypeBase(T : TimeOfDay) = ModelFormat.Field.DBType.time;

unittest
{
	import std.sumtype;

	struct Mod
	{
		import std.datetime;
		import std.typecons;

		enum State : string
		{
			ok = "ok",
			warn = "warn",
			critical = "critical",
			unknown = "unknown"
		}

		class User : Model
		{
			@maxLength(255)
			string username;

			@maxLength(255)
			string password;

			@maxLength(255)
			Nullable!string email;

			ubyte age;

			Nullable!DateTime birthday;

			@autoCreateTime
			SysTime createdAt;

			@autoUpdateTime
			Nullable!SysTime updatedAt;

			@autoCreateTime
			ulong createdAt2;

			@autoUpdateTime
			Nullable!ulong updatedAt2;

			State state;

			@choices("ok", "warn", "critical", "unknown")
			string state2;

			@columnName("admin")
			bool isAdmin;

			@constructValue!(() => Clock.currTime + 4.hours)
			SysTime validUntil;

			@maxLength(255)
			@defaultValue("")
			string comment;

			@defaultValue(1337)
			int counter;

			@primaryKey
			long ownPrimaryKey;

			@timestamp
			Nullable!ulong someTimestamp;

			@unique
			int uuid;

			@validator!(x => x >= 18)
			int someInt;

			@ignored
			int imNotIncluded;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 1);

	auto m = mod.models[0];

	// Length is always len(m.fields + 1) as dorm.model.Model adds the id field,
	// unless you define your own primary key field.
	assert(m.fields.length == 19);

	int i = 0;

	assert(m.fields[i].columnName == "username");
	assert(m.fields[i].type == ModelFormat.Field.DBType.varchar);
	assert(m.fields[i].annotations == [DBAnnotation(AnnotationFlag.notNull), DBAnnotation(maxLength(255))]);

	assert(m.fields[++i].columnName == "password");
	assert(m.fields[i].type == ModelFormat.Field.DBType.varchar);
	assert(m.fields[i].annotations == [DBAnnotation(AnnotationFlag.notNull), DBAnnotation(maxLength(255))]);

	assert(m.fields[++i].columnName == "email");
	assert(m.fields[i].type == ModelFormat.Field.DBType.varchar);
	assert(m.fields[i].annotations == [DBAnnotation(maxLength(255))]);

	assert(m.fields[++i].columnName == "age");
	assert(m.fields[i].type == ModelFormat.Field.DBType.int16);
	assert(m.fields[i].annotations == [DBAnnotation(AnnotationFlag.notNull)]);

	assert(m.fields[++i].columnName == "birthday");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == []);

	assert(m.fields[++i].columnName == "created_at");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(AnnotationFlag.autoCreateTime),
		]);

	assert(m.fields[++i].columnName == "updated_at");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.autoUpdateTime)
		]);

	assert(m.fields[++i].columnName == "created_at_2");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(AnnotationFlag.autoCreateTime),
		]);

	assert(m.fields[++i].columnName == "updated_at_2");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.autoUpdateTime)
		]);

	assert(m.fields[++i].columnName == "state");
	assert(m.fields[i].type == ModelFormat.Field.DBType.choices);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(Choices(["ok", "warn", "critical", "unknown"])),
		]);

	assert(m.fields[++i].columnName == "state_2");
	assert(m.fields[i].type == ModelFormat.Field.DBType.choices);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(Choices(["ok", "warn", "critical", "unknown"])),
		]);

	assert(m.fields[++i].columnName == "admin");
	assert(m.fields[i].type == ModelFormat.Field.DBType.boolean);
	assert(m.fields[i].annotations == [DBAnnotation(AnnotationFlag.notNull)]);

	assert(m.fields[++i].columnName == "valid_until");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull)
		]);
	assert(m.fields[i].internalAnnotations.length == 1);
	assert(m.fields[i].internalAnnotations[0].match!((ConstructValueRef r) => true, _ => false));

	assert(m.fields[++i].columnName == "comment");
	assert(m.fields[i].type == ModelFormat.Field.DBType.varchar);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(maxLength(255)),
			DBAnnotation(defaultValue("")),
		]);

	assert(m.fields[++i].columnName == "counter");
	assert(m.fields[i].type == ModelFormat.Field.DBType.int32);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(defaultValue(1337)),
		]);

	assert(m.fields[++i].columnName == "own_primary_key");
	assert(m.fields[i].type == ModelFormat.Field.DBType.int64);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.primaryKey),
		]);

	assert(m.fields[++i].columnName == "some_timestamp");
	assert(m.fields[i].type == ModelFormat.Field.DBType.datetime);
	assert(m.fields[i].annotations == []);

	assert(m.fields[++i].columnName == "uuid");
	assert(m.fields[i].type == ModelFormat.Field.DBType.int32);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull),
			DBAnnotation(AnnotationFlag.unique),
		]);

	assert(m.fields[++i].columnName == "some_int");
	assert(m.fields[i].type == ModelFormat.Field.DBType.int32);
	assert(m.fields[i].annotations == [
			DBAnnotation(AnnotationFlag.notNull)
		]);
	assert(m.fields[i].internalAnnotations.length == 1);
	assert(m.fields[i].internalAnnotations[0].match!((ValidatorRef r) => true, _ => false));
}

unittest
{
	struct Mod
	{
		abstract class NamedThing : Model
		{
			@Id long id;

			@maxLength(255)
			string name;
		}

		class User : NamedThing
		{
			int age;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 1);

	auto m = mod.models[0];
	assert(m.tableName == "user");
	assert(m.fields.length == 3);
	assert(m.fields[0].columnName == "id");
	assert(m.fields[1].columnName == "name");
	assert(m.fields[2].columnName == "age");
}

unittest
{
	struct Mod
	{
		struct SuperCommon
		{
			int superCommonField;
		}

		struct Common
		{
			string commonName;
			@embedded
			SuperCommon superCommon;
		}

		class NamedThing : Model
		{
			@Id long id;

			@embedded
			Common common;

			@maxLength(255)
			string name;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 1);
	auto m = mod.models[0];
	assert(m.tableName == "named_thing");
	assert(m.fields.length == 4);
	assert(m.fields[1].columnName == "common_name");
	assert(m.fields[1].sourceColumn == "common.commonName");
	assert(m.fields[2].columnName == "super_common_field");
	assert(m.fields[2].sourceColumn == "common.superCommon.superCommonField");
	assert(m.fields[3].columnName == "name");
	assert(m.fields[3].sourceColumn == "name");
	assert(m.embeddedStructs == ["common", "common.superCommon"]);
}

// https://github.com/myOmikron/drorm/issues/6
unittest
{
	struct Mod
	{
		class NamedThing : Model
		{
			@Id long id;

			@timestamp
			Nullable!long timestamp1;

			@autoUpdateTime
			Nullable!long timestamp2;

			@autoCreateTime
			long timestamp3;

			@autoUpdateTime @autoCreateTime
			long timestamp4;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 1);
	auto m = mod.models[0];
	assert(m.tableName == "named_thing");
	assert(m.fields.length == 5);

	assert(m.fields[1].columnName == "timestamp_1");
	assert(m.fields[1].isNullable);
	assert(m.fields[2].isNullable);
	assert(!m.fields[3].isNullable);
	assert(!m.fields[4].isNullable);
}

unittest
{
	struct Mod
	{
		class DefaultValues : Model
		{
			@Id long id;

			@defaultValue(10)
			int f1;

			@defaultValue(2)
			int f2 = 1337;

			@defaultFromInit
			int f3 = 1337;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 1);
	auto m = mod.models[0];
	assert(m.fields.length == 4);

	assert(m.fields[1].columnName == "f_1");
	assert(m.fields[1].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(defaultValue(10))
	]);

	assert(m.fields[2].columnName == "f_2");
	assert(m.fields[2].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(defaultValue(2))
	]);

	assert(m.fields[3].columnName == "f_3");
	assert(m.fields[3].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(defaultValue(1337))
	]);
}

unittest
{
	struct Mod
	{
		class User : Model
		{
			@maxLength(255) @primaryKey
			string username;
		}

		class Toot : Model
		{
			@Id long id;

			ModelRef!(User.username) author;
		}
	}

	static assert(DormForeignKeys!(Mod.Toot).length == 1);
	static assert(DormForeignKeys!(Mod.Toot)[0].columnName == "author");

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 2);
	auto m = mod.models[0];
	assert(m.fields.length == 1);

	assert(m.fields[0].columnName == "username");
	assert(m.fields[0].annotations == [
		DBAnnotation(maxLength(255)),
		DBAnnotation(AnnotationFlag.primaryKey)
	]);

	m = mod.models[1];
	assert(m.fields.length == 2);

	assert(m.fields[1].columnName == "author");
	assert(m.fields[1].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(maxLength(255)),
		DBAnnotation(ForeignKeyImpl(
			"user", "username",
			restrict, restrict
		))
	]);
}

unittest
{
	// cyclic ref
	struct Mod
	{
		class User : Model
		{
			@Id long id;

			ModelRef!(Project.otherId) favoriteProject;
		}

		class Project : Model
		{
			@primaryKey @maxLength(123) string otherId;

			ModelRef!(User.id) author;
		}
	}

	auto mod = processModelsToDeclarations!Mod;
	assert(mod.models.length == 2);
	auto m = mod.models[0];
	assert(m.fields.length == 2);

	assert(m.fields[0].columnName == "id");
	assert(m.fields[0].annotations == [
		DBAnnotation(AnnotationFlag.primaryKey),
		DBAnnotation(AnnotationFlag.autoIncrement),
	]);

	assert(m.fields[1].columnName == "favorite_project");
	assert(m.fields[1].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(maxLength(123)),
		DBAnnotation(ForeignKeyImpl(
			"project", "other_id",
			restrict, restrict
		))
	]);

	m = mod.models[1];
	assert(m.fields.length == 2);

	assert(m.fields[0].columnName == "other_id");
	assert(m.fields[0].annotations == [
		DBAnnotation(AnnotationFlag.primaryKey),
		DBAnnotation(maxLength(123)),
	]);

	assert(m.fields[1].columnName == "author");
	assert(m.fields[1].annotations == [
		DBAnnotation(AnnotationFlag.notNull),
		DBAnnotation(ForeignKeyImpl(
			"user", "id",
			restrict, restrict
		))
	]);
}