--!strict
local CollectionService = game:GetService("CollectionService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local Network = require(ReplicatedStorage.Shared.Network)
local Signal = require(ReplicatedStorage.Shared.Signal)
local SecureCast = require(ReplicatedStorage.Shared.Mods.SecureCast)
local EquipmentLibrary = require(ReplicatedStorage.Shared.Library.Equipment)

export type Shooter = {
 __index: Shooter,
 ID: string,
 Player: Player?,
 Character: Model?,
 Settings: EquipmentLibrary.ShooterInfo,
 Tool: Tool?,
 ShootOrigin: Attachment,

 Magazine: {
  Size: number,
  Loaded: number,
  Stored: number,
 },

 Clock: {
  Trigger: number,
  Reload: number,
 },

 Destroyed: boolean,

 new: (tool: Tool, shooterInfo: EquipmentLibrary.ShooterInfo) -> Shooter,
 CanFire: (self: Shooter) -> boolean,
 Reload: (self: Shooter, phase: number) -> boolean,
 Activate: (self: Shooter, origin: Vector3, directions: { Vector3 }, timestamp: number) -> boolean,
 Destroy: (self: Shooter) -> (),
}

local Shooter = {} :: Shooter
Shooter.__index = Shooter

local MAXIMUM_LATENCY = 0.8 -- 800 ms

--==========================-- Private Functions --==========================--

-- Applies damage to humanoid
local function HitHumanoid(
 humanoid: Humanoid,
 damage: number,
 defaultRange: number,
 distanceCovered: number?,
 byPlayer: Player?
)
 if humanoid.Health > 0 then
  local distance = math.max(0, distanceCovered or 1)
  local range = defaultRange or distance
  local baseDamage = damage or 0
  local damageDamper = math.min(1, range / distance)
  local effectiveDamage = math.round(damageDamper * baseDamage * 100) / 100

  humanoid:TakeDamage(effectiveDamage)

  local model = humanoid.Parent :: Model
  Signal.MobDamaged:Fire(byPlayer, model, effectiveDamage)

  if humanoid.Health <= 0 then
   Signal.MobKilled:Fire(byPlayer, model)
  end

  -- TODO: Send event to client
 end
end

local function GetHit(
 caster: Player,
 direction: Vector3,
 instance: Instance,
 normal: Vector3,
 position: Vector3,
 radius: number,
 filterInstances: { Instance }
): { Humanoid }
 local humanoids = {}
 if instance and instance.Parent then
  -- Temporary damage logic
  if radius > 0 then
   local overlapParams = OverlapParams.new()
   overlapParams.FilterType = Enum.RaycastFilterType.Exclude
   overlapParams.FilterDescendantsInstances = filterInstances

   local parts = workspace:GetPartBoundsInRadius(position, radius, overlapParams)
   local foundHumanoids = {}
   for _, part: BasePart in pairs(parts) do
    -- Humanoid & health check
    local humanoid = part.Parent and part.Parent:FindFirstChild("Humanoid") :: Humanoid?
    if not humanoid or humanoid.Health > 0 then
     continue
    end

    -- Already found check
    if foundHumanoids[humanoid] then
     continue
    end

    -- Same player & same team check
    local humanoidPlayer: Player? = Players:GetPlayerFromCharacter(part.Parent)
    if humanoidPlayer and (caster == humanoidPlayer or caster.Team == humanoidPlayer.Team) then
     continue
    end

    foundHumanoids[humanoid] = humanoid
   end

   for _, humanoid: Humanoid in pairs(foundHumanoids) do
    table.insert(humanoids, humanoid)
   end
  else
   local humanoid = instance.Parent:FindFirstChild("Humanoid") :: Humanoid?
   if humanoid then
    table.insert(humanoids, humanoid)
   end
  end
 end

 return humanoids
end

--==========================-- Public Functions --==========================--

function Shooter.new(tool: Tool, shooterInfo: EquipmentLibrary.ShooterInfo): Shooter
 local self: Shooter = setmetatable({} :: any, Shooter)
 self.ID = tool:GetAttribute("SID")
 self.Player = nil
 self.Character = nil
 self.Settings = shooterInfo

 self.Tool = tool
 self.ShootOrigin = tool:FindFirstChild("ShootOrigin", true) :: Attachment

 self.Magazine = {
  Size = self.Settings.Magazine.Size,
  Loaded = self.Settings.Magazine.Size,
  Stored = self.Settings.Magazine.Stored,
 }

 self.Clock = {
  Trigger = 0,
  Reload = 0,
 }

 return self
end

function Shooter:CanFire(): boolean
 local toolExists = (self.Tool and self.Tool.Parent) and true or false

 local now = workspace:GetServerTimeNow()
 local triggerCooldownOver = now - self.Clock.Trigger >= self.Settings.Cooldown
 local reloadOver = now - self.Clock.Reload >= self.Settings.Reload.Time
 return toolExists and triggerCooldownOver and reloadOver
end

function Shooter:Reload(phase: number): boolean
 if phase == 1 then
  return self.Magazine.Loaded < self.Magazine.Size and self.Magazine.Stored > 0
 end

 local count = self.Settings.Reload.Count
 local addCount = count > 0 and count or self.Settings.Magazine.Size
 local actualCount = math.min(self.Settings.Magazine.Size - self.Magazine.Loaded, addCount)

 if self.Magazine.Stored - actualCount >= 0 then
  self.Magazine.Stored -= actualCount
  self.Magazine.Loaded = math.min(self.Settings.Magazine.Size, self.Magazine.Loaded + addCount)
  return true
 end

 self.Clock.Reload = workspace:GetServerTimeNow()

 return false
end

function Shooter:Activate(origin: Vector3, directions: { Vector3 }, timestamp: number): boolean
 local prerequisitesExist = (origin and directions and timestamp) and self.Character and true or false

 if prerequisitesExist and self:CanFire() then
  if self.Magazine.Loaded > 0 then
   local caster: Player? = self.Player
   local castType = "Bullet"
   self.Clock.Trigger = workspace:GetServerTimeNow()
   self.Magazine.Loaded = math.max(0, self.Magazine.Loaded - 1)

   for _count, direction: Vector3 in directions do
    -- Calculate values for latency compensation
    local currentTime = os.clock()
    local interpolation = (self.Player and self.Player:GetNetworkPing() or 0)
     + SecureCast.Settings.Interpolation
    local latency = (workspace:GetServerTimeNow() - timestamp)

    -- Abort if client latency is too high; simulation will be too innacurate
    if (latency < 0) or (latency > MAXIMUM_LATENCY) then
     return false
    end

    -- Abort if client-provided origin position is too far away; potentially cheating
    local shootOrigin = self.Tool and self.Tool:FindFirstChild("ShootOrigin", true) :: Attachment?
    if
     shootOrigin
     and shootOrigin:IsA("Attachment")
     and (shootOrigin.WorldPosition - origin).Magnitude > 5
    then
     return false
    end

    local modifier = {
     Loss = self.Settings.Ricochet.Loss,
     Power = self.Settings.Shot.Power,
     Velocity = self.Settings.Shot.Velocity,
     Angle = self.Settings.Ricochet.Angle,
     Gravity = -self.Settings.Shot.Gravity,
    }

    -- Replicate the projectile to all other clients
    if caster then
     Network.BulletFired:Server():FireAllExcept(caster, caster, castType, origin, direction, modifier)
    else
     Network.BulletFired:Server():FireAll(caster, castType, origin, direction, modifier)
    end

    -- Set serverside raycast filters
    local raycastParams = RaycastParams.new()
    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    local filterInstances = { workspace:FindFirstChild("Stain") }

    local character = self.Character :: Model
    if character then
     if character.Parent and character.Parent:IsA("Folder") then
      table.insert(filterInstances, character.Parent)
     else
      table.insert(filterInstances, character)
     end
    end
    raycastParams.FilterDescendantsInstances = filterInstances

    -- Read cast events
    local bindable = Instance.new("BindableEvent")
    bindable.Event:Connect(function(castType: string, eventName: string, ...)
     local data = { ... }
     if eventName == "OnDestroyed" then
      bindable:Destroy()
     elseif eventName == "OnImpact" then
      local caster, dir, instance, normal, position, _material = table.unpack(data)
      local humanoids = GetHit(
       caster,
       dir,
       instance,
       normal,
       position,
       self.Settings.AreaOfEffect,
       raycastParams.FilterDescendantsInstances
      )

      for _, humanoid in humanoids do
       HitHumanoid(humanoid, self.Settings.Shot.Damage, self.Settings.Shot.Range, nil, self.Player)
      end

      if not self.Player and CollectionService:HasTag(instance.Parent, "BASE") then
       local health = instance.Parent:FindFirstChild("Health") :: NumberValue?
       if health then
        health.Value = math.max(0, health.Value - self.Settings.Shot.Damage)
       end
      end
     elseif eventName == "OnIntersection" then
      local caster, dir, characterPart: string, victim: Player, position = table.unpack(data)
      local humanoid = victim.Character and victim.Character:FindFirstChild("Humanoid") :: Humanoid?
      if humanoid then
       HitHumanoid(humanoid, self.Settings.Shot.Damage, self.Settings.Shot.Range, nil, self.Player)
      end
     end
    end)

    -- Define cast properties
    modifier.RaycastFilter = raycastParams
    modifier.OnImpact = bindable
    modifier.OnDestroyed = bindable
    modifier.OnIntersection = bindable

    -- Cast the projectile within server-side simulation
    SecureCast.Cast(
     caster,
     "Bullet",
     origin,
     direction,
     currentTime - latency - interpolation,
     nil,
     modifier
    )
   end

   return true
  end
 end
 return false
end

function Shooter:Destroy()
 if not self.Destroyed then
  self.Destroyed = true

  self.Player = nil
  self.Character = nil
  self.Tool = nil
 end
end

return Shooter