namespace UnityAPIReference
{

    using UnityEngine;
    using UnityEngine.SceneManagement; // WICHTIG: Für den Szenen-Wechsel
    using UnityEngine.UI;              // WICHTIG: Für klassische UI (Text, Buttons)

    public class UnityAPIReferenz : MonoBehaviour
    {
        [Header("Referenzen auf andere Komponenten")]
        public Rigidbody meinRigidbody;
        public Renderer meinRenderer;
        public AudioSource meineAudioquelle;
        public Animator meinAnimator;
        public Light meinLicht;
        public Text meinUI_Text;

        void Start()
        {
            // ========================================================================
            // 1. DAS EIGENE GAMEOBJECT KONTROLLIEREN
            // ========================================================================

            // Das Objekt komplett de-aktivieren (verschwindet aus der Welt, Updates stoppen)
            gameObject.SetActive(false);
            gameObject.SetActive(true);

            // Namen und Tag auslesen oder ändern
            gameObject.name = "Neuer_Name_im_Inspector";
            gameObject.tag = "Player"; // (Achtung: Der Tag muss im Editor existieren!)

            // Das Objekt nach 3 Sekunden komplett aus dem Speicher löschen
            Destroy(gameObject, 3f);


            // ========================================================================
            // 2. TRANSFORM (Position, Rotation, Skalierung & Hierarchie)
            // Transform hat JEDES GameObject standardmäßig.
            // ========================================================================

            // Position setzen (Vector3 = X, Y, Z Koordinaten)
            transform.position = new Vector3(0, 5, 0); // Absolute Welt-Position
            transform.localPosition = new Vector3(0, 0, 0); // Position relativ zum "Eltern-Objekt"

            // Rotation setzen (Quaternion ist komplex, daher nutzen wir Euler-Winkel in Grad)
            transform.rotation = Quaternion.Euler(0, 90, 0); // Dreht das Objekt um 90 Grad auf der Y-Achse

            // Skalierung (Größe) ändern
            transform.localScale = new Vector3(2, 2, 2); // Macht das Objekt doppelt so groß

            // Direkte Bewegungen (ohne Physik!)
            transform.Translate(Vector3.forward * 5f); // 5 Meter nach vorne schieben
            transform.Rotate(Vector3.up, 45f);         // Um 45 Grad drehen

            // Hierarchie (Parenting) ändern
            // transform.SetParent(anderesGameObject.transform); // Hängt dieses Objekt an ein anderes an
            transform.SetParent(null); // Macht das Objekt wieder komplett unabhängig (Root-Ebene)


            // ========================================================================
            // 3. KOMPONENTEN FINDEN UND AUSLESEN (Sehr wichtig!)
            // ========================================================================

            // Holt die Komponente "BoxCollider", die auf demselben GameObject liegt
            BoxCollider meinCollider = GetComponent<BoxCollider>();
            if (meinCollider != null)
            {
                meinCollider.enabled = false; // Schaltet die Kollision ab
            }

            // ========================================================================
            // 4. PHYSIK (Rigidbody)
            // ========================================================================

            if (meinRigidbody != null)
            {
                // Einen Impuls-Schub geben (z.B. für einen Sprung oder eine Explosion)
                meinRigidbody.AddForce(Vector3.up * 500f, ForceMode.Impulse);

                // Die aktuelle Geschwindigkeit direkt überschreiben oder auslesen
                meinRigidbody.linearVelocity = new Vector3(0, 10, 0);

                // Schwerkraft für dieses Objekt deaktivieren
                meinRigidbody.useGravity = false;

                // Masse ändern
                meinRigidbody.mass = 50f;

                // IsKinematic: Wenn true, wird das Objekt NICHT mehr von Physik (Schwerkraft/Stöße) 
                // beeinflusst, kann aber per Skript bewegt werden und rammt andere Objekte weg.
                meinRigidbody.isKinematic = true;
            }

            // ========================================================================
            // 5. GRAFIK & MATERIALIEN (Renderer)
            // ========================================================================

            if (meinRenderer != null)
            {
                // Das Objekt unsichtbar machen (es bleibt aber da und hat noch Kollision!)
                meinRenderer.enabled = false;

                // Die Farbe des Materials ändern
                meinRenderer.material.color = Color.red; // Standard-Farben
                meinRenderer.material.color = new Color(0.5f, 0.2f, 0.8f, 1f); // RGBA (Rot, Grün, Blau, Alpha/Transparenz)
            }

            // ========================================================================
            // 6. AUDIO & SOUNDS
            // ========================================================================

            if (meineAudioquelle != null)
            {
                meineAudioquelle.volume = 0.5f; // Lautstärke (0.0 bis 1.0)
                meineAudioquelle.pitch = 1.2f;  // Tonhöhe (1.0 = normal, < 1 = tiefer/langsamer)
                meineAudioquelle.Play();        // Sound abspielen
                meineAudioquelle.Stop();        // Sound stoppen
            }

            // ========================================================================
            // 7. ANIMATIONEN (Animator)
            // Setzt Parameter, die du im Animator-Fenster definiert hast
            // ========================================================================

            if (meinAnimator != null)
            {
                meinAnimator.SetBool("IsRunning", true);    // Eine Checkbox umschalten
                meinAnimator.SetFloat("Speed", 5.5f);       // Einen Komma-Wert übergeben
                meinAnimator.SetTrigger("Jump");            // Einen einmaligen Impuls feuern
            }

            // ========================================================================
            // 8. LICHT
            // ========================================================================

            if (meinLicht != null)
            {
                meinLicht.intensity = 10f; // Helligkeit
                meinLicht.color = Color.yellow; // Lichtfarbe
                meinLicht.range = 50f; // Reichweite des Lichts
            }

            // ========================================================================
            // 9. ZEIT KONTROLLIEREN (Time-Klasse)
            // ========================================================================

            // Zeitlupen-Effekt (0.5 = halbe Geschwindigkeit, 0 = Spiel pausiert!)
            // Time.timeScale = 0.5f; 

            // Wieviel Zeit seit Spielstart vergangen ist (in Sekunden)
            float zeit = Time.time;

            // ========================================================================
            // 10. SZENEN & LEVEL WECHSELN
            // ========================================================================

            // Lädt die Szene mit dem Namen "Level_02" (Muss in den Build-Settings hinzugefügt sein!)
            // SceneManager.LoadScene("Level_02"); 

            // Lädt die aktuelle Szene neu (z.B. nach einem Game Over)
            // SceneManager.LoadScene(SceneManager.GetActiveScene().name); 

            // ========================================================================
            // 11. HILFS-MATHEMATIK (Die Unity Mathf Klasse)
            // ========================================================================

            // Clamp: Begrenzt einen Wert auf ein Minimum und Maximum
            float lebenspunkte = 150f;
            lebenspunkte = Mathf.Clamp(lebenspunkte, 0f, 100f); // Setzt den Wert zwingend auf max 100 zurück

            // Random: Eine Zufallszahl generieren
            int zufallsZahl = Random.Range(1, 10); // Zahl zwischen 1 und 9 (Int-Maximum ist exklusiv!)
            float zufallsKomma = Random.Range(0f, 5.5f); // Float-Maximum ist inklusiv.

            // Lerp (Linear Interpolation): Einen sanften Übergang zwischen zwei Werten berechnen
            // Hier: Berechne den Wert genau in der Mitte (0.5f) zwischen 10 und 20 -> Ergebnis: 15
            float sanfterWert = Mathf.Lerp(10f, 20f, 0.5f);
        }
    }
}