using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;

namespace Bon.Integrated
{
	struct SerializeValueState
	{
		public bool doOneLine, arrayKeepUnlessSet;
	}

	static class Serialize
	{
		public static mixin CompNoReflectionError(String type, String example)
		{
			scope:mixin $"No reflection data for {type}!\n(for example: [BonTarget] extension {example} {{}} or through build settings)"
		}

		static mixin DoAlwaysInclude(Type type)
		{
			type.IsStruct || type.IsSizedArray
		}
		
		static mixin DoInclude(ValueView val, BonSerializeFlags flags)
		{
			flags.HasFlag(.IncludeDefault) || DoAlwaysInclude!(val.type) || !ValueDataIsZero!(val)
		}

		static mixin DoTypeOneLine(Type type, BonSerializeFlags flags)
		{
			(type.IsPrimitive || (type.IsTypedPrimitive && (!flags.HasFlag(.Verbose) || !type.IsEnum)))
		}

		// These two are for integrated use!
		[Inline]
		public static int Start(BonWriter writer)
		{
			writer.Start();
			return writer.outStr.Length;
		}
		
		[Inline]
		public static void End(BonWriter writer, int lengthReturnedFromStartCall)
		{
			if (writer.outStr.Length == lengthReturnedFromStartCall)
				Irrelevant(writer);

			writer.End();
		}

		public static void Entry(BonWriter writer, ValueView val, BonEnvironment env)
		{
			let startLen = Start(writer);

			if (DoInclude!(val, env.serializeFlags))
				Value(writer, val, env);
			
			End(writer, startLen);
		}

		public static void Value(BonWriter writer, ValueView val, BonEnvironment env, SerializeValueState state = default)
		{
			let valType = val.type;

			// Make sure that doOneLineVal is only passed when valid
			Debug.Assert(!state.doOneLine || DoTypeOneLine!(valType, env.serializeFlags));

			writer.EntryStart(state.doOneLine);

			if (valType.IsPrimitive)
			{
				if (valType.IsInteger)
					Integer(valType, writer, val);
				else if (valType.IsFloatingPoint)
					Float(valType, writer, val);
				else if (valType.IsChar)
					Char(valType, writer, val);
				else if (valType == typeof(bool))
					Bool(writer, val, env.serializeFlags);
				else Debug.FatalError(); // Should be unreachable
			}
			else if (valType.IsTypedPrimitive)
			{
				// Is used to change what will be printed if the enum has a remainder
				// to be printed as a literal
				int64 enumRemainderVal = 0;
				var printVal = val;

				bool doPrintLiteral = true;
				if (valType.IsEnum && env.serializeFlags.HasFlag(.Verbose))
				{
					doPrintLiteral = false;

					int64 valueData = 0;
					Span<uint8>((uint8*)val.dataPtr, valType.Size).CopyTo(Span<uint8>((uint8*)&valueData, valType.Size));

					bool found = false;
					for (var field in valType.GetFields())
					{
						if (field.[Friend]mFieldData.mFlags.HasFlag(.EnumCase) &&
							*(int64*)&field.[Friend]mFieldData.[Friend]mData == valueData)
						{
							writer.Enum(field.Name);
							found = true;
							break;
						}
					}

					if (!found)
					{
						// There is no exact named value here, but maybe multiple!

						// We only try once, but that's better than none. If you were
						// to have this enum { A = 0b0011, B = 0b0111, C = 0b1100 }
						// and run this on 0b1111, this algorithm would fail to
						// identify .A | .C, but rather .B | 0b1000 because it takes
						// the largest match first and never looks back if it doesn't
						// work out. The easiest way to make something more complicated
						// work would probably be recursion... maybe in the future
						enumRemainderVal = valueData;
						String bestValName = scope .();
						bool foundAny = false;
						while (enumRemainderVal != 0)
						{
							// Go through all values and find best match in therms of bits
							int64 bestVal = 0;
							var bestValBits = 0;
							for (var field in valType.GetFields())
							{
								if (field.[Friend]mFieldData.mFlags.HasFlag(.EnumCase))
								{
									let fieldVal = *(int64*)&field.[Friend]mFieldData.[Friend]mData;

									if (fieldVal == 0 || (fieldVal & ~enumRemainderVal) != 0)
										continue; // fieldVal contains bits that valueLeft doesn't have

									var bits = 0;
									for (let i < sizeof(int64) * 8)
										if (((fieldVal >> i) & 0b1) != 0)
											bits++;

									if (bits > bestValBits)
									{
										bestVal = fieldVal;
										bestValName.Set(field.Name);
										bestValBits = bits;
									}
								}
							}

							if (bestValBits > 0)
							{
								enumRemainderVal &= ~bestVal; // Remove all bits it shares with this
								writer.Enum(bestValName);
								foundAny = true;
							}
							else
							{
								if (foundAny)
									writer.EnumAdd();

								// Print remainder literal
								doPrintLiteral = true;
								printVal = .(val.type, &enumRemainderVal);

								break;
							}

							if (enumRemainderVal == 0)
								break;
						}
					}
				}

				// Print on non-enum types, and if the enum need to append the leftover value as literal
				// or in any case if we're not printing verbose
				if (doPrintLiteral)
				{
					if (valType.UnderlyingType.IsInteger)
						Integer(valType.UnderlyingType, writer, printVal);
					else if (valType.UnderlyingType.IsFloatingPoint)
						Float(valType.UnderlyingType, writer, printVal);
					else if (valType.UnderlyingType.IsChar)
						Char(valType.UnderlyingType, writer, printVal);
					else if (valType.UnderlyingType == typeof(bool))
						Bool(writer, printVal, env.serializeFlags);
					else Debug.FatalError(); // Should be unreachable
				}
			}
			else if (valType.IsStruct)
			{
				if (valType == typeof(StringView))
				{
					let view = *(StringView*)val.dataPtr;

					if (view.Ptr == null)
						writer.Null();
					else writer.String(view);
				}
				else if (valType.IsEnum && valType.IsUnion)
				{
					let payloadVal = GetPayloadValueFromEnumUnion(val, let caseName, ?);
					if (payloadVal != default)
					{
						writer.Enum(caseName);
						Struct(writer, payloadVal, env);
					}
					else
					{
						writer.outStr.Append('?');
						if (env.serializeFlags.HasFlag(.Verbose) && !ValueDataIsZero!(val))
						{
							if (valType.FieldCount <= 2) // Always has two fields $discriminator & $payload
								writer.outStr.Append(scope $"/* No reflection data for {valType}. Add [BonTarget] or force it */");
							else writer.outStr.Append("/* Enum has corrupted value */");
						}
					}
				}
				else if (GetCustomHandler(valType, env, let func))
					func(writer, val, env, state);
				else
				{
					if (valType.IsUnion && env.serializeFlags.HasFlag(.Verbose))
						writer.outStr.Append("/* Union struct! Fields influence each other */");

					Struct(writer, val, env);
				}
			}
			else if (valType.IsSizedArray)
			{
				let t = (SizedArrayType)valType;
				let count = t.ElementCount;

				// Since this is a fixed-size array, this info is not necessary to
				// deserialize in any case. But it's nice for manual editing to know how
				// much the array can hold
				if (env.serializeFlags.HasFlag(.Verbose))
					writer.Sizer((.)count, true);

				Array(writer, t.UnderlyingType, val.dataPtr, count, env, state.arrayKeepUnlessSet);
			}
			else if (TypeHoldsObject!(valType))
			{
				if (*(void**)val.dataPtr == null)
					writer.Null();
				else
				{
					// We may modify type with polytype for further operations
					var val;

					let polyType = (*(Object*)val.dataPtr).GetType();
					if (polyType != valType)
					{
						Debug.Assert(!polyType.IsObject || polyType.IsSubtypeOf(valType) || (valType.IsInterface && polyType.HasInterface(valType)));

						// Change type of pointer to actual type
						val.type = polyType;

						Type(writer, polyType);
					}
					else Debug.Assert(!valType.IsInterface);

					if (!polyType.IsObject)
					{
						// Throw together the pointer to the box payload
						// in the corlib approved way. (See Variant.CreateFromBoxed)
						let boxType = (*(Object*)val.dataPtr).[Friend]RawGetType();
						let boxedPtr = (uint8*)*(void**)val.dataPtr + boxType.[Friend]mMemberDataOffset;

						Debug.Assert(!polyType.IsObject);

						// polyType already is the type in the box
						Value(writer, ValueView(polyType, boxedPtr), env);

						// Don't call EndEntry twice
						return;
					}
					else if (polyType.IsArray)
					{
						Debug.Assert(polyType != typeof(Array) && polyType is ArrayType);

						let t = polyType as ArrayType;
						
						Debug.Assert(t.GetField("mFirstElement") case .Ok, CompNoReflectionError!("array type", "Array1<T>"));

						let arrType = t.GetGenericArg(0); // T
						var arrPtr = GetValFieldPtr!(val, "mFirstElement"); // T*
						var count = GetValField!<int_arsize>(val, "mLength");

						bool includeAllValues = state.arrayKeepUnlessSet;
						switch (t.UnspecializedType)
						{
						case typeof(Array1<>):
							if (!includeAllValues && !Serialize.IsArrayFilled(arrType, arrPtr, count, env))
								writer.Sizer((.)count);
							Array(writer, arrType, arrPtr, count, env, includeAllValues);

						case typeof(Array2<>):
							let count1 = GetValField!<int_cosize>(val, "mLength1");
							count /= count1;
							writer.MultiSizer((.)count,(.)count1);

							MultiDimensionalArray(writer, arrType, arrPtr, env, includeAllValues, count, count1);

						case typeof(Array3<>):
							let count2 = GetValField!<int_cosize>(val, "mLength2");
							let count1 = GetValField!<int_cosize>(val, "mLength1");
							count /= (count1 * count2);
							writer.MultiSizer((.)count,(.)count1,(.)count2);

							MultiDimensionalArray(writer, arrType, arrPtr, env, includeAllValues, count, count1, count2);

						case typeof(Array4<>):
							let count1 = GetValField!<int_cosize>(val, "mLength1");
							let count2 = GetValField!<int_cosize>(val, "mLength2");
							let count3 = GetValField!<int_cosize>(val, "mLength3");
							count /= (count1 * count2 * count3);
							writer.MultiSizer((.)count,(.)count1,(.)count2,(.)count3);

							MultiDimensionalArray(writer, arrType, arrPtr, env, includeAllValues, count, count1, count2, count3);

						default:
							Debug.FatalError();
						}
					}
					else if (GetCustomHandler(polyType, env, let func))
						func(writer, val, env, state);
					else Class(writer, val, env);
				}
			}
			else if (valType.IsPointer)
			{
				if (env.serializeFlags.HasFlag(.Verbose))
					writer.outStr.Append("/* Cannot handle pointer values. Put [BonIgnore] on this field */");
			}
			else
			{
				writer.outStr.Append("/* Unhandled. Please report this! */");
				Debug.FatalError();
			}

			writer.EntryEnd(state.doOneLine);
		}

		static bool GetCustomHandler(Type type, BonEnvironment env, out HandleSerializeFunc func)
		{
			if (env.typeHandlers.TryGetValue(type, let val) && val.serialize != null)
			{
				func = val.serialize;
				return true;
			}
			else if (type is SpecializedGenericType && env.typeHandlers.TryGetValue(((SpecializedGenericType)type).UnspecializedType, let gVal)
				&& gVal.serialize != null)
			{
				func = gVal.serialize;
				return true;
			}
			func = null;
			return false;
		}

		public static void Class(BonWriter writer, ValueView classVal, BonEnvironment env)
		{
			let classType = classVal.type;

			Debug.Assert(classType.IsObject);

			Struct(writer, ValueView(classType, *(void**)classVal.dataPtr), env);
		}

		static mixin GetStateFromValueField(FieldInfo fieldInfo)
		{
			SerializeValueState state = default;
			if (fieldInfo.HasCustomAttribute<BonArrayKeepUnlessSetAttribute>())
				state.arrayKeepUnlessSet = true;
			state
		}

		public static void Struct(BonWriter writer, ValueView structVal, BonEnvironment env)
		{
			let structType = structVal.type;
			let flags = env.serializeFlags;

			bool hasUnnamedMembers = false, membersKeepUnlessSet = structType.HasCustomAttribute<BonKeepMembersUnlessSetAttribute>();
			if (structType.FieldCount > 0)
			{
				using (writer.ObjectBlock())
				{
					for (let f in structType.GetFields(.Instance))
					{
						if ((flags & .IgnorePermissions) != .IgnorePermissions
							&& (f.GetCustomAttribute<BonIgnoreAttribute>() case .Ok // check hidden
							|| (!flags.HasFlag(.IncludeNonPublic) && (f.[Friend]mFieldData.mFlags & .Public == 0) // check protection level
							&& f.GetCustomAttribute<BonIncludeAttribute>() case .Err))) // check if we still include it anyway)
							continue;

						var val = ValueView(f.FieldType, ((uint8*)structVal.dataPtr) + f.MemberOffset);

						if (!membersKeepUnlessSet && !DoInclude!(val, flags) && !f.HasCustomAttribute<BonKeepUnlessSetAttribute>())
							continue;

						if (flags.HasFlag(.Verbose) && uint64.Parse(f.Name) case .Ok)
							hasUnnamedMembers = true;

						writer.Identifier(f.Name);
						Value(writer, val, env, GetStateFromValueField!(f));
					}
				}
			}
			else writer.outStr.Append("{}");

			if (env.serializeFlags.HasFlag(.Verbose))
			{
				// Just add this as a comment in case anyone wonders...
				if (!ValueDataIsZero!(structVal) && structType.FieldCount == 0)
					writer.outStr.Append(scope $"/* No reflection data for {structType}. Add [BonTarget] or force it */");
				else if (hasUnnamedMembers)
					writer.outStr.Append("/* Type has unnamed members */");
			}
		}

		public static bool IsArrayFilled(Type arrType, void* arrPtr, int64 count, BonEnvironment env)
		{
			if (DoInclude!(ValueView(arrType, (uint8*)arrPtr + arrType.Stride * (count - 1)), env.serializeFlags))
				return true;
			return false;
		}

		public static void Array(BonWriter writer, Type arrType, void* arrPtr, int64 count, BonEnvironment env, bool includeAllValues = false)
		{
			SerializeValueState state = .{
				doOneLine = DoTypeOneLine!(arrType, env.serializeFlags)
			};
			using (writer.ArrayBlock(state.doOneLine))
			{
				if (count > 0)
				{
					var includeCount = count;
					if (!includeAllValues && !env.serializeFlags.HasFlag(.IncludeDefault) && !DoAlwaysInclude!(arrType)) // DoInclude! would return true on anything anyway
					{
						var ptr = (uint8*)arrPtr + arrType.Stride * (count - 1);
						for (var i = count - 1; i >= 0; i--)
						{
							// If this gets included, we'll have to include everything until here!
							if (DoInclude!(ValueView(arrType, ptr), env.serializeFlags))
							{
								includeCount = i + 1;
								break;
							}

							ptr -= arrType.Stride;
						}
					}

					var ptr = (uint8*)arrPtr;
					for (let i < includeCount)
					{
						var arrVal = ValueView(arrType, ptr);
						if (includeAllValues || DoInclude!(arrVal, env.serializeFlags))
							Value(writer, arrVal, env, state);
						else Irrelevant(writer, state.doOneLine);

						ptr += arrType.Stride;
					}
				}
			}
		}

		public static void MultiDimensionalArray(BonWriter writer, Type arrType, void* arrPtr, BonEnvironment env, bool includeAllValues = false, params int64[] counts)
		{
			Debug.Assert(counts.Count > 1); // Must be multi-dimensional!

			let count = counts[0];
			var stride = counts[1];
			if (counts.Count > 2)
				for (let i < counts.Count - 2)
					stride *= counts[i + 2];
			stride *= arrType.Stride;

			using (writer.ArrayBlock())
			{
				if (count > 0)
				{
					var includeCount = count;
					if (!includeAllValues && !env.serializeFlags.HasFlag(.IncludeDefault) && !DoAlwaysInclude!(arrType))
					{
						var ptr = (uint8*)arrPtr + stride * (count - 1);
						DEFCHECK:for (var i = count - 1; i >= 0; i--)
						{
							// If this gets included, we'll have to include everything until here!
							for (var j < stride)
								if (ptr[j] != 0)
									break DEFCHECK;

							includeCount = i + 1;
							ptr -= stride;
						}
					}

					var ptr = (uint8*)arrPtr;
					for (let i < includeCount)
					{
						bool isZero = true;
						for (var j < stride)
							if (ptr[j] != 0)
							{
								isZero = false;
								break;
							}

						if (!isZero || includeAllValues || env.serializeFlags.HasFlag(.IncludeDefault) || DoAlwaysInclude!(arrType))
						{
							let inner = counts.Count - 1;
							if (inner > 1)
							{
								int64[] innerCounts = scope .[inner];
								for (let j < inner)
									innerCounts[j] = counts[j + 1];

								MultiDimensionalArray(writer, arrType, ptr, env, includeAllValues, params innerCounts);
							}
							else Array(writer, arrType, ptr, counts[1], env, includeAllValues);

							writer.EntryEnd();
						}	
						else Irrelevant(writer);

						ptr += stride;
					}
				}
			}
		}

		public static void GetPolyTypeName(Type type, String into)
		{
			let res = type.GetCustomAttribute<BonPolyNameAttribute>();
			if (res case .Ok(let attr))
			{
				Debug.Assert(attr.name != null);
				into.Append(attr.name);
			}
			else type.GetFullName(.. into);
		}

		[Inline]
		public static void Type(BonWriter writer, Type type)
		{
			writer.EntryStart();
			writer.Type(GetPolyTypeName(type, .. scope .(256)));
		}

		[Inline]
		public static void Irrelevant(BonWriter writer, bool doOneLine = false)
		{
			writer.EntryStart(doOneLine);
			writer.IrrelevantEntry();
			writer.EntryEnd(doOneLine);
		}

		static mixin AsThingToString<T>(BonWriter writer, ValueView val)
		{
			T thing = *(T*)val.dataPtr;
			thing.ToString(writer.outStr);
		}

		[Inline]
		static void Integer(Type type, BonWriter writer, ValueView val)
		{
			switch (type)
			{
			case typeof(int8): AsThingToString!<int8>(writer, val);
			case typeof(int16): AsThingToString!<int16>(writer, val);
			case typeof(int32): AsThingToString!<int32>(writer, val);
			case typeof(int64): AsThingToString!<int64>(writer, val);
			case typeof(int): AsThingToString!<int>(writer, val);

			case typeof(uint8): AsThingToString!<uint8>(writer, val);
			case typeof(uint16): AsThingToString!<uint16>(writer, val);
			case typeof(uint32): AsThingToString!<uint32>(writer, val);
			case typeof(uint64): AsThingToString!<uint64>(writer, val);
			case typeof(uint): AsThingToString!<uint>(writer, val);

			default: Debug.FatalError(); // Should be unreachable
			}
		}

		[Inline]
		static void Char(Type type, BonWriter writer, ValueView val)
		{
			char32 char = 0;
			switch (type)
			{
			case typeof(char8): char = (.)*(char8*)val.dataPtr;
			case typeof(char16): char = (.)*(char16*)val.dataPtr;
			case typeof(char32): char = *(char32*)val.dataPtr;
			}
			writer.Char(char);
		}

		[Inline]
		static void Float(Type type, BonWriter writer, ValueView val)
		{
			switch (type)
			{
			case typeof(float):
				float thing = *(float*)val.dataPtr;
				thing.ToString(writer.outStr, "R", null); // Produce a string we can recreate... MS says this should be G9 when supported
			case typeof(double):
				double thing = *(double*)val.dataPtr;
				thing.ToString(writer.outStr, "R", null); // Produce a string we can recreate... MS says this should be G17 when supported

			default: Debug.FatalError(); // Should be unreachable
			}
		}

		[Inline]
		static void Bool(BonWriter writer, ValueView val, BonSerializeFlags flags)
		{
			bool boolean = *(bool*)val.dataPtr;
			if (flags.HasFlag(.Verbose))
				writer.Bool(boolean);
			else (boolean ? 1 : 0).ToString(writer.outStr);
		}

		internal static ValueView GetPayloadValueFromEnumUnion(ValueView enumVal, out StringView caseName, out uint64 caseIndex)
		{
			// Enum union in memory:
			// {<payload>|<discriminator>}

			bool foundCase = false;
			uint64 unionCaseIndex = 0;
			uint64 currCaseIndex = 0;
			for (var enumField in enumVal.type.GetFields())
			{
				if (enumField.[Friend]mFieldData.mFlags.HasFlag(.EnumDiscriminator))
				{
					let discrType = enumField.FieldType;
					var discrVal = ValueView(discrType, (uint8*)enumVal.dataPtr + enumField.[Friend]mFieldData.mData);
					Debug.Assert(discrType.IsInteger);

					mixin GetVal<T>() where T : var
					{
						T thing = *(T*)discrVal.dataPtr;
						unionCaseIndex = (uint64)thing;
					}

					switch (discrType)
					{
					case typeof(int8): GetVal!<int8>();
					case typeof(int16): GetVal!<int16>();
					case typeof(int32): GetVal!<int32>();
					case typeof(int64): GetVal!<int64>();
					case typeof(int): GetVal!<int>();

					case typeof(uint8): GetVal!<uint8>();
					case typeof(uint16): GetVal!<uint16>();
					case typeof(uint32): GetVal!<uint32>();
					case typeof(uint64): GetVal!<uint64>();
					case typeof(uint): GetVal!<uint>();

					default: Debug.FatalError(); // Should be unreachable
					}

					foundCase = true;
				}
				else if (enumField.[Friend]mFieldData.mFlags.HasFlag(.EnumCase)) // Filter through unioncaseIndex
				{
					Debug.Assert(foundCase);

					// Skip enum cases until we get to the selected one
					if (currCaseIndex != unionCaseIndex)
					{
						currCaseIndex++;
						continue;
					}

					caseIndex = currCaseIndex;
					caseName = enumField.Name;
					return ValueView(enumField.FieldType, enumVal.dataPtr);
				}
			}
			caseIndex = 0;
			caseName = default;
			return default;
		}
	}
}