Funkcje w C# – dziel i rządź

// Schemat ogólny:
[modyfikator] [typ zwracany] [NazwaFunkcji]([parametry])
{
    // ciało funkcji - kod do wykonania
    return [wartość];  // jeśli typ != void
}

// Przykład konkretny:
static int Dodaj(int a, int b)
{
    int wynik = a + b;
    return wynik;
}

// Definicja funkcji
static void PowitajUzytkownika()
{
    Console.WriteLine("Witaj w programie!");
    Console.WriteLine("Miłego dnia!");
}

// Wywołanie w Main():
PowitajUzytkownika();  // Wyświetli dwie linie
PowitajUzytkownika();  // Można wywołać wielokrotnie!

// Funkcja przyjmuje imię jako parametr
static void PowitajOsobe(string imie)
{
    Console.WriteLine($"Witaj {imie}!");
}

// Wywołania z różnymi argumentami:
PowitajOsobe("Anna");   // Witaj Anna!
PowitajOsobe("Marek");  // Witaj Marek!
PowitajOsobe("Ola");    // Witaj Ola!

// Funkcja zwraca int – typ przed nazwą!
static int Dodaj(int a, int b)
{
    int wynik = a + b;
    return wynik;  // Zwraca wartość
}

// Wywołanie – wynik zapisujemy do zmiennej:
int suma = Dodaj(5, 3);
Console.WriteLine($"Suma: {suma}");  // Suma: 8

// Można też użyć bezpośrednio:
Console.WriteLine(Dodaj(10, 20));  // 30

// Funkcja sprawdzająca warunek – zwraca true/false
static bool CzyPelnoletni(int wiek)
{
    return wiek >= 18;  // Zwraca wynik porównania
}

// Użycie w warunku if:
if (CzyPelnoletni(20))
{
    Console.WriteLine("Osoba jest pełnoletnia");
}

// Lub zapisanie do zmiennej:
bool pelnoletni = CzyPelnoletni(16);  // false

static void WypiszDane(string imie, int wiek, double wzrost)
{
    Console.WriteLine($"Imię: {imie}");
    Console.WriteLine($"Wiek: {wiek}");
    Console.WriteLine($"Wzrost: {wzrost}m");
}

// Wywołanie – kolejność argumentów musi się zgadzać!
WypiszDane("Anna", 17, 1.65);

// "powitanie" ma wartość domyślną "Cześć"
static void WypiszPowitanie(string imie, string powitanie = "Cześć")
{
    Console.WriteLine($"{powitanie}, {imie}!");
}

// Różne sposoby wywołania:
WypiszPowitanie("Anna");                    // Cześć, Anna!
WypiszPowitanie("Anna", "Witaj");           // Witaj, Anna!
WypiszPowitanie("Marek", "Dzień dobry");    // Dzień dobry, Marek!

// Rabat domyślnie 0%, VAT domyślnie 23%
static double ObliczCene(double cenaBazowa, double rabat = 0, double vat = 23)
{
    double cenaPoRabacie = cenaBazowa - (cenaBazowa * rabat / 100);
    double cenaZVat = cenaPoRabacie + (cenaPoRabacie * vat / 100);
    return cenaZVat;
}

// Wywołania:
double cena1 = ObliczCene(100);            // 100zł, 0% rabatu, 23% VAT = 123zł
double cena2 = ObliczCene(100, 10);        // 100zł, 10% rabatu, 23% VAT = 110.7zł
double cena3 = ObliczCene(100, 10, 8);    // 100zł, 10% rabatu, 8% VAT = 97.2zł

// BEZ ref – zmienia tylko kopię
static void ZwiekszBezRef(int liczba)
{
    liczba++;  // Zmienia KOPIĘ
}

// Z ref – zmienia oryginał
static void ZwiekszZRef(ref int liczba)
{
    liczba++;  // Zmienia ORYGINAŁ
}

// Test:
int a = 5;
ZwiekszBezRef(a);
Console.WriteLine(a);  // 5 – BEZ ZMIAN!

int b = 5;
ZwiekszZRef(ref b);  // UWAGA: "ref" też przy wywołaniu!
Console.WriteLine(b);  // 6 – ZMIENIONE!

static void ZamienWartosci(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

int x = 5, y = 10;
Console.WriteLine($"Przed: x={x}, y={y}");  // x=5, y=10

ZamienWartosci(ref x, ref y);

Console.WriteLine($"Po: x={x}, y={y}");     // x=10, y=5

class Program
{
    // Zmienna na poziomie klasy – dostępna wszędzie w klasie
    static int liczbaGlobalna = 10;

    static void PrzykladZakresu()
    {
        // Zmienna lokalna – dostępna tylko w tej funkcji
        int liczbaLokalna = 5;

        Console.WriteLine(liczbaGlobalna);  // ✅ OK
        Console.WriteLine(liczbaLokalna);   // ✅ OK
    }

    static void Main()
    {
        Console.WriteLine(liczbaGlobalna);  // ✅ OK
        // Console.WriteLine(liczbaLokalna); // ❌ BŁĄD! Nie istnieje tutaj
    }
}

// Ta sama nazwa "Policz", różne parametry:

// Wersja dla dwóch int
static int Policz(int a, int b)
{
    return a + b;
}

// Wersja dla dwóch double
static double Policz(double a, double b)
{
    return a + b;
}

// Wersja dla trzech int
static int Policz(int a, int b, int c)
{
    return a + b + c;
}

// Wywołania – kompilator wybiera właściwą wersję:
int w1 = Policz(5, 3);         // Wersja int, int
double w2 = Policz(5.5, 3.2);  // Wersja double, double
int w3 = Policz(1, 2, 3);      // Wersja int, int, int