package tactic

import "github.com/golangconf/gophers-and-dragons/game"

func ChooseCard(s game.State) game.CardType {
    return myTactic(s)
}

func myTactic(s game.State) game.CardType {
    var CriticalHP = s.Avatar.HP - 1

    if s.Avatar.HP < 20 {
        if s.Can(game.CardHeal) {
            return game.CardHeal
        }
    }
    
    if s.Round == 12 {
        if s.RoundTurn == 1 && diffInDamage(s) > s.Avatar.HP {
            return game.CardRetreat
        }         
    } else if s.RoundTurn == 1 && diffInDamage(s) > CriticalHP  {
        return game.CardRetreat
    }
    
    if s.Creep.HP == 3 && s.Creep.Type != game.CreepDragon && s.Can(game.CardMagicArrow) {
        return game.CardMagicArrow
    }

    if s.Creep.Type == game.CreepCheepy {
        return fightCheepy(s)
    }

    if s.Creep.Type == game.CreepMummy && s.Can(game.CardFirebolt) {
        return game.CardFirebolt
    }

    if s.Creep.Type == game.CreepDragon {
        return fightDragon(s)
    }
    return burst(s)
}

func fightCheepy(s game.State) game.CardType {
    if s.Avatar.HP < 35 && s.RoundTurn <= 2 {
        return game.CardRest
    } 
    return game.CardAttack
}

func fightDragon(s game.State) game.CardType {
    if s.Can(game.CardParry) {
        return game.CardParry
    } 
    if s.Can(game.CardStun) && !s.Creep.IsStunned() {
        return game.CardStun
    }
    burst(s)
}

func diffInDamage(s game.State) int {
    var diff = 0
    var CreepHP = s.Creep.HP
    var highestCreepDamage = s.Creep.Damage.High()
    var lowestMyDamage = 2
    var powerAttacks = s.Deck[game.CardPowerAttack].Count
    var fireboltAttacks = s.Deck[game.CardFirebolt].Count
    var stuns = s.Deck[game.CardStun].Count
    
    CreepHP = CreepHP - 4*powerAttacks
    diff = highestCreepDamage*powerAttacks - 4*powerAttacks
    
    if s.Creep.Traits.Has(game.TraitWeakToFire) {
        CreepHP = CreepHP - 8*fireboltAttacks 
        diff = diff + highestCreepDamage*fireboltAttacks - 8*fireboltAttacks 
    }
    
    if !s.Creep.Traits.Has(game.TraitMagicImmunity) {
        if fireboltAttacks > 3 {
            fireboltAttacks = fireboltAttacks - 3
            CreepHP = CreepHP - 4*fireboltAttacks 
            diff = diff + highestCreepDamage*fireboltAttacks - 4*fireboltAttacks 
        }
    }

    if s.Creep.Type == game.CreepDragon {
        var parry = s.Deck[game.CardParry].Count
        CreepHP = CreepHP - 5*parry
        diff = diff - 5*parry
    }
    
    CreepHP = CreepHP - 2*stuns
    diff = diff + highestCreepDamage*stuns - 2*stuns

    for CreepHP >= 0 {
        diff = diff + highestCreepDamage
        diff = diff - 2
        CreepHP = CreepHP - 2
    }
    
    return diff
}

func burst(s game.State) game.CardType {
    if s.Deck[game.CardFirebolt].Count > 3 && s.Creep.Type != game.CreepDragon && s.Creep.HP > 4 {
            return game.CardFirebolt
    }
    
    if s.Round == 11 && s.Can(game.CardFirebolt) {
        return game.CardFirebolt
    }
    
    if s.Creep.HP > 4 && !s.Creep.IsStunned() && s.Can(game.CardStun) {
        return game.CardStun
    }
    if s.Creep.HP > 4 && s.Can(game.CardPowerAttack) {
        return game.CardPowerAttack
    }
    return game.CardAttack
}