07.RegularExpressionsExercise-Star Enigma

04. *Star Enigma
The war is in its peak, but you, young Padawan, can turn the tides with your programming skills. You are tasked to create a program to decrypt the messages of The Order and prevent the death of hundreds of lives.
You will receive several messages, which are encrypted using the legendary star enigma. You should decrypt the messages, following these rules:
To properly decrypt a message, you should count all the letters [s, t, a, r] – case insensitive and remove the count from the current ASCII value of each symbol of the encrypted message.
After decryption:
Each message should have a planet name, population, attack type ('A', as attack or 'D', as destruction) and soldier count.
The planet name starts after '@' and contains only letters from the Latin alphabet.
The planet population starts after ':' and is an Integer;
The attack type may be "A"(attack) or "D"(destruction) and must be surrounded by "!" (exclamation mark).
The soldier count starts after "->" and should be an Integer.
The order in the message should be: planet name -> planet population -> attack type -> soldier count. Each part can be separated from the others by any character except: '@', '-', '!', ':' and '>'.
Input / Constraints
• The first line holds n – the number of messages– integer in range [1…100];
• On the next n lines, you will be receiving encrypted messages.
Output
After decrypting all messages, you should print the decrypted information in the following format:
First print the attacked planets, then the destroyed planets.
"Attacked planets: {attackedPlanetsCount}"
"-> {planetName}"
"Destroyed planets: {destroyedPlanetsCount}"
"-> {planetName}"
The planets should be ordered by name alphabetically.
Examples
Input                         Output                Comments
2                             Attacked planets: 1   We receive two messages, to decrypt them we calculate the key:
STCDoghudd4=63333$D$0A53333   -> Alderaa            First message has decryption key 3. So we substract from each characters code 3.
EHfsytsnhf?8555&I&2C9555SR    Destroyed planets: 1  PQ@Alderaa1:30000!A!->20000 The second message has key 5.@Cantonica:3000!D!->4000NM
                              -> Cantonica          Both messages are valid and they contain planet,
                                                    population, attack type and soldiers count.
                                                    After decrypting all messages we print each planet according the format given.

3                                    Attacked planets: 0       We receive three messages. Message one is decrypted with key 4:
tt(''DGsvywgerx>6444444444%H%1B9444  Destroyed planets: 2      pp$##@Coruscant:2000000000!D!->5000
GQhrr|A977777(H(TTTT                 -> Cantonica              Message two is decrypted with key 7: @Jakku:200000!A!MMMM
EHfsytsnhf?8555&I&2C9555SR           -> Coruscant              This is invalid message, missing soldier count, so we continue.
                                                               The third message has key 5. @Cantonica:3000!D!->4000NM
using System;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
         var countMessages = int.Parse(Console.ReadLine());

            var counterA = 0;
            var counterD = 0;
            var listAttackedPlanets = new List<string>();
            var listDestroyedPlanets = new List<string>();
            for (int i = 1; i <= countMessages; i++)
            {
                var encryptedMessage = Console.ReadLine();
                var patternKey = @"[starSTAR]";
                var matchKeyLetters = Regex.Matches(encryptedMessage, patternKey);
                var decryptionKey = int.Parse(matchKeyLetters.Count.ToString());
                var decryptedMessage = "";
                foreach (var encryptedSymbol in encryptedMessage)
                {
                    decryptedMessage += (char)(encryptedSymbol - decryptionKey);
                }
                var pattern = @"@(?<Planet>[A-za-z]+)\d*[^@\-!:>]*:(?<Population>\d+)[^@\-!:>]*!(?<Action>[AD])![^@\-!:>]*->(?<Soldier>\d+)";
                var matchMessage = Regex.Match(decryptedMessage, pattern);

                if (matchMessage.Success)
                {
                    if (matchMessage.Groups["Action"].Value == "A")
                    {
                        counterA++;
                        var attackedPlanets = $"-> {matchMessage.Groups["Planet"].Value}";
                        listAttackedPlanets.Add(attackedPlanets);
                    }
                    else
                    {
                        counterD++;
                        var destroyedPlanets = $"-> {matchMessage.Groups["Planet"].Value}";
                        listDestroyedPlanets.Add(destroyedPlanets);
                    }
                }

            }
            Console.WriteLine($"Attacked planets: {counterA}");
            if (counterA != 0)
            {
                Console.WriteLine(string.Join("\n", listAttackedPlanets.OrderBy(x => x)));
            }
            Console.WriteLine($"Destroyed planets: {counterD}");
            Console.WriteLine(string.Join("\n", listDestroyedPlanets.OrderBy(x => x)));
    }
}