finn | Fast Raft framework using the Redis protocol for Go | Architecture library

class Program
{
    static void Main(string[] args)
    {
        /// 
        /// Tapet:

        // Följande ska användaren kunna mata in:
        // 1. Väggens mått: Längd och bredd.
        // 2. Jämförelse av upp till 8 st tapeter.

        // Programmet ska även kunna skriva ut en lista av alla tapet där man tydligt ser namn, antal rullar och pris. 

        //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

        ///Mattor:

        // Användaren ska kunna mata in golvets bredd och längd.

        // Användaren ska sedan kunna mata in olika areor på mattor tills det täcker golvets yta.  

        // Vi ska bestämma när antalet mattor har täckt golvet, samt hur många mattor det tog.

        //.......

        // Variabeln menyKörs sätts till true så vi kan skapa en While-loop som hela tiden körs om. Detta avbryter vi genom att sätta den till
        // false ifall användaren väljer att avsluta programmet. 
        bool menyKörs = true;
        while (menyKörs)
        {
            //Ett programm som hjälper anändaren att tappetsera en vägg eller lägga mattor på användarens golv

            Console.WriteLine("Hej! Välkommen till programmet som hjälper dig med att tappetsera och lägga golvmattor ");
            // Menyval för användaren att välja väg i programmet. Beroende på val skickas användaren till olika metoder som utreder specifika uppgifter. 

            Console.WriteLine("Meny: ");
            Console.WriteLine("Välj V för att tappetsera en vägg, M för att lägga mattor eller A för att avsluta programmet! ");
            Console.WriteLine("Tappetsera vägg (V)");
            Console.WriteLine("Lägga mattor (M)");
            Console.WriteLine("Avsluta programm (A)");
            Console.WriteLine("\r\n:");

            string val = Console.ReadLine().ToUpper();

            //Anänver mig av en "switch" för att gå olika vägar beroende på användarens val i menyn. 
            switch (val)
            {
                //Tar in värdena bredd och längd och skickar in detta i metoden "tapeter".
                case "V":
                    {
                        Console.WriteLine("Vad är måtten på väggen du ska tappetsera? (Skriv i meter) ");
                        Console.WriteLine("Bredden: ");
                        double måttBredd = double.Parse(Console.ReadLine());
                        Console.WriteLine("Längden: ");
                        double måttLängd = double.Parse(Console.ReadLine());
                        Console.WriteLine($"Din area på väggen blir: {måttBredd * måttLängd}m^2 ");

                        Tapeter(måttBredd, måttLängd);
                        break;
                    }

                //Skickas direkt till metoden "mattor" som sedan returnar hur många mattor det krävdens
                case "M":
                    {
                        Console.WriteLine($"Det krävdes {Mattor()} antal mattor för att täcka golvets yta! ");
                        break;
                    }
                case "A":
                    {
                        menyKörs = false;
                        break;
                    }

                //Avbryter koden genom att skickas till metoden "Felmeddelande"
                default:
                    {
                        Felmeddelande();
                        break;
                    }

            }

        }

    }

    /// 
    /// En metod som berättar för användaren att ett felaktigt värde blivit angivet. Detta görs i en metod då vi minskar upprepning. 
    /// 
    private static void Felmeddelande()
    {
        Console.WriteLine("Du skrev in ett felaktigt värde, testa igen! ");
    }

    /// 
    /// Räknar ut antal tapeter för en vägg och skriver ut dem
    /// 
    /// Den bredd väggen har
    /// Den längd som väggen har
    private static void Tapeter(double måttBredd, double måttLängd)
    {
        //Tapet
        //Olika lister där inmatning utav olika värden från användaren sparas för senare utskrivning
        List listaTapet = new List();
        List listaNamn = new List();
        List listaPris = new List();
        List listaPrisTotal = new List();


        int a = 0;
        bool tapetVäg = true;
        while (a <= 9 && tapetVäg)
        {
            //Menyval där användaren kan välja att lägga till en tapet för jämförelse, skriva ut tapeterna eller avsluta programmet. 
            Console.WriteLine("Vad vill du göra? Klicka 1, 2, respektive 3 för att välja: ");
            Console.WriteLine("Tänk på att du enbart kan jämföra !MAX! 8 st olika tapeter. ");
            Console.WriteLine("1: Lägga till en tapet");
            Console.WriteLine("2: Skriva ut listorna av tapeterna");
            Console.WriteLine("3: Avsluta programm");

            int valdVäg = int.Parse(Console.ReadLine());

            switch (valdVäg)
            {
                case 1:
                    {
                        Console.Clear();
                        Console.WriteLine("Vad heter din tapet? ");
                        string namnTapet = Console.ReadLine();
                        listaNamn.Add(namnTapet);

                        /*Räknar ut det antal rullar som användaren behöver. Detta görs utan hänsyn till mönster eller att tapeten ska sitta rätt.
                        Uträkningen görs genom att först dividera väggens bredd, (måttBredd), med tapetens bredd (tapetBredd), 
                        vilket ger oss antalet rullar vi behöver för att täcka väggens bredd med tapeter (antalRullar bredd). 
                        Detta värde avrundas uppåt då vi inte kan köpa halva tapetrullar. 
                        
                        Sedan multipliceras det antal tapeter som behövs för att täcka väggens bredd, (antalRullar bredd), med väggens längd, (måttLängd). Slutligen divideras detta med
                        tapetens längd, (tapetLängd), vilket ger oss totala antalet rullar vi behöver för att täcka hela väggen, (antalRullarVägg). 
                        Även detta värde, (antalRullarVägg), avrundas uppåt av samma anledning som innan. 
                        */

                        Console.WriteLine("Hur bred är tapeten? (meter) ");
                        double tapetBredd = double.Parse(Console.ReadLine());
                        Console.WriteLine("Hur lång är tapeten? (meter) ");
                        double tapetLängd = double.Parse(Console.ReadLine());
                        double antalRullarBredd = (måttBredd / tapetBredd);
                        int kolumnRullar = Convert.ToInt32((Math.Ceiling(antalRullarBredd)));
                        int antalRullarVägg = Convert.ToInt32((Math.Ceiling((antalRullarBredd * måttLängd) / tapetLängd)));
                        Console.WriteLine($"Totala antal rullar du behöver blir {antalRullarVägg} st");
                        listaTapet.Add(antalRullarVägg);

                        //Det totala priset blir antalet rullar tapet multiplicerat med vad en rulle tapet kostar. 
                        Console.WriteLine("vad kostar tapeten? (kr/rulle) ");
                        double tapetPris = double.Parse(Console.ReadLine());
                        double prisTotal = antalRullarVägg * tapetPris;
                        Console.WriteLine($"Det totala priset för din tapet blir därmet: {prisTotal} kr ");
                        listaPris.Add(tapetPris);
                        listaPrisTotal.Add(prisTotal);

                        Console.WriteLine("Tryck Enter för att fortsätta: ");
                        Console.ReadLine();
                        Console.Clear();

                            break;
                    }

                case 2:
                    { 
                        Console.Clear();
                        Console.WriteLine("Här kommer dina tapeter som en lista: ");

                        //Räknar upp listorna i ordning med hjälp av en "foreach" där loopen körs tills det inte finns något mer i listan "listaNamn".
                        //Då listan "listaNamn" och alla andra listor är lika stora så kommer loopen skriva ut allt i listorna. 
                        for (int i = 0; i < listaNamn.Count; i++)
                        {
                            Console.Write("Namn: ");
                            Console.WriteLine(listaNamn[i]);
                            Console.Write("Antal tapetrullar: ");
                            Console.WriteLine(listaTapet[i]);
                            Console.Write("Kr/Rulle: ");
                            Console.WriteLine(listaPris[i]);
                            Console.Write("Totalt pris för tapet: ");
                            Console.WriteLine(listaPrisTotal[i]);
                            Console.Write("");
                        }

                            break;
                    }

                case 3:
                    {
                        tapetVäg = false;
                            break;
                    }
                        
                default:
                    {
                        Felmeddelande();
                            break;
                    }
            }

            a++;
        }
    }

    /// 
    /// Metod som körs för att täcka golvet med mattor
    /// 
    static int Mattor()
    {
        //Skapar två lister för mattornas längd och bredd. Detta för att jag sedan ska kunna skriva ut mattorna som användaren har använt. 
        List listaMattaBredd = new List();
        List listaMattaLängd = new List();
        int b = 0;
        bool mattaVäg = true;
        while (mattaVäg)
        {
            Console.WriteLine("Meny: ");
            Console.WriteLine("1: Lägga till mattor");
            Console.WriteLine("2: Skriva ut mattorna");
            Console.WriteLine("3: Avsluta programm");
            int mattaVal = int.Parse(Console.ReadLine());

            switch (mattaVal)
            {
                case 1:
                    {
                        Console.WriteLine("Du ska täcka ditt golv med golvmattor. Jag behöver följande: ");
                        Console.WriteLine("Golvets bredd: ");
                        double golvBredd = double.Parse(Console.ReadLine());
                        Console.WriteLine("Golvets längd: ");
                        double golvLängd = double.Parse(Console.ReadLine());
                        Console.WriteLine($"Din area blir: {golvBredd * golvLängd} m^2 ");
                        double golvArea = golvLängd * golvBredd;

                        // "täcktGolv" sätts till noll och adderas varje gång anvädnaren valt att lägga till en matta på golvet. 
                        double täcktGolv = 0;
                        //Använder do-while för att se om mattorna tänker golvarean. Använder även en variabel som räknas efter varje gång loopen utförs för att bestämma antal mattor man behöver. 
                        
                        do
                        {
                            Console.WriteLine("Ta en matta och mata in mattans mått: ");
                            Console.WriteLine("Matta bredd: ");
                            int mattaBredd = int.Parse(Console.ReadLine());
                            listaMattaBredd.Add(mattaBredd);
                            Console.WriteLine("Matta längd: ");
                            int mattaLängd = int.Parse(Console.ReadLine());
                            listaMattaLängd.Add(mattaLängd);

                            täcktGolv = täcktGolv + (mattaBredd * mattaLängd);

                            Console.WriteLine($"Täckt golv blir: {täcktGolv} m^2");
                            b++;
                        } while (täcktGolv < golvArea);
                        return b;
                        
                    }

                case 2:
                    {
                        Console.Clear();
                        Console.WriteLine("Här kommer dina tapeter som en lista: ");

                        //Räknar upp listorna i ordning med hjälp av en "foreach" där loopen körs tills det inte finns något mer i listan "listaMattaBredd". 
                        //Då listan "listaMattaBredd" är lika stor som listan "listaMattaLängd" så kommer loopen skriva ut allt i listorna. 
                        for (int i = 0; i < listaMattaBredd.Count; i++)
                        {
                            Console.Write("Matta Bredd: ");
                            Console.WriteLine(listaMattaBredd[i]);
                            Console.Write("Matta Längd: ");
                            Console.WriteLine(listaMattaLängd[i]);
                            Console.Write("");
                        }
                        return b;
                        
                    }

                case 3:
                    {
                        mattaVäg = false;
                        return b;
                        
                    }


                default:
                    {
                        Felmeddelande();
                        return b;
                        
                    }
                    
            }

            

        }   
    }
}