C# మెథడ్స్ & పారామీటర్ మోడిఫైయర్స్ (ref, out, in, params)

// సరళమైన వడ్డీ (Simple Interest) లెక్కించే మెథడ్
decimal CalculateInterest(decimal principal, decimal rate, int timeYears)
{
    decimal totalInterest = (principal * rate * timeYears) / 100m;
    return totalInterest; // రిటర్న్ స్టేట్‌మెంట్
}

// మెథడ్ కాల్ చేయడం (Invocation)
decimal myInterest = CalculateInterest(100000m, 8.5m, 3);
Console.WriteLine($"3 సంవత్సరాల వడ్డీ: ₹{myInterest:N2}");

void AttemptToChange(int score)
{
    score = score + 50; // కేవలం లోకల్ కాపీ మాత్రమే మారుతుంది
    Console.WriteLine($"మెథడ్ లోపల స్కోర్: {score}"); // 150
}

int originalScore = 100;
AttemptToChange(originalScore);
Console.WriteLine($"మెథడ్ బయట అసలు స్కోర్: {originalScore}"); // 100 మాత్రమే మిగిలింది!

// రెండు వేరియబుల్స్ విలువలను తారుమారు చేసే (Swap) ప్రసిద్ధ మెథడ్
void Swap(ref int first, ref int second)
{
    int temp = first;
    first = second;
    second = temp;
}

int a = 10, b = 20;
Console.WriteLine($"మార్చకముందు: a = {a}, b = {b}");

// కాల్ చేసేటప్పుడు కూడా తప్పనిసరిగా 'ref' రాయాలి!
Swap(ref a, ref b);

Console.WriteLine($"మార్చిన తర్వాత: a = {a}, b = {b}"); // a = 20, b = 10 అయింది!

void CalculateCircle(double radius, out double area, out double circumference)
{
    area = Math.PI * radius * radius;
    circumference = 2 * Math.PI * radius;
}

// C# 7+ Inline Out Variable Declaration: ముందే వేరియబుల్స్ డిక్లేర్ చేయక్కర్లేదు!
CalculateCircle(7.0, out double circleArea, out double circleCircumference);

Console.WriteLine($"వృత్త వైశాల్యం (Area): {circleArea:F2}");
Console.WriteLine($"చుట్టుకొలత (Circumference): {circleCircumference:F2}");

readonly struct SystemCoordinate
{
    public double X { get; }
    public double Y { get; }
    public double Z { get; }
    public SystemCoordinate(double x, double y, double z) => (X, Y, Z) = (x, y, z);
}

// 'in' వాడటం వల్ల భారీ struct కాపీ అవ్వదు, కానీ రీడ్-ఓన్లీ రక్షణ ఉంటుంది
double MeasureDistance(in SystemCoordinate point)
{
    // point.X = 50; // ❌ కంపైల్ ఎర్రర్ వస్తుంది! 'in' పారామీటర్‌ను మార్చలేరు!
    return Math.Sqrt(point.X * point.X + point.Y * point.Y + point.Z * point.Z);
}

// ఎన్నైనా పూర్ణాంకాలను స్వీకరించి కూడే మెథడ్
int SumNumbers(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers) total += n;
    return total;
}

// విభిన్న సంఖ్యలలో ఆర్గ్యుమెంట్స్ పంపడం:
Console.WriteLine($"2 సంఖ్యల కూడిక: {SumNumbers(10, 20)}");
Console.WriteLine($"5 సంఖ్యల కూడిక: {SumNumbers(1, 2, 3, 4, 5)}");
Console.WriteLine($"ఏమీ పంపకపోయినా పనిచేస్తుంది: {SumNumbers()}"); // 0

// 1. Expression-Bodied Method (అత్యంత క్లీన్)
int Square(int x) => x * x;
bool IsEven(int x) => x % 2 == 0;

// 2. Local Function (ఒక మెథడ్ లోపల మాత్రమే పనిచేసే అంతర్గత ఫంక్షన్)
void ProcessUserData()
{
    string user = "  సురేష్  ";
    
    // లోకల్ ఫంక్షన్: కేవలం ProcessUserData పరిధిలో మాత్రమే కనిపిస్తుంది
    string Clean(string s) => s.Trim().ToUpper();
    
    Console.WriteLine($"శుభ్రపరిచిన యూజర్ నేమ్: {Clean(user)}");
}

ProcessUserData();

long Factorial(int n)
{
    // బేస్ కేస్: 0! లేదా 1! విలువ 1
    if (n <= 1) return 1;
    
    // రికార్సివ్ స్టెప్: n * (n - 1)!
    return n * Factorial(n - 1);
}

Console.WriteLine($"5 యొక్క ఫ్యాక్టోరియల్ (5!): {Factorial(5)}"); // 120

using System;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("🏢 మన కార్పొరేట్ - స్మార్ట్ పేరోల్ & టాక్స్ ఇంజిన్ v1.0");
Console.WriteLine("=================================================\n");

// కంపెనీ పాలసీ స్ట్రక్ట్ (స్థిరమైన నియమాలు)
struct CompanyTaxPolicy
{
    public decimal PfRate { get; }
    public decimal ProfessionalTax { get; }
    public CompanyTaxPolicy(decimal pf, decimal pt) => (PfRate, ProfessionalTax) = (pf, pt);
}

// 1. అలవెన్సుల కూడిక (params keyword)
decimal CalculateAllowances(params decimal[] allowances)
{
    decimal sum = 0m;
    foreach (decimal a in allowances) sum += a;
    return sum;
}

// 2. పేరోల్ గణన మెథడ్ (in, out, ref కలయిక)
void ProcessSalarySlip(
    string empName,
    decimal basicPay,
    in CompanyTaxPolicy policy,     // 'in' రీడ్-ఓన్లీ పాలసీ
    out decimal deductions,         // 'out' టాక్స్ తగ్గింపులు
    out decimal netSalary,          // 'out' టేక్-హోమ్ శాలరీ
    ref decimal companyBankReserves,// 'ref' కంపెనీ అకౌంట్ నుండి డబ్బు కటింగ్
    params decimal[] allowances)    // 'params' అదనపు బోనస్‌లు
{
    decimal totalAllowances = CalculateAllowances(allowances);
    decimal grossSalary = basicPay + totalAllowances;

    // కటింగులు: PF (12%) + వృత్తి పన్ను (PT)
    decimal pfAmount = basicPay * (policy.PfRate / 100m);
    deductions = pfAmount + policy.ProfessionalTax;

    netSalary = grossSalary - deductions;

    // కంపెనీ బ్యాంక్ బ్యాలెన్స్ నుండి నెట్ శాలరీ డెబిట్ చేయడం (ref)
    companyBankReserves -= netSalary;

    Console.WriteLine($"జీతం స్లిప్ జెనరేట్ చేయబడింది: {empName}");
    Console.WriteLine($"గ్రాస్ శాలరీ       : ₹{grossSalary:N2}");
    Console.WriteLine($"మొత్తం తగ్గింపులు: ₹{deductions:N2} (PF: ₹{pfAmount:N2})");
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine($"టేక్-హోమ్ శాలరీ : ₹{netSalary:N2}");
    Console.ResetColor();
}

// ప్రాజెక్ట్ ఎగ్జిక్యూషన్
decimal companyFunds = 1000000.00m; // కంపెనీ బ్యాలెన్స్ ₹10 లక్షలు
var standardPolicy = new CompanyTaxPolicy(pf: 12.0m, pt: 200.0m);

Console.WriteLine($"ప్రారంభ కంపెనీ నిధులు: ₹{companyFunds:N2}\n");

// ఉద్యోగి 1 కి పేరోల్ ప్రాసెస్ చేయడం
ProcessSalarySlip(
    "శ్రీకాంత్ వర్మ (సీనియర్ ఆర్కిటెక్ట్)",
    basicPay: 85000m,
    standardPolicy,
    out decimal srikanthDeductions,
    out decimal srikanthNet,
    ref companyFunds,
    15000m, 5000m, 2500m // HRA, మెడికల్, ఇంటర్నెట్ అలవెన్సులు (params)
);

Console.WriteLine($"\nశాలరీ పంపిణీ తర్వాత మిగిలిన కంపెనీ నిధులు: ₹{companyFunds:N2}");
Console.WriteLine("=================================================\n");