using System;

namespace _01KlassenWiederholung
{
    class Person
    {
        // Datenfelder/Member pro Objekt (OHNE Angabe von static)
        private string name;
        private string vorname;
        public int Alter3 { get; private set; }
        // Legt eine anonyme Variable an ~alter4711
        // plus eine öffentliche get-Methode plus eine private set-Methode
        private string telNr;
        private readonly int steuerIdentNummer=100;
        // readonly = Diese Variable darf nur im Konstruktor geändert werden
        //private DateTime gebDatum;


        // static Member/static Datenfelder (MIT Angabe von static)
        // Kommen nur einmal pro Klasse vor
        private static int naechsteIdentnummer = 0;
        private static Person[] personen = new Person[1000];


        // get ~ gezielte Umgehung des private-Schutzes; liefert Wert zurück
        //       Name ("get") ist ohne Bedeutung
        private int alter;
        public int getAlter()
        {
            return alter;
        }
        // Alternative Schreibweise: Lambda-Ausdruck
        public int getAlter2() => alter;   // => ~ "wird abgebildet auf"

        // set ~ gezielte Umgehung des private Schutzes; setzt den Wert, 
        //       ermöglicht aber eine Wertebereichsüberprüfung
        //       Name ("set") ist wieder ohne Bedeutung
        public void setAlter(int wert)
        {
            if (wert < 0)
                throw new ArgumentOutOfRangeException("Alter muss > 0 sein");
            alter = wert;
        }
        // get&set in alternativer Schreibweise, zusammen als PROPERTY
        //   get und set sind optional, d.h. können auch entfallen
        public int Alter
        {
            get { return alter; }
            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("Alter muss > 0 sein");
                alter = value;
            }
        }
        public int Alter2
        {
            get { return alter; }
            set { alter = value; }
        }
        // Automatisches Property für spätere Erweiterbarkeit
        public int Alter4 { get; private set; }
        // Öffentliches get, privates set

        static Person() 
        {
            Console.WriteLine("Statischer Konstruktor");
            naechsteIdentnummer = 100;
        }
        public Person(int stId)
        {
            steuerIdentNummer = stId;
            personen[naechsteIdentnummer++] = this;

        }
        // Konstruktor Person
        public Person(string name, string Vorname, int Alter, string TelNr = "")
        {
            this.name = name;
            vorname = Vorname;
            if (Alter < 0)
                throw new ArgumentOutOfRangeException("Das Alter muss >= 0 sein");
            Alter2 = Alter;
            telNr = TelNr;
            steuerIdentNummer = naechsteIdentnummer;

            personen[naechsteIdentnummer] = this;
            naechsteIdentnummer++;
        }
        // STATIC oder NICHT-STATIC???
        //public void SetzeIdentnummer(int nummer)
        //{
        //    if (nummer < naechsteIdentnummer)
        //        throw new ArgumentException("Falsche neue Identnummer");
        //    naechsteIdentnummer = nummer;
        //}
        public static void SetzeIdentnummer(int nummer)
        {
            if (nummer < naechsteIdentnummer)
                throw new ArgumentException("Falsche neue Identnummer");
            naechsteIdentnummer = nummer;
        }

        // static oder nichts (d.h. nicht-static)
        //      static: FUNKTION (z.B. Sqrt(25) --> 5) mit ihren Parametern
        //      nicht-static: METHODE (z.B. void Ausgabe() ), erhält zusätzlich
        //          zu ihren Parametern noch einen - impliziten - Zeiger
        //          auf das Objekt
        // Rückgabetyp der Funktion (z.B. int, double, void,
        //     aber auch der Klassenname ist zulässig)
        // ----- Funktions-/Methodenname
        // Parameter jeweils mit Datentyp

        public static void Ausgabe(Person p)
        {
            Console.WriteLine($"Name: {p.name}, Vorname: {p.vorname}");
        }
        public void Ausgabe()
        {
            Console.WriteLine($"Name: {name}, Vorname: {vorname}");
            //Console.WriteLine($"Name: {this.name}, Vorname: {this.vorname}");
        }
        public override string ToString() => $"Name: {name}, Vorname: {vorname}";
      

    }


    // Bis hierher PROGRAMMIERER 1
    // =======================================================
    // Ab hier:    PROGRAMMIERER 2



    //class Vereinsmitglied
    //{
    //    Person mitglied;
    //    DateTime eintrittsdatum;
    //    bool mitgliedsbeitragBezahlt;
    //}

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine("Programmstart");
            //anton.SetzeIdentnummer(1000000); -- geht nicht, da anton noch nicht existiert
            //Person.SetzeIdentnummer(1000000);
            Console.WriteLine("Hier sind wir ...");
            Person anton = new Person("Müller", "Anton", 23);
            
            Console.WriteLine($"Anton: {anton}");
            anton.setAlter(24);
            anton.setAlter(anton.getAlter() + 1);
            Console.WriteLine(anton.Alter);
            anton.Alter = 24;
            anton.Alter += 1;
            Console.WriteLine($"Anton: {anton}");

            Person.Ausgabe(anton);
            // Aufruf als Funktion (static): Klassenname.Funktionsname()
            anton.Ausgabe();
            // Aufruf als Methode (nicht-static): Objektvar.Methodenname()


            Person[] persFeld = new Person[5];
            //// Feld mit 5 Referenzen auf Personen-Objekte
            persFeld[0] = new Person("Meier", "Dieter", 25);
            //// Für Eintrag 1 Speicher für eine Person anfordern

            Person claudia = new Person("Schuster", "Claudia", 23, "0911-234567");
            persFeld[1] = claudia;

            Console.WriteLine(anton);
            Console.WriteLine(persFeld[0]);
            Console.WriteLine(Math.PI.ToString());
        }
    }

}