RodManager.lua

local RodManager = {}

--// Services
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

--// Variables
local rodConfigs = {}
local rodInstances = {}

--// Initialize the Rod Manager
function RodManager.Init(rodConfigTable)
	assert(typeof(rodConfigTable) == "table", "Rod config must be a table")
	rodConfigs = rodConfigTable
end

--// Create a new rod instance 
function RodManager.CreateRod(rodId)
	if not rodConfigs[rodId] then
		warn("Rod ID not found in config: " .. rodId)
		return nil
	end
	
	local config = rodConfigs[rodId]
	local rodModel = ServerStorage:FindFirstChild("FishingRods") and 
		ServerStorage.FishingRods:FindFirstChild(config.Model)
	
	if not rodModel then
		rodModel = ReplicatedStorage:FindFirstChild("FishingRods") and 
			ReplicatedStorage.FishingRods:FindFirstChild(config.Model)
		
		if not rodModel then
			warn("Rod model not found: " .. config.Model)
			return nil
		end
	end
	
	local rod = {
		Id = rodId,
		Name = config.Name,
		ModelName = config.Model,
		Rarity = config.Rarity,
		CastRange = config.CastRange,
		ReelSpeed = config.ReelSpeed,
		CatchChance = config.CatchChance,
		RareFishChance = config.RareFishChance,
		MaxDurability = config.Durability,
		CurrentDurability = config.Durability,
		Model = rodModel:Clone(),
		
		IsFishing = false,
		CastPosition = nil,
		FishingStartTime = nil,
		
		Connections = {},
	}
	
	function rod:Cast(position)
		if self.IsFishing then return false, "Already fishing" end
		if self.CurrentDurability <= 0 then return false, "Rod is broken" end
		
		self.IsFishing = true
		self.CastPosition = position
		self.FishingStartTime = tick()
		
		return true
	end
	
	function rod:ReelIn()
		if not self.IsFishing then return false, "Not currently fishing" end
		
		self.IsFishing = false
		self.CurrentDurability = math.max(0, self.CurrentDurability - 1)
		
		local catchSuccess = math.random() < self.CatchChance
		return catchSuccess
	end
	
	function rod:Repair(amount)
		self.CurrentDurability = math.min(self.MaxDurability, self.CurrentDurability + amount)
		return self.CurrentDurability
	end
	
	function rod:Destroy()
		for _, connection in pairs(self.Connections) do
			if typeof(connection) == "RBXScriptConnection" and connection.Connected then
				connection:Disconnect()
			end
		end
		
		self.Connections = {}
		if self.Model then
			self.Model:Destroy()
			self.Model = nil
		end
	end
	
	local rodId = rodId .. "_" .. tostring(tick())
	rodInstances[rodId] = rod
	
	return rod
end

--// Get rod by ID
function RodManager.GetRod(rodId)
	return rodInstances[rodId]
end

--// Get all available rod types
function RodManager.GetRodTypes()
	local types = {}
	for rodId, config in pairs(rodConfigs) do
		table.insert(types, {
			Id = rodId,
			Name = config.Name,
			Rarity = config.Rarity
		})
	end
	return types
end

--// Clean up resources
function RodManager.DestroyRod(rodId)
	local rod = rodInstances[rodId]
	if rod then
		rod:Destroy()
		rodInstances[rodId] = nil
	end
end

return RodManager