using Dalamud.Game.ClientState.Objects.Types;
using Questionable.Functions;
using Questionable.Model.Questing;

namespace Questionable.Controller.CombatModules;

internal sealed class Mount128Module : ICombatModule
{
	public const ushort MountId = 128;

	private readonly EAction[] _actions = new EAction[2]
	{
		EAction.MagitekThunder,
		EAction.MagitekPulse
	};

	private readonly GameFunctions _gameFunctions;

	public Mount128Module(GameFunctions gameFunctions)
	{
		_gameFunctions = gameFunctions;
	}

	public bool CanHandleFight(CombatController.CombatData combatData)
	{
		ushort? mountId = _gameFunctions.GetMountId();
		int num = (mountId.HasValue ? 1315978543 : 1315978542);
		int? obj;
		while (true)
		{
			int num2 = num;
			int num3 = 1315978543;
			int num4 = num2;
			switch ((num4 | num3) - (num4 & num3))
			{
			default:
				continue;
			case 2:
				goto IL_005c;
			case 0:
				obj = mountId.GetValueOrDefault();
				break;
			case 1:
				obj = null;
				break;
			}
			break;
			IL_005c:
			num = 1315978542;
		}
		return obj == 128;
	}

	bool ICombatModule.CanHandleFight(CombatController.CombatData combatData)
	{
		//ILSpy generated this explicit interface implementation from .override directive in CanHandleFight
		return this.CanHandleFight(combatData);
	}

	public bool Start(CombatController.CombatData combatData)
	{
		return true;
	}

	bool ICombatModule.Start(CombatController.CombatData combatData)
	{
		//ILSpy generated this explicit interface implementation from .override directive in Start
		return this.Start(combatData);
	}

	public bool Stop()
	{
		return true;
	}

	bool ICombatModule.Stop()
	{
		//ILSpy generated this explicit interface implementation from .override directive in Stop
		return this.Stop();
	}

	public void Update(IGameObject gameObject)
	{
		EAction[] actions = _actions;
		int num = 0;
		int num2 = -321000316;
		while (true)
		{
			int num3 = num2;
			int num4 = -321000313;
			int num5 = num3;
			switch ((num5 | num4) - (num5 & num4))
			{
			case 5:
				num2 = -321000316;
				break;
			case 4:
				return;
			case 0:
			{
				int num6 = num;
				num4 = 1;
				num5 = num6;
				int num7 = num5 ^ num4;
				int num8 = num5 & num4;
				num = num7 + (num8 + num8);
				num2 = -321000316;
				break;
			}
			case 2:
				return;
			case 1:
			{
				EAction action = actions[num];
				num2 = ((!_gameFunctions.UseAction(gameObject, action, checkCanUse: false)) ? (-321000313) : (-321000315));
				break;
			}
			case 3:
				num2 = ((num < actions.Length) ? (-321000314) : (-321000317));
				break;
			}
		}
	}

	void ICombatModule.Update(IGameObject gameObject)
	{
		//ILSpy generated this explicit interface implementation from .override directive in Update
		this.Update(gameObject);
	}

	public bool CanAttack(IBattleNpc target)
	{
		uint num = _200D_206E_206B_200C_200E_200F_200E_206A_200C_200E_202B_202A_206C_202B_206A_202B_200D_206F_200F_202D_200C_200E_206E_200D_200E_202A_200B_200B_206F_206F_202B_206D_202A_200E_202D_206F_206D_200F_202B_202E((IGameObject)target);
		int num2 = 7504;
		int num3 = (int)num;
		int num4 = (((uint)(~(~num3 + num2)) <= 1u) ? 2050510022 : 2050510023);
		bool result = default(bool);
		while (true)
		{
			int num5 = num4;
			num2 = 2050510022;
			num3 = num5;
			switch ((num3 | num2) - (num3 & num2))
			{
			case 2:
				return result;
			case 1:
				num4 = ((num != 14107) ? 2050510018 : 2050510022);
				break;
			case 3:
				num4 = 2050510023;
				break;
			case 0:
				result = true;
				num4 = 2050510020;
				break;
			case 4:
				result = false;
				num4 = 2050510020;
				break;
			}
		}
	}

	bool ICombatModule.CanAttack(IBattleNpc target)
	{
		//ILSpy generated this explicit interface implementation from .override directive in CanAttack
		return this.CanAttack(target);
	}

	static uint _200D_206E_206B_200C_200E_200F_200E_206A_200C_200E_202B_202A_206C_202B_206A_202B_200D_206F_200F_202D_200C_200E_206E_200D_200E_202A_200B_200B_206F_206F_202B_206D_202A_200E_202D_206F_206D_200F_202B_202E(IGameObject P_0)
	{
		return P_0.BaseId;
	}
}