local DrawSprite = DrawSprite
local DrawRect = DrawRect

local isHackActive = false
local isCallbackSent = false
local callbackFn

local activeNumberNode = 1
local activeCircleNode = 0

local generatedNumbers = {}

local targetVoltage = 0
local targetVoltageTable = {}

local resultVoltage = 0
local resultVoltageString = {0,0,0}

local occupiedCircleNodes = {}
local confirmedNodes = {} 

local countDownTime = 6
local isSuccess = nil

local circlNodeColor = {
	{250, 172, 54},
	{247, 49, 49},
	{58, 53, 212}
}

local resultTextColor = {
	{191, 191, 191},
	{88, 204, 102}
}
local resultAlpha = 255

local connectedNodeAlpha = {
	255,
	255,
	255
}

local iconName = {
	'Icons__x1',
	'Icons__x2',
	'Icons__x3',
	'Icons__x5',
	'Icons__x10',
	'Icons__x15'
}

local timerUI = {
	{0.383, 0.815, 0.0145, 0.05},
	{0.373, 0.815, 0.0145, 0.05},
	{0.363, 0.815, 0.0145, 0.05},
	{0.353, 0.815, 0.0145, 0.05},
	{0.343, 0.815, 0.0145, 0.05},
	{0.333, 0.815, 0.0145, 0.05},

}

local nodePaths = {

	['1'] = {
		['1'] = {
				['square1'] = {0.324, 0.307,0.006, 0.01},
				['square2'] = {0.658, 0.307,0.006, 0.01},
				
				['line'] = {0.49, 0.307, 0.33, 0.004} -- 1:1 line
		},
		
		['2'] = {
				['square1'] = {0.324, 0.307, 0.006, 0.01},
				['sqaure2'] = {0.49, 0.307,0.007, 0.0135},
				['square3'] = {0.49, 0.501, 0.007, 0.0128},
				['square4'] = {0.657, 0.501, 0.007, 0.0128},
				
				['line1'] = {0.407, 0.307, 0.16, 0.004}, -- line1
				['line2'] = {0.4905, 0.404, 0.002, 0.18}, -- line2
				['line3'] = {0.574, 0.501, 0.16, 0.004} -- line3
		},
		
		['3'] = {
			['square1'] = {0.324, 0.307,0.007, 0.0128, 250, 172, 54, 255},
			['square2'] = {0.397, 0.307,0.007, 0.0128, 250, 172, 54, 255},
			['square3'] = {0.397, 0.502,0.007, 0.0128, 250, 172, 54, 255},
			['square4'] = {0.49, 0.502,0.007, 0.0128, 250, 172, 54, 255},
			['square5'] = {0.49, 0.694,0.007, 0.0128, 250, 172, 54, 255},
			['square6'] = {0.657, 0.694,0.007, 0.0128, 250, 172, 54, 255},
			
			['line1'] = {0.36, 0.307, 0.07, 0.004, 250, 172, 54, 255}, --line1
			['line2'] = {0.3965, 0.404, 0.002, 0.182, 250, 172, 54, 255}, -- vertical line1
			
			['line3'] = {0.445, 0.502, 0.09, 0.004, 250, 172, 54, 255}, -- line2
			['line4'] = {0.4905, 0.598, 0.002, 0.182, 250, 172, 54, 255}, -- vertical line2
			
			['line5'] = {0.574, 0.694, 0.16, 0.004, 250, 172, 54, 255} -- line3
		}
	},
	
	['2'] = {
		['1'] = {
			['square1'] = {0.324, 0.5,0.006, 0.01},
			['square2'] = {0.46, 0.5,0.007, 0.01281},
			['square3'] = {0.46, 0.39,0.007, 0.01281},
			['square4'] = {0.551, 0.39,0.007, 0.01281},
			['square5'] = {0.551, 0.307,0.007, 0.01281},
			['square6'] = {0.658, 0.307,0.006, 0.01},
			
			['line1'] = {0.392, 0.5, 0.129, 0.0035},
			['line2'] = {0.46, 0.444, 0.003, 0.1}, -- vertical 1
			['line3'] = {0.508, 0.39, 0.09, 0.004},
			['line4'] = {0.508, 0.39, 0.09, 0.0025}, -- vertical 2
			['line5'] = {0.605, 0.307, 0.108, 0.004},
			['line6'] = {0.551, 0.35, 0.0025, 0.08} -- vertical 3
		},
		
		['2'] = {
			['square1'] = {0.324, 0.5,0.006, 0.01},
			['square2'] = {0.657, 0.5,0.006, 0.01},
			
			['line1'] = {0.49, 0.5, 0.33, 0.004} -- 2:2 line
		},
		
		['3'] = {
			['square1'] = {0.324, 0.5,0.006, 0.01},
			['square2'] = {0.429, 0.5,0.007, 0.01281},
			['square3'] = {0.429, 0.694,0.007, 0.01281},
			['square4'] = {0.657, 0.694,0.007, 0.01281},
			
			['line1'] = {0.376, 0.5, 0.1, 0.0035},
			['line2'] = {0.429, 0.6, 0.003, 0.2}, -- vertical 1
			['line3'] = {0.543, 0.694, 0.22, 0.0035}
		}
	},
	
	['3'] = {
		['1'] = {
			['square1'] = {0.324, 0.694,0.006, 0.01},
			['square2'] = {0.521, 0.694,0.007, 0.01281},
			['square3'] = {0.521, 0.61,0.007, 0.01281},
			['square4'] = {0.582, 0.61,0.007, 0.01281},
			['square5'] = {0.582, 0.3085,0.007, 0.01281},
			['square6'] = {0.6565, 0.307,0.007, 0.01281},
			
			['line1'] = {0.421, 0.694, 0.19, 0.0035},
			['line2'] = {0.521, 0.652, 0.00222, 0.074}, --vertical 2
			
			['line3'] = {0.55, 0.61, 0.06, 0.0035},
			['line4'] = {0.582, 0.46, 0.00222, 0.29}, --vertical 2
			
			['line5'] = {0.62, 0.307, 0.07, 0.0035}
		},
		
		['2'] = {
			['sqaure1'] = {0.324, 0.694,0.006, 0.01},
			['sqaure2'] = {0.521, 0.694,0.007, 0.01281},
			['sqaure3'] = {0.521, 0.61,0.007, 0.01281},
			['sqaure4'] = {0.582, 0.61,0.007, 0.01281},
			['sqaure5'] = {0.582, 0.5,0.007, 0.01281},
			['sqaure6'] = {0.6565, 0.5,0.007, 0.01281},
			
			['line1'] = {0.421, 0.694, 0.19, 0.0035},
			['line2'] = {0.521, 0.652, 0.00222, 0.074}, --vertical 2
			
			['line3'] = {0.55, 0.61, 0.06, 0.0035},
			['line4'] = {0.582, 0.55, 0.00222, 0.11}, --vertical 2
			
			['line5'] = {0.62, 0.5, 0.07, 0.0035}
		},
		
		['3'] = {
			['square1'] = {0.324, 0.694,0.006, 0.01},
			['square2'] = {0.6565, 0.694,0.007, 0.01281},
			
			['line1'] = {0.49, 0.694, 0.33, 0.0035} -- 3:3 line
		}
	}


}


-- Main game logic

local function shuffle(t) --Utility function
	local tbl = {}
	for i = 1, #t do
	  tbl[i] = t[i]
	end
	for i = #tbl, 2, -1 do
	  local j = math.random(i)
	  tbl[i], tbl[j] = tbl[j], tbl[i]
	end
	return tbl
end


local function getTableSize(t) --Utility function
	local count = 0
	for _, __ in pairs(t) do
		count = count + 1
	end
	return count
end


local function playSound(audioName,audioRef)
	PlaySoundFrontend(-1 , audioName,audioRef, true)
end


local function generateTargetVoltage()
	targetVoltage = 0
	for i=1,3 do
		generatedNumbers[i] = math.random(1,8)
	end

	for i=1,3 do
		targetVoltage = targetVoltage + (generatedNumbers[i] * iconValues[i])
	end
end


local function updateResultVoltage(volt)
	volt = volt or resultVoltage
	local resultVoltage = tostring(volt)
	
	if string.len(resultVoltage) < 3 then
		for i=1,(3 - string.len(resultVoltage)) do
			resultVoltage = '0' .. resultVoltage
		end
	end
	
	for i = 1,3 do
		resultVoltageString[i] = resultVoltage:sub(i, i)
	end
end

local function formatTargetVoltage()
	local voltageString = tostring(targetVoltage)
	
	if string.len(voltageString) < 3 then
		for i=1,(3 - string.len(voltageString)) do
			voltageString = '0' .. voltageString
		end
	end
	
	for i = 1,3 do
		targetVoltageTable[i] = voltageString:sub(i, i)
	end
end

-- Load audio and texture stuff

local requiredTxd = {'MPIsland_Voltage', 'MPIsland_Voltage_BG'}
local requiredAudioBank = 'DLC_HEI4\\DLC_HEI4_V_MG'
local requiredAudioBank2 = 'DLC_HEI4\\DLC_HEI4_FH_MG'

for i=1,#requiredTxd do
	RequestStreamedTextureDict(requiredTxd[i], false)
end

RequestScriptAudioBank(requiredAudioBank, false, -1)
RequestScriptAudioBank(requiredAudioBank2, false, -1)

CreateThread(function()


	for i=1,#requiredTxd do
		while not HasStreamedTextureDictLoaded(requiredTxd[i]) do
			Wait(10)
		end
	end
end)
local function drawRect(x, y, w, h, r, g, b, a )
	DrawRect(x,y,w,h,r,g,b,a)
end

local function drawSprite(txd, txName, screenX, screenY, width, height, head, red, green, blue, alpha)
	DrawSprite(txd, txName, screenX, screenY, width, height, head, red, green, blue, alpha)
end


function ButtonMessage(text)
    BeginTextCommandScaleformString("STRING")
    AddTextComponentScaleform(text)
    EndTextCommandScaleformString()
end

function Button(ControlButton)
    N_0xe83a3e3557a56640(ControlButton)
end

function setupScaleform(scaleform)
    local scaleform = RequestScaleformMovie(scaleform)
    while not HasScaleformMovieLoaded(scaleform) do
        Citizen.Wait(0)
    end
    PushScaleformMovieFunction(scaleform, "CLEAR_ALL")
    PopScaleformMovieFunctionVoid()
    
    PushScaleformMovieFunction(scaleform, "SET_CLEAR_SPACE")
    PushScaleformMovieFunctionParameterInt(200)
    PopScaleformMovieFunctionVoid()

    PushScaleformMovieFunction(scaleform, "SET_DATA_SLOT")
    PushScaleformMovieFunctionParameterInt(0)
    Button(GetControlInstructionalButton(2, 194, true))
    ButtonMessage("Abort Hack")
    PopScaleformMovieFunctionVoid()

    PushScaleformMovieFunction(scaleform, "SET_DATA_SLOT")
    PushScaleformMovieFunctionParameterInt(1)
    Button(GetControlInstructionalButton(2, 191, true))
    ButtonMessage("Confirm selection (Irrevertible)")
    PopScaleformMovieFunctionVoid()

    PushScaleformMovieFunction(scaleform, "SET_DATA_SLOT")
    PushScaleformMovieFunctionParameterInt(2)
    Button(GetControlInstructionalButton(2, 307, true))
	Button(GetControlInstructionalButton(2, 308, true))
	Button(GetControlInstructionalButton(2, 299, true))
	Button(GetControlInstructionalButton(2, 300, true))
	ButtonMessage("Select")
	PopScaleformMovieFunctionVoid()


    PushScaleformMovieFunction(scaleform, "DRAW_INSTRUCTIONAL_BUTTONS")
    PopScaleformMovieFunctionVoid()

    PushScaleformMovieFunction(scaleform, "SET_BACKGROUND_COLOUR")
    PushScaleformMovieFunctionParameterInt(0)
    PushScaleformMovieFunctionParameterInt(0)
    PushScaleformMovieFunctionParameterInt(0)
    PushScaleformMovieFunctionParameterInt(80)
    PopScaleformMovieFunctionVoid()

    return scaleform
end


AddEventHandler("ultra-voltlab", function(time, returnFn)

	--Reset previous data
	isCallbackSent = false
	occupiedCircleNodes = {}
	confirmedNodes = {} 
	activeNumberNode = 1
	activeCircleNode = 0
	countDownTime = 6

	callbackFn = returnFn
	local time = tonumber(time)
	timer = time
	
	if time < 10 or time > 60 then
		callbackFn(-1,'Entered time is out of range')
		isCallbackSent = true
		return
	end



	generateTargetVoltage() -- Generate random voltage target level
	formatTargetVoltage() -- Format target voltage to 3 digit string

	-- Ensure that generated target is within limits 
	while targetVoltage > 999 or targetVoltage <= 0 do
		Wait(10)
		generateTargetVoltage()
	end
	
	-- Randomize index to prevent repetative pattern generations
	generatedNumbers = shuffle(generatedNumbers)
	iconValues = shuffle(iconValues)
	iconName = shuffle(iconName)
	
	local iconValueLimit = 0
	for	i=1,3 do
		iconValueLimit = iconValueLimit + iconValues[i]
	end
	if iconValueLimit > 111 or iconValueLimit <= 0 then
		callbackFn(-1,'Icon values are out of range in config')
		isCallbackSent = true
		return
	end

	formatTargetVoltage()

	
	
	CreateThread(function()
		Wait(100)
		SendNUIMessage({
			type = 'intro'
		})
		playSound('Loading_Bink','DLC_H4_Voltage_Minigame_Sounds')
		isHackActive = true
		
		while isHackActive do 
			Wait(1)

			drawSprite(
				'MPIsland_Voltage_BG', 
				'PHONE_BACKGROUND', 
				0.50, 0.50, 1.0, 1.0, 0, 255, 255, 255, 255
			)				
			
			drawSprite(
				'MPIsland_Voltage_BG', 
				'target_text', 
				0.498, 0.12, 0.04, 0.014, 0,  231, 99, 99, 255
			)

			drawSprite(
				'MPIsland_Voltage_BG', 
				'result_text', 
				0.498, 0.88, 0.04, 0.014, 0,  88, 204, 102, 255
			)
							
			drawSprite(
				'MPIsland_Voltage', 
				'Phone_Icons', 
				0.95, 0.03, 0.08, 0.04, 0, 160, 160, 160, 255
			)
			
			
			-- Main interface
			drawSprite(
				'MPIsland_Voltage', 
				'MainInterface_BG', 
				0.5, 0.5, 0.5, 0.73, 0, 255, 255, 255, 255
			)


			-- Target voltage 
			drawSprite(
				'MPIsland_Voltage', 
				targetVoltageTable[1], 
				0.457, 0.185, 0.03, 0.09, 0, 231, 99, 99, 255
			)
			
			drawSprite(
				'MPIsland_Voltage', 
				targetVoltageTable[2], 
				0.497, 0.185	, 0.03, 0.09, 0, 231, 99, 99, 255
			)
			
			drawSprite(
				'MPIsland_Voltage', 
				targetVoltageTable[3], 
				0.539, 0.185	, 0.03, 0.09, 0, 231, 99, 99, 255
			)

			
			-- Left numbers
			
			drawSprite(
				'MPIsland_Voltage', 
				generatedNumbers[1], 
				0.29, 0.307, 0.03, 0.09, 0, 255, 255, 255, 255
			)
			
			drawSprite(
				'MPIsland_Voltage', 
				generatedNumbers[2], 
				0.29, 0.50, 0.03, 0.09, 0, 255, 255, 255, 255
			)


			drawSprite(
				'MPIsland_Voltage', 
				generatedNumbers[3], 
				0.29, 0.694, 0.03, 0.09, 0, 255, 255, 255, 255
			)
			
			
			-- Right target icons

			drawSprite(
				'MPIsland_Voltage', 
				iconName[1], 
				0.699, 0.307, 0.06, 0.08, 0, 255, 255, 255, 255
			)
			

			drawSprite(
				'MPIsland_Voltage', 
				iconName[2], 
				0.7, 0.503, 0.05, 0.08, 0, 255, 255, 255, 255
			)
			
			
			drawSprite(
				'MPIsland_Voltage', 
				iconName[3], 
				0.7, 0.698, 0.04, 0.06, 0, 255, 255, 255, 255
			)				

				
			-- Result voltage

			local resultColor = 0
			if resultVoltage == targetVoltage then
				resultColor = 2
			else
				resultColor = 1
			end
			drawSprite(
				'MPIsland_Voltage', 
				tostring(resultVoltageString[1]), 
				0.457, 0.815, 0.03, 0.09, 0, resultTextColor[resultColor][1], resultTextColor[resultColor][2], resultTextColor[resultColor][3], resultAlpha
			)
			
			drawSprite(
				'MPIsland_Voltage', 
				tostring(resultVoltageString[2]), 
				0.497, 0.815, 0.03, 0.09, 0, resultTextColor[resultColor][1], resultTextColor[resultColor][2], resultTextColor[resultColor][3], resultAlpha
			)
			
			drawSprite(
				'MPIsland_Voltage', 
				tostring(resultVoltageString[3]), 
				0.539, 0.815, 0.03, 0.09, 0, resultTextColor[resultColor][1], resultTextColor[resultColor][2], resultTextColor[resultColor][3], resultAlpha
			)

			for i=1,countDownTime do
				drawSprite(
					'MPIsland_Voltage', 
					'maininterface_progress_highlight', 
					timerUI[i][1], timerUI[i][2], timerUI[i][3], timerUI[i][4], 0, 88, 204, 102, 255
				)
			end

			-- Track drawing nodes

			if activeNumberNode == 1 then 
				drawSprite(
					'MPIsland_Voltage', 
					'NUMBER_NODE', 
					0.298, 0.307, 0.06, 0.098, 0, 250, 172, 54, 255
				)
			elseif activeNumberNode == 2 then
			
				drawSprite(
					'MPIsland_Voltage', 
					'NUMBER_NODE', 
					0.298, 0.5, 0.06, 0.098, 0, 247, 49, 49, 255
				)
			elseif activeNumberNode == 3 then
			
				drawSprite(
					'MPIsland_Voltage', 
					'NUMBER_NODE', 
					0.298, 0.693, 0.06, 0.098, 0, 58, 53, 212, 255
				)
			end
			
			-- Active circle nodes
			
			if activeCircleNode == 1 then 
				drawSprite(
					'MPIsland_Voltage', 
					'CIRCLE_NODE', 
					0.691, 0.307, 0.078, 0.13, 0, circlNodeColor[activeNumberNode][1], circlNodeColor[activeNumberNode][2], circlNodeColor[activeNumberNode][3], 255
				)
			elseif activeCircleNode == 2 then
			
				drawSprite(
					'MPIsland_Voltage', 
					'CIRCLE_NODE', 
					0.691, 0.5, 0.078, 0.125, 0, circlNodeColor[activeNumberNode][1], circlNodeColor[activeNumberNode][2], circlNodeColor[activeNumberNode][3], 255
				)
			elseif activeCircleNode == 3 then
			
				drawSprite(
					'MPIsland_Voltage', 
					'CIRCLE_NODE', 
					0.691, 0.694, 0.078, 0.125, 0, circlNodeColor[activeNumberNode][1], circlNodeColor[activeNumberNode][2], circlNodeColor[activeNumberNode][3], 255
				)
			end
			
			if activeNumberNode ~= 0 and activeCircleNode ~= 0 then
				for i,k in pairs(nodePaths[tostring(activeNumberNode)][tostring(activeCircleNode)]) do
					if activeNumberNode and activeCircleNode then
						drawRect(k[1],k[2],k[3],k[4],circlNodeColor[activeNumberNode][1], circlNodeColor[activeNumberNode][2], circlNodeColor[activeNumberNode][3], connectedNodeAlpha[activeNumberNode])
					end
				end	
			end	
	
			if getTableSize(confirmedNodes) ~= 0 then
				for index,freezeData in pairs(confirmedNodes) do
					for i,k in pairs(nodePaths[tostring(freezeData[1])][tostring(freezeData[2])]) do
						if freezeData[1] and freezeData[2] then
							drawRect(k[1],k[2],k[3],k[4],circlNodeColor[freezeData[1]][1], circlNodeColor[freezeData[1]][2], circlNodeColor[freezeData[1]][3], connectedNodeAlpha[freezeData[1]])
						end
					end	
				end
			end
	


		end
	end)

	Wait(100) -- Necessary to actiavte the previous thread

	CreateThread(function()
		local tempVoltage = 0
		local totalVoltage = 0
		local form = setupScaleform("instructional_buttons")

		while isHackActive do
			Wait(5)
			DrawScaleformMovieFullscreen(form, 255, 255, 255, 255, 0)
			if IsControlJustPressed(0, 172) then -- Arrow UP
				if activeNumberNode > 1 and activeNumberNode < 4 then
					activeNumberNode = activeNumberNode - 1
					playSound('Disconnect_Wire','DLC_H4_Voltage_Minigame_Sounds')
					if activeCircleNode ~= 0 then
						tempVoltage = totalVoltage + generatedNumbers[activeNumberNode] * iconValues[activeCircleNode]
						updateResultVoltage(tempVoltage)
					end
				end
				
			elseif IsControlJustPressed(0, 173) then -- Arrow DOWN
				if activeNumberNode < 3 and activeNumberNode >= 0 then
					activeNumberNode = activeNumberNode + 1
					playSound('Disconnect_Wire','DLC_H4_Voltage_Minigame_Sounds')
					if activeCircleNode ~= 0 then
						tempVoltage = totalVoltage + generatedNumbers[activeNumberNode] * iconValues[activeCircleNode]
						updateResultVoltage(tempVoltage)
					end
				end
				
			elseif IsControlJustPressed(0, 174) then -- Arrow LEFT
				if activeCircleNode > 1 and activeCircleNode < 4 then
					activeCircleNode = activeCircleNode - 1
					playSound('Disconnect_Wire','DLC_H4_Voltage_Minigame_Sounds')
					tempVoltage = totalVoltage + generatedNumbers[activeNumberNode] * iconValues[activeCircleNode]
					updateResultVoltage(tempVoltage)
				end
				
			elseif IsControlJustPressed(0, 175) then -- Arrow RIGHT
				if activeCircleNode < 3 and activeCircleNode >= 0 then
					activeCircleNode = activeCircleNode + 1
					playSound('Disconnect_Wire','DLC_H4_Voltage_Minigame_Sounds')
					tempVoltage = totalVoltage + generatedNumbers[activeNumberNode] * iconValues[activeCircleNode]
					updateResultVoltage(tempVoltage)
				end
			
			elseif IsControlJustPressed(0, 194) then -- backspace

				isSuccess = false
				isHackActive = false
				playSound('Minigame_Failure','DLC_H4_Voltage_Minigame_Sounds')
				SendNUIMessage({
					type = 'fail'
				})
				isCallbackSent = true
				callbackFn(0,'Hack cancelled')

			elseif IsControlJustPressed(0, 191) then -- Enter
				if activeCircleNode ~= 0 then
					if occupiedCircleNodes[tostring(activeCircleNode)] == nil or occupiedCircleNodes[tostring(activeCircleNode)] == false then 	
						if confirmedNodes[tostring(activeNumberNode)] == nil or confirmedNodes[tostring(activeNumberNode)] == false then
							
							local flashcount = 1
							local alpha = 255
							playSound('OS_Draw','DLC_H4_Voltage_Minigame_Sounds')
							CreateThread(function()
								while flashcount > 0 do
									for i=1,#connectedNodeAlpha do
										connectedNodeAlpha[i] = alpha
										if alpha < 255 then
											alpha = alpha + 85
										else
											alpha = alpha - 85
										end
									end
									Wait(100)
								end
								for i=1,#connectedNodeAlpha do
									connectedNodeAlpha[i] = 255
								end
							end)
							Wait(1000)
							flashcount = 0
	
							totalVoltage = totalVoltage + generatedNumbers[activeNumberNode] * iconValues[activeCircleNode]
							resultVoltage = totalVoltage
	
							occupiedCircleNodes[tostring(activeCircleNode)] = true
							confirmedNodes[tostring(activeNumberNode)] = {activeNumberNode, activeCircleNode}
	
							if getTableSize(confirmedNodes) >= 3 then
								if totalVoltage == targetVoltage then
	
									isSuccess = true
									playSound('All_Connected_Correct','DLC_H4_Voltage_Minigame_Sounds')
									local resultFlashCount = 1
									CreateThread(function()
										while resultFlashCount > 0 do
											if resultAlpha < 255 then
												resultAlpha = resultAlpha + 85
											else
												resultAlpha = resultAlpha - 85
											end
											Wait(100)
										end
										resultAlpha = 255
									end)
									Wait(1000)
									resultFlashCount = 0
									playSound('Minigame_Success','DLC_H4_Voltage_Minigame_Sounds')
									SendNUIMessage({
										type = 'success'
									})
									isHackActive = false
									isCallbackSent = true
									callbackFn(1)
								else
									Wait(1000)
									isSuccess = false
									isHackActive = false
									playSound('Minigame_Failure','DLC_H4_Voltage_Minigame_Sounds')
									SendNUIMessage({
										type = 'fail'
									})
									isCallbackSent = true
									callbackFn(0,'Hack failed')
									
								end
							end
						end
					end
				end
			end
		end
	end)


	CreateThread(function()
		Wait(5000)
		local timerWait = timer / 6
		while timer > 0 do
			Wait(timerWait*1000)
			timer = timer - timerWait
			countDownTime = countDownTime - 1
		end 
		Wait(2000)
		if isSuccess == nil then
			isHackActive = false
			playSound('Minigame_Failure','DLC_H4_Voltage_Minigame_Sounds')
			SendNUIMessage({
				type = 'fail'
			})
			if not isCallbackSent then 
				callbackFn(2,'Hack timeout out')
			end
		end
	end)
end)