ENT.Base = "base_nextbot"
--ART stuff
ENT.Drops = nil
ENT.OnDammage = nil
ENT.Speed = 0
ENT.Model = nil
ENT.Behave = nil
ENT.Act = nil
ENT.AutomaticFrameAdvance = true

--[[---------------------------------------------------------
Name: OnRemove
Desc: Called just before entity is deleted
---------------------------------------------------------]]
function ENT:OnRemove()
end


function ENT:DefaultBehaviour()
    print("In default behavior")
    self.lastrun = CurTime()

    --Set some stuff up for navigation
    local path = Path( "Follow" )
    path:SetMinLookAheadDistance( self.lookahead or 300 )
    path:SetGoalTolerance( self.goaltolarance or 100)
    path:Draw()
    local delta = CurTime() - self.lastrun
    self:AI(delta)
    while (true) do
        --print("Inside defaultbehaviour's while")

        --Sets all the values needed for the rest of this function to do it's thing
        --Main loop for ai

        --print("Going into behavior for " .. self.Name)
        --Update aware enemies
        delta = CurTime() - self.lastrun
        --print("delta was", delta)
        if delta > 0.1 then
            --print('Running ai')
            self:AI(delta)
            self.lastrun = CurTime()
        end

        if self.TargetPos ~= nil then
            if ( !path:IsValid() ) then print("Path wasn't valid!") end
            if ( path:GetAge() > 0.1 ) then					-- Since we are following the player we have to constantly repath
                path:Compute( self, self.TargetPos ) -- Compute the path towards the enemy's position again
                path:Update( self )								-- This function moves the bot along the path
            end


            if ( true ) then path:Draw() end
            -- If we're stuck then call the HandleStuck function and abandon
            if ( self.loco:IsStuck() ) then
                --self:HandleStuck()
                --return "stuck"
            end

            --return "ok"
        end
        coroutine.yield()
    end

    coroutine.yield()
end


function ENT:AI(num)
    --print("Inside ai")
    local players = player.GetAll()

    for k, v in pairs(players) do
        local dist = v:GetPos():Distance(self:GetPos())
        if (dist < self.Stats["AwareDist"]) then
            table.insert(self.AwareEnemies, v)
        end
    end

    --Find the enemy with the highest priority
    local maxpriority = -1
    local maxprioritytarget = nil

    for k, v in pairs(self.AwareEnemies) do
        local priority = self:AttackPriority(v)

        if (priority == nil) then
            --print("Nill priority hit after ")
            --PrintTable(self)
        end

        if (priority > maxpriority) then
            maxpriority = priority
            maxprioritytarget = v
        end
    end

    self.Target = maxprioritytarget
    --print("My target is",self.Target)
    --If we can't find anyone to attack, just stay idle
    if (self.Target == nil) then
        --print("Couldn't find anyone to attack!")
        --Play an idle sequence
        local randanim = math.Round(math.Rand(1, #self.IdleSequences))
        print("Playing sequence",self.IdleSequences[randanim])
        self:PlaySequenceAndWait(self.IdleSequences[randanim])
        self:StartActivity(ACT_IDLE)
        print("Acting idle")
        --If there's noone within 4000 units, just remove ourselves to save server resources
        local closest = 5000

        for k, v in pairs(player.GetAll()) do
            local thisdist = self:GetPos():Distance(v:GetPos())

            if (thisdist < closest) then
                closest = thisdist
            end
        end

        if (closest > 4000) then
            --print("Closes player is " .. closest .. " removeing self...")
            self:BecomeRagdoll(DamageInfo())
        end
    else
        --We have a target to attack!
        --Find which attack will do the most dammage
        local maxdammage = -1
        local maxdammagefunc = nil

        for k, v in pairs(self.Attacks) do
            local dammagefunc = nil
            local attackfunc = nil

            for i, j in pairs(v) do
                dammagefunc = i
                attackfunc = j
            end

            local dammage = dammagefunc(self, self.Target)

            if (dammage > maxdammage) then
                maxdammage = dammage
                maxdammagefunc = attackfunc
            end
        end

        --Do that attack
        if (maxdammagefunc) then
            maxdammagefunc(self, self.Target)
        end
    end

    --[[
    print("Before running, behavethread was", self.BehaveThread)
    local ok, message = coroutine.resume( self.BehaveThread )
    if not ok then
        self.BehaveThread = nil
        Msg( self, "error: ", message, "\n" );
    end
    ]]

    if (self.Act) then
        self:Act(num)
    else
        print("NPC spawned without an Act function, this might be an error!")
    end

end

function ENT:RunBehaviour()
    print("Running behavior")
    if (self.Behave) then
        print("Doing self.behave")
        self:Behave()
    else
        print("Doing default behavior")
        self:DefaultBehaviour()
    end
end