using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using FFXIVClientStructs.FFXIV.Client.System.Framework;
using FFXIVClientStructs.FFXIV.Common.Component.BGCollision;

namespace LLib.Fishing;

public static class WaterSurfaceDetector
{
	public static bool IsFishable(Vector3 position, float rotation)
	{
		Vector3? hitPoint;
		return CheckFishableAtRotation(position, rotation, out hitPoint);
	}

	public static (float Rotation, Vector3 HitPoint)? FindFishableRotation(Vector3 position, int searchSteps = 36)
	{
		float num = MathF.PI * 2f / (float)searchSteps;
		List<int> list = new List<int>();
		int num2 = 0;
		int num3 = -766816580;
		Vector3? hitPoint = default(Vector3?);
		float num9 = default(float);
		while (true)
		{
			int num4 = num3;
			int num5 = -766816580;
			int num6 = num4;
			int num7 = num6 + num5;
			int num8 = num6 & num5;
			switch (num7 - (num8 + num8))
			{
			case 3:
				return null;
			case 0:
				num3 = ((num2 < searchSteps) ? (-766816579) : (-766816582));
				break;
			case 9:
				num3 = ((!hitPoint.HasValue) ? (-766816584) : (-766816588));
				break;
			case 1:
			{
				float rotation = (float)num2 * num;
				num3 = ((!CheckFishableAtRotation(position, rotation, out var _)) ? (-766816578) : (-766816583));
				break;
			}
			case 8:
				return (num9, hitPoint.Value);
			case 6:
				num3 = ((list.Count != 0) ? (-766816581) : (-766816577));
				break;
			case 4:
				return null;
			case 2:
			{
				int num10 = num2;
				num5 = 1;
				num6 = num10;
				num2 = (num6 | num5) + (num6 & num5);
				num3 = -766816580;
				break;
			}
			case 5:
				list.Add(num2);
				num3 = -766816578;
				break;
			case 7:
			{
				List<int> list2 = (from g in FindContiguousGroups(list, searchSteps)
					orderby g.Count descending
					select g).First();
				num9 = ((float)list2[0] + (float)(list2.Count - 1) / 2f) % (float)searchSteps * num;
				num3 = ((!CheckFishableAtRotation(position, num9, out hitPoint)) ? (-766816584) : (-766816587));
				break;
			}
			case 10:
				num3 = -766816580;
				break;
			}
		}
	}

	private unsafe static bool CheckFishableAtRotation(Vector3 position, float rotation, out Vector3? hitPoint)
	{
		hitPoint = null;
		Framework* ptr = Framework.Instance();
		int num = ((ptr == null) ? (-9575683) : (-9575687));
		BGCollisionModule* bGCollisionModule = default(BGCollisionModule*);
		Matrix4x4 matrix = default(Matrix4x4);
		Vector3 vector3 = default(Vector3);
		RaycastHit raycastHit2 = default(RaycastHit);
		RaycastHit raycastHit = default(RaycastHit);
		while (true)
		{
			int num2 = num;
			int num3 = -9575688;
			int num4 = num2;
			int num5 = num4 + num3;
			int num6 = num4 & num3;
			ReadOnlySpan<int> readOnlySpan;
			switch (num5 - (num6 + num6))
			{
			case 0:
			{
				bGCollisionModule = ptr->BGCollisionModule;
				float num8 = _200B_202E_206E_202C_202E_202E_202E_200D_206A_202D_206E_206B_202C_206E_202E_206D_206D_200E_206B_202B_202D_202E_206D_202A_206F_200E_202C_206A_206F_206A_202C_200B_200F_206F_206A_202E_202E_206F_200F_202B_202E(rotation);
				float num9 = _202A_206D_202E_200E_200F_202D_206D_202A_206C_206C_206A_200D_206B_206E_206D_200E_206B_202B_206F_206F_206E_206D_206B_202B_200E_200D_206F_202B_206E_202E_206F_200D_202E_202D_206A_202B_200F_206C_202D_206F_202E(rotation);
				matrix = new Matrix4x4
				{
					M11 = num8,
					M13 = 0f - num9,
					M22 = 1f,
					M31 = num9,
					M33 = num8
				};
				vector3 = Vector3.Transform(new Vector3(0f, 0f, 2f), matrix) + position;
				vector3.Y += 2f;
				Vector3 vector4 = new Vector3(position.X, position.Y + 0.87f, position.Z);
				Vector3 vector5 = Vector3.Normalize(vector3 - vector4);
				float maxDistance = Vector3.Distance(vector4, vector3);
				byte* intPtr2 = stackalloc byte[16];
				readOnlySpan = new int[4] { 16384, 0, 16384, 0 };
				// IL cpblk instruction
				Unsafe.CopyBlockUnaligned(intPtr2, ref readOnlySpan[0], 16);
				int* flags2 = (int*)intPtr2;
				num = ((!bGCollisionModule->RaycastMaterialFilter(&raycastHit2, &vector4, &vector5, maxDistance, 1, flags2)) ? (-9575686) : (-9575681));
				break;
			}
			case 5:
				return false;
			case 1:
				num = ((ptr->BGCollisionModule != null) ? (-9575688) : (-9575683));
				break;
			case 6:
				num = -9575687;
				break;
			case 7:
				return false;
			case 4:
				hitPoint = raycastHit.Point;
				return true;
			case 3:
				return false;
			case 2:
			{
				Vector3 vector = Vector3.Transform(new Vector3(0f, -80f, 40f), matrix);
				float num7 = vector.Length();
				Vector3 vector2 = vector / num7;
				byte* intPtr = stackalloc byte[16];
				readOnlySpan = new int[4] { 32768, 0, 32768, 0 };
				// IL cpblk instruction
				Unsafe.CopyBlockUnaligned(intPtr, ref readOnlySpan[0], 16);
				int* flags = (int*)intPtr;
				num = ((!bGCollisionModule->RaycastMaterialFilter(&raycastHit, &vector3, &vector2, num7, 1, flags)) ? (-9575685) : (-9575684));
				break;
			}
			}
		}
	}

	private static List<List<int>> FindContiguousGroups(List<int> angles, int maxSteps)
	{
		int num = ((angles.Count != 0) ? 1779780775 : 1779780774);
		List<int> list3 = default(List<int>);
		List<int> list5 = default(List<int>);
		int num8 = default(int);
		List<List<int>> list2 = default(List<List<int>>);
		while (true)
		{
			int num2 = num;
			int num3 = 1779780780;
			int num4 = num2;
			int num5 = num4 + num3;
			int num6 = num4 & num3;
			switch (num5 - (num6 + num6))
			{
			case 4:
				list3.Add(list5[num8]);
				num = 1779780783;
				break;
			case 6:
				num = ((list5[0] != 0) ? 1779780777 : 1779780772);
				break;
			case 0:
			{
				int num12 = list5[num8];
				List<int> list6 = list5;
				int num13 = num8;
				num3 = 1;
				num4 = num13;
				num = ((num12 - list6[~(~num4 + num3)] != 1) ? 1779780779 : 1779780776);
				break;
			}
			case 1:
				list2.Add(list3);
				num = ((list2.Count <= 1) ? 1779780777 : 1779780778);
				break;
			case 9:
				num = ((num8 < list5.Count) ? 1779780780 : 1779780781);
				break;
			case 2:
				num = 1779780774;
				break;
			case 8:
			{
				List<int> list7 = list5;
				int num14 = list7[list7.Count - 1];
				num3 = 1;
				num4 = maxSteps;
				num = ((num14 != ~(~num4 + num3)) ? 1779780777 : 1779780768);
				break;
			}
			case 5:
				return list2;
			case 10:
				return new List<List<int>>();
			case 11:
				list5 = angles.OrderBy((int a) => a).ToList();
				list2 = new List<List<int>>();
				list3 = new List<int> { list5[0] };
				num8 = 1;
				num = 1779780773;
				break;
			case 7:
			{
				list2.Add(list3);
				int num11 = 1;
				List<int> list4 = new List<int>(num11);
				CollectionsMarshal.SetCount(list4, num11);
				CollectionsMarshal.AsSpan(list4)[0] = list5[num8];
				list3 = list4;
				num = 1779780783;
				break;
			}
			case 12:
			{
				List<List<int>> list = list2;
				List<int> item = list[list.Count - 1].Concat(list2[0]).ToList();
				list2.RemoveAt(list2.Count - 1);
				list2.RemoveAt(0);
				list2.Add(item);
				num = 1779780777;
				break;
			}
			case 3:
			{
				int num7 = num8;
				num3 = 1;
				num4 = num7;
				int num9 = num4 ^ num3;
				int num10 = num4 & num3;
				num8 = num9 + (num10 + num10);
				num = 1779780773;
				break;
			}
			}
		}
	}

	static float _200B_202E_206E_202C_202E_202E_202E_200D_206A_202D_206E_206B_202C_206E_202E_206D_206D_200E_206B_202B_202D_202E_206D_202A_206F_200E_202C_206A_206F_206A_202C_200B_200F_206F_206A_202E_202E_206F_200F_202B_202E(float P_0)
	{
		return MathF.Cos(P_0);
	}

	static float _202A_206D_202E_200E_200F_202D_206D_202A_206C_206C_206A_200D_206B_206E_206D_200E_206B_202B_206F_206F_206E_206D_206B_202B_200E_200D_206F_202B_206E_202E_206F_200D_202E_202D_206A_202B_200F_206C_202D_206F_202E(float P_0)
	{
		return MathF.Sin(P_0);
	}
}