#****************************************************************************
#**
#**  File     :  /lua/SorianInstantBuildConditions.lua
#**  Author(s): Michael Robbins aka Sorian
#**
#**  Summary  : Generic AI Platoon Build Conditions
#**             Build conditions always return true or false
#**
#****************************************************************************
local AIUtils = import('/lua/ai/aiutilities.lua')
local ScenarioFramework = import('/lua/scenarioframework.lua')
local ScenarioUtils = import('/lua/sim/ScenarioUtilities.lua')
local Utils = import('/lua/utilities.lua')
local SUtils = import('/lua/AI/sorianutilities.lua')

function DefensivePointNeedsStructure(aiBrain, locationType, locationRadius, category, markerRadius, unitMax, threatMin, threatMax, threatRings, threatType)
    local pos, name = AIUtils.AIFindDefensivePointNeedsStructureSorian(aiBrain, locationType, locationRadius, category, markerRadius, unitMax, threatMin, threatMax, threatRings, threatType)
    if pos then
        return true
    end
    return false
end

function ExpansionPointNeedsStructure(aiBrain, locationType, locationRadius, category, markerRadius, unitMax, threatMin, threatMax, threatRings, threatType)
    local pos, name = AIUtils.AIFindExpansionPointNeedsStructure(aiBrain, locationType, locationRadius, category, markerRadius, unitMax, threatMin, threatMax, threatRings, threatType)
    if pos then
        return true
    end
    return false
end

function AIThreatExists(aiBrain, threatThreshold)
    for k,v in aiBrain.BaseMonitor.AlertsTable do
        if v.Threat >= threatThreshold then
            return true
        end
    end
    return false
end

##############################################################################################################
# function: FactoryRatioLessOrEqual = BuildCondition
#
# parameter 0: string   aiBrain		    = "default_brain"
# parameter 1: string   locationType    = "location type"
# parameter 2: expr     unitCategory    = "Unit Category"
# parameter 2: expr     unitCategory2   = "Unit Category"
# parameter 2: expr     unitCategory3   = "Unit Category"
#
##############################################################################################################
function FactoryRatioLessOrEqual(aiBrain, locationType, num, unitCategory, unitCategory2, unitCategory3)
    local factoryManager = aiBrain.BuilderManagers[locationType].FactoryManager
    local testCat = unitCategory
    if type(unitCategory) == 'string' then
        testCat = ParseEntityCategory(unitCategory)
    end
    local testCat2 = unitCategory2
    if type(unitCategory2) == 'string' then
        testCat2 = ParseEntityCategory(unitCategory2)
    end
    local testCat3 = unitCategory3
    if type(unitCategory3) == 'string' then
        testCat3 = ParseEntityCategory(unitCategory3)
    end
    if not factoryManager then
        WARN('*AI WARNING: FactoryComparisonAtLocation - Invalid location - ' .. locationType)
        return false
    end
    local numUnits = factoryManager:GetNumCategoryFactories(testCat)
    local numUnits2 = factoryManager:GetNumCategoryFactories(testCat2)
    local numUnits3 = factoryManager:GetNumCategoryFactories(testCat3)
    if numUnits == 0 and numUnits2 == 0 then
        return true
    elseif numUnits2 == 0 and (numUnits - numUnits2 <= num or numUnits3 < 1) then
        return true
    elseif numUnits2 > 0 and (numUnits / numUnits2 <= num or numUnits3 < 1) then
        return true
    else
        return false
    end
end

##############################################################################################################
# function: CDRHealthGreaterThan = BuildCondition
#
# parameter 0: string   aiBrain		    = "default_brain"
# parameter 1: int      health          = "minimum health %"
# parameter 2: int      shield          = "minimum shield %"
#
##############################################################################################################
function CDRHealthGreaterThan(aiBrain, health, shield)
    local cdr = aiBrain:GetListOfUnits(categories.COMMAND, false)[1]
    if not cdr then return false end
    local cdrhealth = cdr:GetHealthPercent()
    local cdrshield
    if (cdr:HasEnhancement('Shield') or cdr:HasEnhancement('ShieldGeneratorField') or cdr:HasEnhancement('ShieldHeavy')) and cdr:ShieldIsOn() then
        cdrshield = (cdr.MyShield:GetHealth() / cdr.MyShield:GetMaxHealth())
    else
        cdrshield = 1
    end
    if cdrhealth >= health and cdrshield >= shield then
        return true
    end
    return false
end

##############################################################################################################
# function: HaveGreaterThanUnitsWithCategory = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string   aiBrain		    = "default_brain"
# parameter 1: int      numReq     = 0					doc = "docs for param1"
# parameter 2: expr   category        = categories.ALLUNITS		doc = "param2 docs"
# parameter 3: expr   idleReq       = false         doc = "docs for param3"
# parameter 4: bool		special		= "Whether numReq varies depending on game time"
#
##############################################################################################################
function HaveGreaterThanUnitsWithCategory(aiBrain, numReq, category, idleReq)
    local numUnits
    local total = 0
    if type(category) == 'string' then
        category = ParseEntityCategory(category)
    end
    if not idleReq then
        numUnits = aiBrain:GetListOfUnits(category, false)
    else
        numUnits = aiBrain:GetListOfUnits(category, true)
    end
    for k,v in numUnits do
        if v:GetFractionComplete() == 1 then
            total = total + 1
            if total > numReq then
                return true
            end
        end
    end
    if total > numReq then
        return true
    end
    return false
end


##############################################################################################################
# function: HaveLessThanUnitsWithCategory = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"
# parameter 1: int	numReq          = 0				doc = "docs for param1"
# parameter 2: expr   category        = categories.ALLUNITS		doc = "param2 docs"
# parameter 3: expr   idleReq       = false         doc = "docs for param3"
#
##############################################################################################################
function HaveLessThanUnitsWithCategory(aiBrain, numReq, category, idleReq)
    local numUnits
    local total = 0
    if type(category) == 'string' then
        category = ParseEntityCategory(category)
    end
    if not idleReq then
        numUnits = aiBrain:GetListOfUnits(category, false)
    else
        numUnits = aiBrain:GetListOfUnits(category, true)
    end
    for k,v in numUnits do
        if v:GetFractionComplete() == 1 then
            total = total + 1
            if total >= numReq then
                return false
            end
        end
    end
    if total >= numReq then
        return false
    end
    return true
end

##############################################################################################################
# function: HaveLessThanUnitsForMapSize = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"
# parameter 1: int	numReq          = 0				doc = "docs for param1"
# parameter 2: expr   category        = categories.ALLUNITS		doc = "param2 docs"
# parameter 3: expr   idleReq       = false         doc = "docs for param3"
#
##############################################################################################################
function HaveLessThanUnitsForMapSize(aiBrain, sizetable, category, idleReq)
    local numUnits
    local total = 0
    local mapSizeX, mapSizeZ = GetMapSize()
    if not sizetable[mapSizeX] or not sizetable[mapSizeZ] then
        return false
    end
    local numReq = sizetable[mapSizeX] or sizetable[mapSizeZ]
    if type(category) == 'string' then
        category = ParseEntityCategory(category)
    end
    if not idleReq then
        numUnits = aiBrain:GetCurrentUnits(category)
    else
        numUnits = table.getn(aiBrain:GetListOfUnits(category, true))
    end
    if numUnits < numReq then
        return true
    end
    return false
end

##############################################################################################################
# function: HaveLessThanUnitsInCategoryBeingBuilt = BuildCondition
#
# parameter 0: string   aiBrain         = "default_brain"
# parameter 1: integer  numunits        = "Number of units"
# parameter 2: integer  radius          = "radius"
#
##############################################################################################################
function HaveLessThanUnitsInCategoryBeingBuilt(aiBrain, numunits, category)
    if type(category) == 'string' then
        category = ParseEntityCategory(category)
    end

    local unitsBuilding = aiBrain:GetListOfUnits(categories.CONSTRUCTION, false)
    local numBuilding = 0
    for unitNum, unit in unitsBuilding do
        if not unit:BeenDestroyed() and unit:IsUnitState('Building') then
            local buildingUnit = unit.UnitBeingBuilt
            if buildingUnit and not buildingUnit.Dead and EntityCategoryContains(category, buildingUnit) then
                numBuilding = numBuilding + 1
            end
        end
        if numunits <= numBuilding then
            return false
        end
    end
    if numunits > numBuilding then
        return true
    end
    return false
end

##############################################################################################################
# function: HaveGreaterThanUnitsInCategoryBeingBuilt = BuildCondition
#
# parameter 0: string   aiBrain         = "default_brain"
# parameter 1: integer  numunits        = "Number of units"
# parameter 2: integer  radius          = "radius"
#
##############################################################################################################
function HaveGreaterThanUnitsInCategoryBeingBuilt(aiBrain, numunits, category)
    if type(category) == 'string' then
        category = ParseEntityCategory(category)
    end

    local unitsBuilding = aiBrain:GetListOfUnits(categories.CONSTRUCTION, false)
    local numBuilding = 0
    for unitNum, unit in unitsBuilding do
        if not unit:BeenDestroyed() and unit:IsUnitState('Building') then
            local buildingUnit = unit.UnitBeingBuilt
            if buildingUnit and not buildingUnit.Dead and EntityCategoryContains(category, buildingUnit) then
                numBuilding = numBuilding + 1
            end
        end
        if numunits < numBuilding then
            return true
        end
    end
    return false
end

##############################################################################################################
# function: LessThanEconTrend = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"			doc = "docs for param1"
# parameter 1: integer	mTrend	        = 0				doc = "docs for param1"
# parameter 2: integer	eTrend	        = 0      			doc = "param2 docs"
#
##############################################################################################################
function LessThanEconTrend(aiBrain, mTrend, eTrend)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return false
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    local cheatmult = tonumber(ScenarioInfo.Options.CheatMult) or 2
    if aiBrain.CheatEnabled and (econ.MassTrend < mTrend * cheatmult and econ.EnergyTrend < eTrend * cheatmult) then
        return true
    elseif not aiBrain.CheatEnabled and (econ.MassTrend < mTrend and econ.EnergyTrend < eTrend) then
        return true
    else
        return false
    end
end

##############################################################################################################
# function: GreaterThanEconEfficiencyOverTimeExp = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassEfficiency	= 1             doc = "docs for param1"
# parameter 2: int	EnergyEfficiency	= 1             doc = "param2 docs"
#
##############################################################################################################
function GreaterThanEconEfficiencyOverTimeExp(aiBrain, MassEfficiency, EnergyEfficiency)
    local unitsBuilding = aiBrain:GetListOfUnits(categories.CONSTRUCTION, false)
    local numBuilding = 0
    for unitNum, unit in unitsBuilding do
        if not unit:BeenDestroyed() and unit:IsUnitState('Building') then
            local buildingUnit = unit.UnitBeingBuilt
            if buildingUnit and not buildingUnit.Dead and EntityCategoryContains(categories.EXPERIMENTAL, buildingUnit) then
                numBuilding = numBuilding + 1
            end
        end
    end

    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassEfficiencyOverTime >= MassEfficiency + (numBuilding * .2) and econ.EnergyEfficiencyOverTime >= EnergyEfficiency + (numBuilding * .2)) then
        return true
    end
    return false
end

##############################################################################################################
# function: GreaterThanEconIncome = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassIncome	= 0.1             doc = "docs for param1"
# parameter 2: int	EnergyIncome	= 1             doc = "param2 docs"
#
##############################################################################################################
function GreaterThanEconIncome(aiBrain, MassIncome, EnergyIncome)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return true
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassIncome >= MassIncome and econ.EnergyIncome >= EnergyIncome) then
        return true
    end
    return false
end


##############################################################################################################
# function: LessThanEconIncome = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassIncome	= 0.1             doc = "docs for param1"
# parameter 2: int	EnergyIncome	= 1             doc = "param2 docs"
#
##############################################################################################################
function LessThanEconIncome(aiBrain, MassIncome, EnergyIncome)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return false
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassIncome < MassIncome and econ.EnergyIncome < EnergyIncome) then
        return true
    end
    return false
end

##############################################################################################################
# function: GreaterThanEconIncomeOverTime = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassIncome	= 0.1             doc = "docs for param1"
# parameter 2: int	EnergyIncome	= 1             doc = "param2 docs"
#
##############################################################################################################
function GreaterThanEconIncomeOverTime(aiBrain, MassIncome, EnergyIncome)
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassIncomeOverTime >= MassIncome and econ.EnergyIncomeOverTime >= EnergyIncome) then
        return true
    end
    return false
end

##############################################################################################################
# function: GreaterThanEconEfficiency = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassEfficiency	= 1             doc = "docs for param1"
# parameter 2: int	EnergyEfficiency	= 1             doc = "param2 docs"
#
##############################################################################################################
function GreaterThanEconEfficiency(aiBrain, MassEfficiency, EnergyEfficiency)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return true
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassEfficiency >= MassEfficiency and econ.EnergyEfficiency >= EnergyEfficiency) then
        return true
    end
    return false
end

function LessThanEconEfficiency(aiBrain, MassEfficiency, EnergyEfficiency)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return false
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassEfficiency <= MassEfficiency and econ.EnergyEfficiency <= EnergyEfficiency) then
        return true
    end
    return false
end

##############################################################################################################
# function: GreaterThanEconEfficiencyOverTime = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassEfficiency	= 1             doc = "docs for param1"
# parameter 2: int	EnergyEfficiency	= 1             doc = "param2 docs"
#
##############################################################################################################
function GreaterThanEconEfficiencyOverTime(aiBrain, MassEfficiency, EnergyEfficiency)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return true
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassEfficiencyOverTime >= MassEfficiency and econ.EnergyEfficiencyOverTime >= EnergyEfficiency) then
        return true
    end
    return false
end

function LessThanEconEfficiencyOverTime(aiBrain, MassEfficiency, EnergyEfficiency)
    if HaveGreaterThanUnitsWithCategory(aiBrain, 0, 'ENERGYPRODUCTION EXPERIMENTAL STRUCTURE') then
        #LOG('*AI DEBUG: Found Paragon')
        return false
    end
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassEfficiencyOverTime <= MassEfficiency and econ.EnergyEfficiencyOverTime <= EnergyEfficiency) then
        return true
    end
    return false
end

##############################################################################################################
# function: LessThanEconIncomeOverTime = BuildCondition	doc = "Please work function docs."
#
# parameter 0: string	aiBrain		= "default_brain"				doc = "docs for param1"
# parameter 1: int	MassIncome	= 0.1             doc = "docs for param1"
# parameter 2: int	EnergyIncome	= 1             doc = "param2 docs"
#
##############################################################################################################
function LessThanEconIncomeOverTime(aiBrain, MassIncome, EnergyIncome)
    local econ = AIUtils.AIGetEconomyNumbers(aiBrain)
    if (econ.MassIncomeOverTime < MassIncome and econ.EnergyIncomeOverTime < EnergyIncome) then
        return true
    end
    return false
end

##############################################################################################################
# function: EngineerNeedsAssistance = BuildCondition
#
# parameter 0: string   aiBrain         = "default_brain"
# parameter 1: bool    doesbool        = "true: Engineer does need assistance false: Engineer does not need assistance"
# parameter 2: string   LocationType   = "LocationType"
# parameter 3: string   category        = "Being built category"
#
##############################################################################################################
function EngineerNeedsAssistance(aiBrain, doesbool, locationType, category)
    local engineerManager = aiBrain.BuilderManagers[locationType].EngineerManager
    if not engineerManager then
        return false
    end
    local numFound = 0
    for _,cat in category do
        local bCategory = ParseEntityCategory(cat)

        local engs = engineerManager:GetEngineersBuildingCategory(bCategory, categories.ALLUNITS)
        for k,v in engs do
            if v.DesiresAssist == true then
                if v.MinNumAssistees and SUtils.GetGuards(aiBrain, v) < v.MinNumAssistees then
                    numFound = numFound + 1
                end
            end
            if numFound > 0 and doesbool then return true end
        end

        engs = engineerManager:GetEngineersBuildQueue(cat)
        for k,v in engs do
            if v.DesiresAssist == true then
                if v.MinNumAssistees and SUtils.GetGuards(aiBrain, v) < v.MinNumAssistees then
                    numFound = numFound + 1
                end
            end
            if numFound > 0 and doesbool then return true end
        end
    end

    if numFound == 0 and not doesbool then return true end
    return false
end

function LessThanExpansionBases(aiBrain)
    local expBaseCount = 0
    local numberofAIs = SUtils.GetNumberOfAIs(aiBrain)
    local startX, startZ = aiBrain:GetArmyStartPos()
    local isWaterMap = false
    local checkNum = tonumber(ScenarioInfo.Options.LandExpansionsAllowed) or 5
    local navalMarker = AIUtils.AIGetClosestMarkerLocation(aiBrain, 'Naval Area', startX, startZ)
    if navalMarker then
        isWaterMap = true
    end
    expBaseCount = aiBrain:GetManagerCount('Start Location')
    expBaseCount = expBaseCount + aiBrain:GetManagerCount('Expansion Area')
    checkNum = checkNum - numberofAIs
    if isWaterMap and expBaseCount < checkNum then
        return true
    elseif not isWaterMap and expBaseCount < checkNum + 1 then
        return true
    end
    return false
end

function GreaterThanExpansionBases(aiBrain)
    return not LessThanExpansionBases(aiBrain)
end

function LessThanNavalBases(aiBrain)
    local expBaseCount = 0
    local checkNum = tonumber(ScenarioInfo.Options.NavalExpansionsAllowed) or 4
    local isIsland = import('/lua/editor/SorianBuildConditions.lua').IsIslandMap(aiBrain)
    expBaseCount = aiBrain:GetManagerCount('Naval Area')
    #LOG('*AI DEBUG: '.. aiBrain.Nickname ..' LessThanNavalBases Total = '..expBaseCount)
    if isIsland and expBaseCount < checkNum then
        return true
    elseif not isIsland and expBaseCount < checkNum - 2 then
        return true
    end
    return false
end

function GreaterThanNavalBases(aiBrain)
    return not LessThanNavalBases(aiBrain)
end

function T4BuildingCheck(aiBrain)
    if aiBrain.T4Building then
        return false
    end
    return true
end

function HavePoolUnitComparisonAtLocationExp(aiBrain, locationType, unitCount, unitCategory, compareType)
    local engineerManager = aiBrain.BuilderManagers[locationType].EngineerManager
    local testCat = unitCategory
    if type(unitCategory) == 'string' then
        testCat = ParseEntityCategory(unitCategory)
    end
    if not engineerManager then
        WARN('*AI WARNING: HavePoolUnitComparisonAtLocation - Invalid location - ' .. locationType)
        return false
    end
    local poolPlatoon = aiBrain:GetPlatoonUniquelyNamed('ArmyPool')
    local numUnits = poolPlatoon:GetNumCategoryUnits(testCat, engineerManager:GetLocationCoords(), engineerManager.Radius * 2.5)
    return CompareBody(numUnits, unitCount, compareType)
end

function PoolLessAtLocationExp(aiBrain, locationType, unitCount, unitCategory)
    return HavePoolUnitComparisonAtLocationExp(aiBrain, locationType, unitCount, unitCategory, '<')
end

function PoolGreaterAtLocationExp(aiBrain, locationType, unitCount, unitCategory)
    return HavePoolUnitComparisonAtLocationExp(aiBrain, locationType, unitCount, unitCategory, '>')
end

function CompareBody(numOne, numTwo, compareType)
    if compareType == '>' then
        if numOne > numTwo then
            return true
        end
    elseif compareType == '<' then
        if numOne < numTwo then
            return true
        end
    elseif compareType == '>=' then
        if numOne >= numTwo then
            return true
        end
    elseif compareType == '<=' then
        if numOne <= numTwo then
            return true
        end
    else
        error('*AI ERROR: Invalid compare type: ' .. compareType)
        return false
    end
    return false
end