using System;

using System.Collections.Generic;

using System.Text;

public class Program

{

    public const int Iterations = 100000;

    public static readonly Dictionary<int, Building> Buildings = new ()

    {

        { 5, new (){ Number = 5, Name = "Bergbaulager", UndestroyCost = 3 } },

        { 12, new (){ Number = 12, Name = "Jagdhütte", UndestroyCost = 3 } },

        { 17, new (){ Number = 17, Name = "Holzfällerlager", UndestroyCost = 3 } },

        { 34, new (){ Number = 34, Name = "Handwerker", UndestroyCost = 4 } },

        { 35, new (){ Number = 35, Name = "Alchemist", UndestroyCost = 3 } },

        { 84, new (){ Number = 84, Name = "Werkstatt", UndestroyCost = 4 } },

        { 98, new (){ Number = 98, Name = "Kaserne", UndestroyCost = 2 } },

    };

    public static void Main()

    {

        var deck = new Deck();

        deck.Add(0, CardEffect.Defend, 6);

        deck.Add(-10, CardEffect.Defend, 5);

        deck.Add(10, CardEffect.Defend, 5);

        deck.Add(-20, CardEffect.Defend, 1);

        deck.Add(20, CardEffect.Defend, 1);

        deck.Add(int.MinValue, CardEffect.Destroy, 1);

        deck.Add(int.MaxValue, CardEffect.Success, 1);

        Test(0, deck, 0);

        Test(1, deck, 1);

        Test(2, deck, 1);

        Test(3, deck, 1);

        Test(2, deck, 2);

        Test(3, deck, 2);

        Test(3, deck, 3);

    }

    public static AverageResult Test(int soldiers, Deck deck, int soldiersPerBuilding)

    {

        var conditions = new Conditions {

            ThreatLevel = 20,

            Buildings = new ( new [] { Buildings[84], Buildings[98], Buildings[12] } ),

            DefenseLevel = 15,

            UsableSoldiers = soldiers,

            SoldiersPerBuilding = soldiersPerBuilding,

            DestroyedCosts = 20f / 6

        };

        Console.Write($"Testing {soldiers} soldier(s), {soldiersPerBuilding} per building: ");

        var player = new AttackEventPlayer(conditions);

        var result = player.PlayMultiple(Iterations, deck);

        Console.WriteLine(result.GetAveragesString());

        //Console.WriteLine(result.GetMinMatCostString());

        //Console.WriteLine(result.GetMinDestroyedString());

        return result;

    }

}

​

public class AttackEventPlayer

{

    public Conditions Conditions { get; }

    public AttackEventPlayer(Conditions conditions)

    {

        Conditions = conditions;

    }

    public AverageResult PlayMultiple(int rounds, Deck deck)

    {

        var averageResult = new AverageResult();

        while(rounds-- > 0)

            averageResult.AddResult(Play(deck));

        averageResult.UpdateAverages(Conditions.DestroyedCosts);

        return averageResult;

    }

    public Result Play(Deck deck)

    {

        var result = new Result();

        var buildings = new Queue<Building>(Conditions.Buildings);

        var soldiers = Conditions.UsableSoldiers;

        var forceDisadvantage = false;

        deck.NewShuffle();

        while(buildings.Count > 0 &&  buildings.Dequeue() is Building building)

        {

            var card = deck.Draw();

                //Console.WriteLine($"card: {card}");

            if(forceDisadvantage)

            {

                var extraCard = deck.Draw();

                if(extraCard.Defense < card.Defense)

                    card = extraCard;

            }

            else {

                for(int spb = Math.Min(Conditions.SoldiersPerBuilding, soldiers); spb > 0 ; spb--, soldiers--)

                {

                    result.SoldiersUsed++;

                    var extraCard = deck.Draw();

                    if(extraCard.Defense > card.Defense)

                        card = extraCard;

                    //Console.WriteLine($"extra card: {extraCard}");

                }

            }

            switch(card.Effect)

            {

                case CardEffect.Destroy:

                    result.Destroyed++;

                    result.UndestroyCost += building.UndestroyCost;

                    if(building.Number == BuildingNumbers.Kaserne)

                        forceDisadvantage = true;

                    //Console.WriteLine($"result destroyed");

                    break;

                case CardEffect.Success:

                    //Console.WriteLine($"result defended");

                    break;

                case CardEffect.Defend:

                    if(Conditions.ThreatLevel > Conditions.DefenseLevel + card.Defense)

                        result.Damaged++;

                    //Console.WriteLine($"result damaged");

                    break;

            }

        }

        return result;

    }

}

​

public enum CardEffect

{

    Defend = 0,

    Success = 1,

    Destroy = 2

}

​

public class Card 

{

    public int Defense = 0;

    public CardEffect Effect = 0;

    public override string ToString() { 

        switch(Effect)

            {

                case CardEffect.Success: return "success";

                case CardEffect.Destroy: return "destroy";

                default:

                    return Defense.ToString();

            }

    }

}

​

public class Deck

{

    static Random Rng = Random.Shared;

    List<Card> CardPool = new List<Card>();

    Queue<Card> CurrentCards = new Queue<Card>();

    public Deck(Card[] cardPool)

    {

        CardPool = new List<Card>(cardPool);

        NewShuffle();

    }

    public Deck()

    {

    }

    public void NewShuffle()

    {

        var cards = new List<Card>(CardPool);

        Shuffle(cards);

        CurrentCards = new (cards);

    }

    static void Shuffle<T>(IList<T> list)

    {

        for (int i = list.Count - 1; i > 0; i--)

        {

            int k = Rng.Next(i + 1);

            (list[i], list[k]) = (list[k], list[i]);

        }

    }

    public Card Draw() 

    {

        if(CurrentCards.Count < 1)

            NewShuffle();

        return CurrentCards.Dequeue();

    }

    public void Add(int defense, CardEffect effect, int count = 1)

    {

        while(count-- > 0)

        {

            CardPool.Add(new Card { Defense = defense, Effect = effect } );

        }

    }

}

​

public class Conditions

{

    public int ThreatLevel { get; init;}

    public Queue<Building> Buildings { get; init; }

    public int DefenseLevel { get; init; }

    public int UsableSoldiers { get; init; }

    public int SoldiersPerBuilding { get; init; }

    public double DestroyedCosts { get; init; } = 20f / 6;

}

​

public class Result

{

    public int Damaged = 0;

    public int Destroyed = 0;

    public int SoldiersUsed = 0;

    public int UndestroyCost = 0;

}

​

public class AverageResult

{

    public int TotalRounds = 0;

    public int TotalDamaged = 0;

    public int TotalDestroyed = 0;

    public int TotalSoldiers = 0;

    public int TotalGoldCosts = 0;

    public SortedDictionary<int, int> DestroyedCount = new ();

    public SortedDictionary<int, int> MaterialCosts = new ();

    public double AvgMaterials { get; private set; } = 0;

    public double AvgDestroyed { get; private set; } = 0;

    public double AvgDamaged { get; private set; } = 0;

    public double AvgGoldCosts { get; private set; } = 0;

    public void UpdateAverages(double destroyedCosts)

    {

        AvgMaterials = (TotalDamaged * 2f + TotalSoldiers + TotalDestroyed * destroyedCosts) / TotalRounds;

        AvgDestroyed = 1f * TotalDestroyed / TotalRounds;

        AvgDamaged = 1f * TotalDamaged / TotalRounds;

        AvgGoldCosts = 1f * TotalGoldCosts / TotalRounds;

    }

    public void AddResult(Result result)

    {

        TotalRounds++;

        TotalDamaged += result.Damaged;

        TotalDestroyed += result.Destroyed;

        TotalSoldiers += result.SoldiersUsed;

        TotalGoldCosts += result.SoldiersUsed * 3;

        DestroyedCount.TryGetValue(result.Destroyed, out var destroyed);

        DestroyedCount[result.Destroyed] = destroyed + 1;

        var materialCosts = (int)(result.Damaged * 2f + result.SoldiersUsed + result.UndestroyCost);

        MaterialCosts.TryGetValue(materialCosts, out var material);

        MaterialCosts[materialCosts] = material + 1;

    }

    public string GetAveragesString()

    {

        return $"avg. materials: {AvgMaterials:0.##}, avg. destroyed: {AvgDestroyed:0.##}, avg. damaged: {AvgDamaged:0.##}, avg. gold costs: {AvgGoldCosts:0.##}";

    }

    public string GetMinMatCostString()

    {

        var right = TotalRounds;

        var left = 0;

        var str = new StringBuilder();

        foreach(var pair in MaterialCosts)

        {

            left += pair.Value;

            str.AppendLine($"at least {pair.Key} materials: {100f * right / TotalRounds:0.##}%");

            right -= pair.Value;

        }

        return str.ToString();

    }

​

    public string GetMinDestroyedString()

    {

        var right = TotalRounds;

        var left = 0;

        var str = new StringBuilder();

        foreach(var pair in DestroyedCount)

        {

            left += pair.Value;

            str.AppendLine($"at least {pair.Key} destroyed: {100f * right / TotalRounds:0.##}%");

            right -= pair.Value;

        }

        return str.ToString();

    }

}

​

public static class BuildingNumbers

{

    public const int Kaserne = 98;

}

​

public class Building

{

    public int Number { get; init; }

    public string Name { get; init; }

    public int RepairCost { get; init; } = 2;

    public int UndestroyCost { get; init; }

}