--!optimize 2
--!native
--!strict

type HumanoidRootPart = BasePart
type Character        = Model
type PromptCallback   = (Player: Player, HumanoidRootPart: HumanoidRootPart, Character: Character) -> ()
type PromptSignal     = RBXScriptSignal<Player>
type PromptSignalName = "Triggered" | "TriggerEnded"

type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
type Impl_Constructor = {
	__index: Impl_Constructor,
	constructor: Constructor_Fun,
	--Class functions
	Triggered:    (self: ClassConstructor, Callback: PromptCallback) -> PromptSignal?,
	TriggerEnded: (self: ClassConstructor, Callback: PromptCallback) -> PromptSignal?,
	Enable:       (self: ClassConstructor) -> (),
	Disable:      (self: ClassConstructor) -> ()
}

type Constructor_Fun = (Prompt: ProximityPrompt, Instance: Instance, Enabled: boolean?) -> ClassConstructor
type Constructor_Return_Props = {
	Prompt: ProximityPrompt,
	Instance: Instance,
	
	__TriggeredCallback: PromptCallback?,
	__TriggerEndedCallback: PromptCallback?,
	__PromptConnections: {
		Triggered: RBXScriptConnection?,
		TriggerEnded: RBXScriptConnection?
	},
}

local Prompts = {} :: Impl_Constructor
Prompts.__index = Prompts

function Prompts.constructor(Prompt, Instance)
	return setmetatable({
		Prompt   = Prompt,
		Instance = Instance,

		__PromptConnections = {
			Triggered = nil,
			TriggerEnded = nil
		}
	}, Prompts)
end

local function DistanceCheck(self: ClassConstructor, Player: Player)
	local PlayerCharacter = Player.Character
	local Root            = PlayerCharacter and PlayerCharacter:FindFirstChild("HumanoidRootPart") :: HumanoidRootPart?

	if Root then
		if (Root.Position-(self.Instance :: BasePart).Position).Magnitude<=self.Prompt.MaxActivationDistance+1 then
			(self.__TriggeredCallback :: PromptCallback)(Player, Root, PlayerCharacter :: Character)
		else
			warn(`{Player.Name}, {Player.UserId} activated a prompt without being in range of MaxActivationDistance.`)
		end
	end
end

local EnumPromptSignals = {
	["Triggered"] = DistanceCheck,
	["TriggerEnded"] = DistanceCheck
}

--This is overly automated lol
local function NewPromptConnection(self: ClassConstructor, PromptSignal: PromptSignal, PromptSignalName: PromptSignalName)
	local Signal: PromptSignal?

	if self.Prompt then
		if self.Instance then
			if self.__PromptConnections[PromptSignalName] and self.__PromptConnections[PromptSignalName].Connected then
				warn("asd")
				self.__PromptConnections[PromptSignalName]:Disconnect()
			end

			self.__PromptConnections[PromptSignalName] = PromptSignal:Connect(function(Player: Player)
				EnumPromptSignals[PromptSignalName](self, Player)
			end)
			Signal = self.__PromptConnections[PromptSignalName]
		else
			warn("Button Hook Error! Inst is missing", debug.traceback())
		end
	else
		warn("Button Hook Error! Prompt is missing", debug.traceback())
	end

	return Signal
end

function Prompts:Triggered(Callback)
	self.__TriggeredCallback = Callback

	--These dont make sense...
	return NewPromptConnection(self, self.Prompt.Triggered, "Triggered")
end

function Prompts:TriggerEnded(Callback)
	self.__TriggerEndedCallback = Callback

	return NewPromptConnection(self, self.Prompt.TriggerEnded, "TriggerEnded")
end

function Prompts:Disable()
	if self.__PromptConnections.Triggered and self.__PromptConnections.Triggered.Connected then
		self.__PromptConnections.Triggered:Disconnect()
	end
	if self.__PromptConnections.TriggerEnded and self.__PromptConnections.TriggerEnded.Connected then
		self.__PromptConnections.TriggerEnded:Disconnect()
	end

	self.Prompt.Enabled = false
end

function Prompts:Enable()
	self.Prompt.Enabled = true
	
	if self.__TriggeredCallback and not (self.__PromptConnections.Triggered and self.__PromptConnections.Triggered.Connected) then
		self:Triggered(self.__TriggeredCallback)
	end
	if self.__TriggerEndedCallback and not (self.__PromptConnections.TriggerEnded and self.__PromptConnections.TriggerEnded.Connected)  then
		self:TriggerEnded(self.__TriggerEndedCallback)
	end
end

return Prompts