using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Numerics;

namespace _04.Trainlands
{
    class Program
    {
        static void Main(string[] args)
        {

            // Правилния начин да се доближаваме до задачи който имат равенства и използват речници

            Dictionary<string, Dictionary<string, long>> trainStation = new Dictionary<string, Dictionary<string, long>>();

            string validInputPattern = @"^(?<trainName>[^ \-:>=]+?) -> (?<wagonName>[^ \-:>=]+?) : (?<wagonPower>[\d]+?)$";
            string input = string.Empty;

            string addWagonsPatternToTrain = @"^(?<leftsideTrainName>[^ \-:>=]+?) -> (?<rightsideWagonName>[^ \-:>=]+?)$";
            string equalPattern = @"^(?<leftside>[^ \-:>=]+?) = (?<rightside>[^ \-:>=]+?)$";

            while ((input = Console.ReadLine()) != "It's Training Men!")
            {
                // ако ще въвеждаме команд {trainName} -> {wagonName} : {wagonPower}

                if (Regex.IsMatch(input, validInputPattern))
                {
                    Match infoToken = Regex.Match(input, validInputPattern);
                    string trainName = infoToken.Groups["trainName"].Value;
                    string wagonName = infoToken.Groups["wagonName"].Value;
                    int wagonPower = int.Parse(infoToken.Groups["wagonPower"].Value);

                    //Creates a train with the given name and adds a wagon to it with the given name and power.
                    //If the train already exists ,
                    // ... it just adds the given "wagon" to it.

                    if (!trainStation.ContainsKey(trainName))
                    {
                        trainStation[trainName] = new Dictionary<string, long>();
                    }

                    if (!trainStation[trainName].ContainsKey(wagonName))
                    {
                        trainStation[trainName][wagonName] = 0;
                    }

                    if (trainStation[trainName].ContainsKey(wagonName))
                    {
                        trainStation[trainName][wagonName] += wagonPower; //  trainStation[trainName][wagonName] = wagonPower;
                    }
                }

                // ако ще въвеждаме команд {trainName} -> {otherTrainName}

                if (Regex.IsMatch(input, addWagonsPatternToTrain))
                {
                    Match sides = Regex.Match(input, addWagonsPatternToTrain);
                    string leftsidetrainName = sides.Groups["leftsideTrainName"].Value;
                    string rightsidetrainName = sides.Groups["rightsideWagonName"].Value;

                    // ако не съществува лявата страна

                    if (!trainStation.ContainsKey(leftsidetrainName) && trainStation.ContainsKey(rightsidetrainName))
                    {

                        trainStation[leftsidetrainName] = new Dictionary<string, long>();

                        // Метод 1 <- могат да се появят грешки
                        ////trainStation[leftsidetrainName] = trainStation[rightsidetrainName];

                        // Метод 2
                        foreach (var wagon in trainStation[rightsidetrainName])
                        {
                            trainStation[leftsidetrainName].Add(wagon.Key, wagon.Value);
                        }

                        trainStation.Remove(rightsidetrainName);


                    }
                    else // ако съществува лявата страна
                    {
                        foreach (var wagon in trainStation[rightsidetrainName])
                        {
                            trainStation[leftsidetrainName].Add(wagon.Key, wagon.Value);
                        }
                        trainStation.Remove(rightsidetrainName);
                    }

                }

                //// ако ще въвеждаме команд {trainName} = {otherTrainName}

                if (Regex.IsMatch(input, equalPattern))
                {
                    Match sides = Regex.Match(input, equalPattern);
                    string leftsidetrainName = sides.Groups["leftside"].Value;
                    string rightsidetrainName = sides.Groups["rightside"].Value;

                    //// МЕТОД 1-- > ТУКА ИМА ГРЕШКА ... КАКВА Е ....
                    //if (!trainStation.ContainsKey(leftsidetrainName)) //&& trainStation.ContainsKey(rightsidetrainName))
                    //{
                    //    trainStation[leftsidetrainName] = new Dictionary<string, long>();
                    //    trainStation[leftsidetrainName] = trainStation[rightsidetrainName];
                    //}
                    //else // ако съществува лявата страна  ---> // тука е грешката
                    //{
                    //    trainStation[leftsidetrainName] = trainStation[rightsidetrainName];
                    //}

                    // ето защо :
                    //Kivil -> KAKA : 1387
                    //Zone -> Gh : 4081
                    //Kivil -> RAMZES666 : 4677
                    //Desolator -> MiraclE~ : 8432
                    //Zone = Kivil
                    //Kivil -> NewOne : 2000
                    //It's Training Men!

                    // МЕТОД 2
                    if (!trainStation.ContainsKey(leftsidetrainName))
                    {
                        trainStation[leftsidetrainName] = new Dictionary<string, long>();
                    }

                    trainStation[leftsidetrainName].Clear(); // защо е нужно Clear()
                    // защото когато има съществуващ

                    foreach (var wagons in trainStation[rightsidetrainName])
                    {
                        trainStation[leftsidetrainName].Add(wagons.Key, wagons.Value);
                    }

                }
            }

            // Output

            foreach (var train in trainStation
                .OrderByDescending(x => x.Value.Values.Sum())
                .ThenBy(x => x.Value.Count))
            {
                string trainToken = train.Key;
                var wagonsAndPowers = train.Value;

                Console.WriteLine($"Train: {trainToken}");

                foreach (var wagonAndPower in wagonsAndPowers.OrderByDescending(x => x.Value))
                {
                    string wagon = wagonAndPower.Key;
                    long power = wagonAndPower.Value;

                    Console.WriteLine($"###{wagon} - {power}");
                }
            }

        }
    }
}