using System;
using System.Collections.Generic;

namespace Lab6
{


    class Program
    {

        class Dyrekcja
        {
            private List<Klatka> klatki = new List<Klatka>();
            private List<Ptak> ptaki = new List<Ptak>();
            private List<Ssak> ssaki = new List<Ssak>();
            private List<Gad> gady = new List<Gad>();

            public void ZbudujKlatke(double pojemnosc)
            {
                Klatka dodawanaKlatka = new Klatka(pojemnosc);
                klatki.Add(dodawanaKlatka);
            }

            public bool PowiekszKlatke(int id, double nowaPojemnosc)
            {
                bool success = false;

                foreach (Klatka klatka in klatki) {
                    if (klatka.IdKlatki == id)
                    {
                        klatka.Pojemnosc = nowaPojemnosc;
                        success = true;
                    }
               }
                return success;
            }

            public void ZarejestrujPtaka(int rozpietoscSkrzydel, int wytzymalosc_, string gatunek, string rodzajPozywienia, string pochodzenie)
            {
                Ptak dodawanyPtak = new Ptak(rozpietoscSkrzydel, wytzymalosc_, gatunek, rodzajPozywienia, pochodzenie);
                ptaki.Add(dodawanyPtak);
            }

            public void ZarejestrujSsaka(string naturalneSrodowisko_, string gatunek, string rodzajPozywienia, string pochodzenie)
            {
                Ssak dodawanySsak = new Ssak(naturalneSrodowisko_, gatunek, rodzajPozywienia, pochodzenie);
                ssaki.Add(dodawanySsak);
            }

            public void ZarejestrujGada(bool czyJadowity_, string gatunek, string rodzajPozywienia, string pochodzenie)
            {
                Gad dodawanyGad = new Gad(czyJadowity_, gatunek, rodzajPozywienia, pochodzenie);
                gady.Add(dodawanyGad);
            }

            public bool PrzypiszKlatke(Zwierze zwierze, int id)
            {
                bool success = false;

                foreach(Klatka klatka in klatki)
                {
                    if(klatka.IdKlatki == id && klatka.KlatkaZajeta == false)
                    {
                        zwierze.Klatka.IdKlatki = id;
                        success = true;
                    }

                }

                if (!success)
                    Console.WriteLine("[!!!!] NIE UDALO SIE PRZYPISAC! ");


                return success;

            }

            public void InfoKlatki() // finish extented showup (using bool)
            {
                foreach (Klatka klatka in klatki)
                    klatka.WypiszInfo();
            }



        };

        class Klatka {

            private double pojemnosc = 0;
            private static int liczbaKlatek = 0;
            private int idKlatki;
            private bool wymagaSprzatania = false;
            private bool klatkaZajeta = false;

            public bool KlatkaZajeta
            {
                get => klatkaZajeta;
                set => klatkaZajeta = value;
            }


            public double Pojemnosc
            {
                get => pojemnosc;
                set => pojemnosc = value;

            }
            public int IdKlatki
            {
                get => idKlatki;
                set => idKlatki = value;
            }

            public bool WymagaSprzatania { set => wymagaSprzatania = value; }
            public Klatka(double pojemnosc_)
            {
                pojemnosc = pojemnosc_;
                liczbaKlatek++;
                idKlatki = liczbaKlatek;
            }







            public void WypiszInfo()
            {
                Console.WriteLine("[INFO O KLATCE ID: " +  idKlatki + "] POJEMNOSC: " + pojemnosc + " [m3]. Wymaga sprzatania?: " + wymagaSprzatania);
            }


        }


        class Zwierze {
            protected string gatunek { get; } = " ";
            protected string rodzajPozywienia { get; } = " ";
            protected string pochodzenie { get; } = " ";
            protected Klatka klatka;
            protected List<string> cechy = new List<string>();
            protected List<string> umietnosci = new List<string>();

            public string Gatunek{ get => gatunek; }
            public Klatka Klatka
            {
                get => klatka;
                set => klatka = value;
            }

            public Zwierze()
            {
                gatunek = "nieznany";
                rodzajPozywienia = "nieznany";
                pochodzenie = "nieznane";
            }

            public Zwierze(string gatunek_, string rodzajPozywienia_, string pochodzenie_)
            {
                gatunek = gatunek_;
                rodzajPozywienia = rodzajPozywienia_;
                pochodzenie = pochodzenie_;

            }


            public void DodajCeche(string cecha)
            {
                cechy.Add(cecha);
            }

            public void DodajUmietnosc(string umietnosc)
            {
                umietnosci.Add(umietnosc);
            }

            public void PobrudzicKlatke()
            {
                klatka.WymagaSprzatania = true;
            }

            public void InfoCechy()
            {
                if (cechy.Count > 0)
                {
                    Console.WriteLine("CECHY:");
                    foreach (string cecha in cechy)
                        Console.WriteLine(cecha);
                }
                else
                {
                    Console.WriteLine("[!!!] NIE MA PRZYPISANYCH CECH DO ZWIERZATKA");
                }
            }

            public void InfoUmietnosci()
            {
                if (umietnosci.Count > 0)
                {
                    Console.WriteLine("UMIETNOSCI:");
                    foreach (string um in umietnosci)
                        Console.WriteLine(um);
                }
                else
                {
                    Console.WriteLine("[!!!] NIE MA PRZYPISANYCH UMIETNOSCI DO ZWIERZATKA");
                }
            }

            public virtual void WypiszInfo()
            {
                Console.WriteLine("[INFO O  ZWIERZAKU] GATUNEK: " + gatunek + ". ROD. POZYWIENIA: " + rodzajPozywienia + ". POCHODZENIE: " + pochodzenie);
            }

        };

        class Ptak : Zwierze {
            private double rozpietoscSkrzydel = 0.0, wytrzymalosc = 0.0;

            public Ptak(): base()
            {
                rozpietoscSkrzydel = wytrzymalosc = 0.0;
            }

            public Ptak(int rozpietoscSkrzydel_, int wytzymalosc_, string gatunek, string rodzajPozywienia, string pochodzenie) : base(gatunek, rodzajPozywienia, pochodzenie)
            {
                rozpietoscSkrzydel = rozpietoscSkrzydel_;
                wytrzymalosc = wytzymalosc_;
            }

            public double MaksymalnaDlugoscLotu()
            {
                return rozpietoscSkrzydel * wytrzymalosc;
            }

            public void WypiszInfo(bool InfoCechy_, bool InfoUmietnosci_)
            {
                Console.WriteLine("\n[INFO O PTAKU] ROZPIETOSCSKRZYDEL: " + rozpietoscSkrzydel + ". WYTRZYMALOSC: " + wytrzymalosc);
                Console.WriteLine("[INFO O PTAKU] GATUNEK: " + gatunek + ". RODZ.POZYWIENIA: " + rodzajPozywienia + ". POCHODZENIE: " + pochodzenie);
                if (InfoCechy_)
                    InfoCechy();
                if (InfoUmietnosci_)
                    InfoUmietnosci();
            }

        }




        class Ssak: Zwierze {
            private string naturalneSrodowisko = " ";

            public Ssak(): base()
            {
                naturalneSrodowisko = "nieznane";
            }

            public Ssak(string naturalneSrodowisko_, string gatunek, string rodzajPozywienia, string pochodzenie) : base(gatunek, rodzajPozywienia, pochodzenie)
            {
                naturalneSrodowisko = naturalneSrodowisko_;
            }


            public void WypiszInfo(bool InfoCechy_, bool InfoUmietnosci_)
            {
                Console.WriteLine("\n[INFO O SSAKU] NATURALNE SRODOWISKO: " + naturalneSrodowisko);
                Console.WriteLine("[INFO O SSAKU] GATUNEK: " + gatunek + ". RODZ.POZYWIENIA: " + rodzajPozywienia + ". POCHODZENIE: " + pochodzenie);
                if (InfoCechy_)
                    InfoCechy();
                if (InfoUmietnosci_)
                    InfoUmietnosci();
            }

        }



        class Gad: Zwierze {
            private bool czyJadowity = false;
            public Gad(): base()
            {
                czyJadowity = false;
            }

            public Gad(bool czyJadowity_ , string gatunek, string rodzajPozywienia, string pochodzenie) : base(gatunek, rodzajPozywienia, pochodzenie)
            {
                czyJadowity = czyJadowity_;
            }

            public  void WypiszInfo(bool InfoCechy_, bool InfoUmietnosci_)
            {
                if(czyJadowity)
                    Console.WriteLine("\n[INFO O GADZIE] JADOWITOSC: TAK" );
                else
                    Console.WriteLine("\n[INFO O GADZIE] JADOWITOSC: NIE");
                Console.WriteLine("[INFO O GADZIE] GATUNEK: " + gatunek + ". RODZ.POZYWIENIA: " + rodzajPozywienia + ". POCHODZENIE: " + pochodzenie);
                if (InfoCechy_)
                    InfoCechy();
                if (InfoUmietnosci_)
                    InfoUmietnosci();
            }

        }




        static void Main(string[] args)
        {
            Generatory g = new Generatory();
            Dyrekcja dyrekcja = new Dyrekcja();
            Klatka klatka = new Klatka(g.GenerujLiczbe(200));
            Ptak ptak = new Ptak(g.GenerujLiczbe(5, 10), g.GenerujLiczbe(10, 500), g.GenerujGatunekPtaka(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());
            Gad gad = new Gad(g.GenerujBool(), g.GenerujGatunekGada(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());
            Ssak ssak = new Ssak(g.GenerujSrodowiskoNaturalne(), g.GenerujGatunekSsaka(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());

            for (int i = 0; i < 60; i++)
                dyrekcja.ZbudujKlatke(g.GenerujLiczbe(20, 400));

            dyrekcja.InfoKlatki();
            dyrekcja.PowiekszKlatke(2, 11111);
            dyrekcja.InfoKlatki();







            // tworze po 20 przedstawicielow ptakow, ssakow i gadow. Rejestruje ich w zoo
            /*for (int i = 0; i < 20; i++)
            {
               dyrekcja.ZarejestrujPtaka(g.GenerujLiczbe(5, 10), g.GenerujLiczbe(10, 500), g.GenerujGatunekPtaka(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());
               dyrekcja.ZarejestrujSsaka(g.GenerujSrodowiskoNaturalne(), g.GenerujGatunekSsaka(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());
               dyrekcja.ZarejestrujGada(g.GenerujBool(), g.GenerujGatunekGada(), g.GenerujRodzajPozywienia(), g.GenerujKrajPochodzenia());

            }*/

            dyrekcja.PrzypiszKlatke(ptak, 2);

            // -- > testy dodawania cech/umietnosci na osobnych objektach, sterowanie wypisywaniem informacji,
           /* ptak.DodajCeche("czarny");
            ptak.DodajUmietnosc("dzwiek BZZZ");
            ssak.DodajUmietnosc("dzwiek SSSSS");
            ptak.WypiszInfo(true, true);
            double dlugoscLotu = ptak.MaksymalnaDlugoscLotu();
            Console.WriteLine("Maksymalna dlugosc lotu ptaka " + ptak.Gatunek + " to " + dlugoscLotu); //
            gad.WypiszInfo(false, false);
            ssak.WypiszInfo(false, true); */





            Console.WriteLine("\n.. console successfully runned");
            Console.ReadKey();
        }

        partial class Generatory
        {
            private Random rnd = new Random();
            private String[] rodzajePozywienia = new String[5]  {
              new String("ROSLINOZERCY"),
              new String("MIESOZERCY"),
              new String("WSZYSTKOZERCY"),
              new String("PASOZYTY"),
              new String("SAPROFAGI")
            };

            private String[] gatunkiOgolne = new string[28]
            {
              new String("JEZ WSCHODNI"),
              new String("KRET EUROPEJSKI"),
              new String("ZABIELEK BIALAWY"),
              new String("RYJOWKA AKSAMITNA"),
              new String("RZESOREK RZECEK"),
              new String("PODKOWIEC MALY"),
              new String("MOPEK"),
              new String("NOCEK"),
              new String("BOROWIEC"),
              new String("KARLIK"),
              new String("ZOLW"),
              new String("JASZCZURKA"),
              new String("ZABIELEK BIALAWY"),
              new String("PADALEC"),
              new String("ZASKRONIEC"),
              new String("WAZ"),
              new String("GNIEWOSZ"),
              new String("ZMIJA ZYGZAKOWATA"),
              new String("CZYZ"),
              new String("DROZDZIK"),
              new String("GIL"),
              new String("MAZUREK"),
              new String("SROKA"),
              new String("SZPAK"),
              new String("WROBEL"),
              new String("GRZYWACZ"),
              new String("KROGULEC"),
              new String("KOS")
            };

            private String[] pochodzenia = new String[6]  {
              new String("EUROPA ZACHODNIA"),
              new String("EUROPA WSCHODNIA"),
              new String("AFRYKA"),
              new String("AUSTRALIA POLNOCNA"),
              new String("POLNOCNA AMERYKA"),
              new String("KRAJE AMERYKI POLUDNIOWEJ")
            };

            private String[] srodowiskaNaturalne = new String[4]  {
              new String("MROZNY OBSZAR"),
              new String("GORACY TROPIK"),
              new String("PODZIEMNE"),
              new String("PODWODNE")
            };

            public bool GenerujBool()
            {
                return Convert.ToBoolean(rnd.Next(2));
            }

            public string GenerujGatunekPtaka()
            {
                return gatunkiOgolne[rnd.Next(18, 28)];
            }
            public string GenerujGatunekGada()
            {
                return gatunkiOgolne[rnd.Next(10, 18)];
            }

            public string GenerujGatunekSsaka()
            {
                return gatunkiOgolne[rnd.Next(10)];
            }

            public string GenerujRodzajPozywienia()
            {
                return rodzajePozywienia[rnd.Next(5)];
            }

            public string GenerujKrajPochodzenia()
            {
                return pochodzenia[rnd.Next(6)];
            }

            public string GenerujSrodowiskoNaturalne()
            {
                return srodowiskaNaturalne[rnd.Next(4)];
            }

            public int GenerujLiczbe(int limitGorny)
            {
                return rnd.Next(0, limitGorny);
            }

            public int GenerujLiczbe(int limitDolny, int limitGorny)
            {

                return rnd.Next(limitDolny, limitGorny);
            }

        }

    }


}