function SWEP:Reload(force)
    force = force or false

    if self:GetOwner():IsNPC() then
        self:NPC_Reload()
        return
    end

    if self:GetValue("Firemodes") and self:GetOwner():KeyDown(IN_USE) and self:GetOwner():KeyPressed(IN_RELOAD) and self:GetFiremodeAmount() > 1 and !self:GetSafe() then
        self:SwitchFiremode()
        self:EmitSound("tacrp/weapons/pdw/fire_select-1.wav", 75, 100, 1, CHAN_ITEM)
        return
    end

    local stop = self:RunHook("Hook_PreReload")
    if stop then return end

    if !self:GetOwner():KeyPressed(IN_RELOAD) and !force then
        return
    end

    if self:StillWaiting(true) then return end

    if self:GetJammed() then
        local t = self:PlayAnimation("jam", 0.75, true, true)
        self:GetOwner():DoCustomAnimEvent(PLAYERANIMEVENT_CANCEL_RELOAD, t * 1000)
        self:SetJammed(false)
        self:SetCharge(false)
        return
    end

    if !self:CanReloadInSprint() and self:GetIsSprinting() then return end
    if self:GetCapacity() <= 0 then return end
    if self:Clip1() >= self:GetCapacity() then return end
    if self:Ammo1() <= 0 and !self:GetInfiniteAmmo() then return end

    self:ToggleBlindFire(TacRP.BLINDFIRE_NONE)

    local mult = self:GetValue("ReloadTimeMult") / TacRP.ConVars["mult_reloadspeed"]:GetFloat()

    local anim = "reload"

    if self:GetValue("ShotgunReload") then
        anim = "reload_start"
    else
        self:SetTimer(self:GetValue("LoadInTime") * mult, function()
            self:SetLoadedRounds(math.min(self:GetCapacity(), self:Clip1() + self:Ammo1()))
            self:DoBulletBodygroups()
        end, "SetLoadedRounds")
        if self.ReloadUpInTime then
            self:SetTimer(self.ReloadUpInTime * mult, function()
                self:RestoreClip(self:GetCapacity())
                self:SetNthShot(0)
                self:SetEndReload(true)
            end, "ReloadUpIn")
        end
    end

    local t = self:PlayAnimation(anim, mult, true, true)

    self:GetOwner():DoCustomAnimEvent(PLAYERANIMEVENT_RELOAD, t * 1000)

    if SERVER then
        self:SetTimer(self.DropMagazineTime * mult, function()
            self:DropMagazine()
        end, "DropMagazine")
    end

    self:SetLoadedRounds(self:Clip1())

    self:SetReloading(true)
    self:SetEndReload(false)

    self:SetEmptyReload(self:GetValue("ShotgunNoReverseStart") or self:Clip1() == 0)

    self:DoBulletBodygroups()

    self:RunHook("Hook_StartReload")

    self:SetReloadFinishTime(CurTime() + (t * 0.95))
end

function SWEP:DropMagazine()
    -- if !IsFirstTimePredicted() and !game.SinglePlayer() then return end
    if self:GetValue("DropMagazineModel") and TacRP.ConVars["dropmagazinemodel"]:GetBool() then
        local dropamt = math.floor(self:Clip1() / self:GetValue("DropMagazineAmount"))
        local clip1 = self:Clip1()
        for i = 1, self:GetValue("DropMagazineAmount") do
            local mag = ents.Create("TacRP_droppedmag")

            if IsValid(mag) then
                local bone = "ValveBiped.Bip01_R_Hand"
                if i == 2 then bone = "ValveBiped.Bip01_L_Hand" end
                local matrix = self:GetOwner():GetBoneMatrix(self:GetOwner():LookupBone(bone) or -1)
                local pos, ang
                if matrix then
                    pos = matrix:GetTranslation()
                    ang = matrix:GetAngles()
                else
                    pos = self:GetOwner():EyePos() - (self:GetOwner():EyeAngles():Up() * 8)
                    ang = self:GetOwner():EyeAngles()
                end

                mag:SetPos(pos)
                mag:SetAngles(ang)
                mag.Model = self:GetValue("DropMagazineModel")
                mag.ImpactType = self:GetValue("DropMagazineImpact")
                mag:SetOwner(self:GetOwner())
                if clip1 > 0 and TacRP.ConVars["reload_dump"]:GetBool() then
                    local amt = (i == self:GetValue("DropMagazineAmount") and clip1) or dropamt
                    clip1 = clip1 - amt

                    if !self:GetInfiniteAmmo() then
                        mag.AmmoType = self:GetAmmoType()
                        mag.AmmoCount = amt
                    end
                end
                mag:Spawn()

                local phys = mag:GetPhysicsObject()

                if IsValid(phys) then
                    phys:AddAngleVelocity(Vector(math.Rand(-300, 300), math.Rand(-300, 300), math.Rand(-300, 300)))
                end
            end
        end
        self:SetClip1(clip1)
    end
end

function SWEP:RestoreClip(amt)
    local reserve = self:GetInfiniteAmmo() and math.huge or (self:Clip1() + self:Ammo1())

    local lastclip1 = self:Clip1()

    self:SetClip1(math.min(math.min(self:Clip1() + amt, self:GetCapacity()), reserve))

    if !self:GetInfiniteAmmo() then
        reserve = reserve - self:Clip1()
        self:GetOwner():SetAmmo(reserve, self.Primary.Ammo)
    end

    return self:Clip1() - lastclip1
end

function SWEP:Unload(ammotype)
    self:GetOwner():GiveAmmo(self:Clip1(), ammotype or self.Primary.Ammo)
    self:SetClip1(0)
end

function SWEP:EndReload()
    if self:GetValue("ShotgunReload") then
        local mult = self:GetValue("ReloadTimeMult") / TacRP.ConVars["mult_reloadspeed"]:GetFloat()
        if self:Clip1() >= self:GetCapacity() or (!self:GetInfiniteAmmo() and self:Ammo1() == 0) or self:GetEndReload() then

            local cancellable = TacRP.ConVars["reload_sg_cancel"]:GetBool() and !self:GetValue("ShotgunFullCancel")
            local t = 1
            if !self.ShotgunNoReverseStart and (self:Clip1() == self:GetLoadedRounds() or !self:GetEmptyReload()) then
                t = self:PlayAnimation("reload_start", -0.75 * mult, !cancellable, true)
            else
                t = self:PlayAnimation("reload_finish", mult, !cancellable, true)
            end
            self:GetOwner():DoCustomAnimEvent(PLAYERANIMEVENT_RELOAD_END, t * 1000)

            self:SetReloading(false)

            self:SetNthShot(0)

            self:DoBulletBodygroups()

            self:RunHook("Hook_EndReload")
        else
            local t = self:PlayAnimation("reload", mult, true)

            local res = self:GetValue("ShotgunThreeload") and
                    math.min(math.min(3, self:GetCapacity() - self:Clip1()), self:GetInfiniteAmmo() and math.huge or self:Ammo1())
                    or 1

            local delay = self:GetValue("ShotgunUpInTime")
            for i = 1, res do
                self:SetTimer(t * delay * ((i - 1) / 3) + 0.22, function()
                    self:GetOwner():DoCustomAnimEvent(PLAYERANIMEVENT_RELOAD_LOOP, t * 1000)
                    self:RestoreClip(1)
                    self:RunHook("Hook_InsertReload", res)
                end, "ShotgunRestoreClip")
            end

            self:SetTimer(t * self:GetValue("ShotgunLoadInTime") * (res / 3), function()
                self:SetLoadedRounds(self:GetLoadedRounds() + res)
                self:DoBulletBodygroups()
            end, "SetLoadedRounds")

            self:SetReloadFinishTime(CurTime() + (t * delay * (res / 3)) + 0.05)

            self:DoBulletBodygroups()
        end
    else
        if !self.ReloadUpInTime then
            self:RestoreClip(self:GetCapacity())
            self:SetNthShot(0)
        end
        self:SetReloading(false)
        self:SetEndReload(false)

        self:RunHook("Hook_EndReload")
    end
end

function SWEP:CancelReload(doanims, keeptime)
    if self:GetReloading() then

        self:RunHook("Hook_CancelReload")

        local stop = false

        if doanims then
            if self:GetValue("ShotgunReload") then
                local mult = self:GetValue("ReloadTimeMult") / TacRP.ConVars["mult_reloadspeed"]:GetFloat()
                local t = 1
                if self.CurrentAnimation == "reload_start" and self.ShotgunReloadCompleteStart then
                    self:SetEndReload(true)
                elseif self:Clip1() == self:GetLoadedRounds() and !self.ShotgunNoReverseStart then
                    t = self:PlayAnimation("reload_start", -0.75 * mult, true, true)
                    stop = true
                else
                    t = self:PlayAnimation("reload_finish", mult, true, true)
                    stop = true
                end
                self:GetOwner():DoCustomAnimEvent(PLAYERANIMEVENT_RELOAD_END, t * 1000)
            else
                self:Idle()
                stop = true
            end
        else
            stop = true
        end

        if stop then
            self:KillTimer("SetLoadedRounds")
            self:KillTimer("ShotgunRestoreClip")
            self:KillTimer("ReloadUpIn")
            self:KillTimer("DropMagazine")
            self:SetReloading(false)
            self:SetEndReload(false)
            self:SetNthShot(0)
            self:DoBulletBodygroups()
            if !keeptime then
                self:SetReloadFinishTime(0)
            end
        end
    end
end

function SWEP:ThinkReload()
    if self:GetReloading() and self:GetReloadFinishTime() < CurTime() then
        self:EndReload()
    end
end

local launcher_ammo = {
    ["smg1_grenade"] = true,
    ["rpg_round"] = true,
}
function SWEP:GetInfiniteAmmo()
    local ammo = string.lower(self:GetAmmoType())
    if launcher_ammo[ammo] then
        return TacRP.ConVars["infinitelaunchers"]:GetBool() or self:GetValue("InfiniteAmmo")
    else
        return TacRP.ConVars["infiniteammo"]:GetBool() or self:GetValue("InfiniteAmmo")
    end
end

function SWEP:GetCapacity(base)
    if base then
        return self:GetBaseValue("ClipSize")
    else
        return self:GetValue("ClipSize")
    end
end

function SWEP:GetAmmoType(base)
    local valfunc = base and self.GetBaseValue or self.GetValue
    if self.Ammo_Expanded and TacRP.ConVars["expandedammotypes"]:GetBool() then
        return valfunc(self, "Ammo_Expanded") or valfunc(self, "Ammo")
    else
        return valfunc(self, "Ammo")
    end
end

-- Override to disable auto-reload for one reason or another.
function SWEP:ShouldAutoReload()
    return true
end