public class Bil
{
    public string Marke { get; set; }
    public int Hastighet { get; set; }

    public Bil(string marke, int hastighet)
    {
        Marke = marke;
        Hastighet = hastighet;
    }

    public void Kora() => Console.WriteLine($"{Marke} kör!");
}

// Skapa objekt
var b1 = new Bil("Volvo", 120);
var b2 = new Bil("Tesla", 250);
b1.Kora(); // "Volvo kör!"

public class BankKonto
{
    private decimal _saldo;          // ingen utanför klassen ser detta

    public decimal Saldo             // property – kontrollerad åtkomst
    {
        get => _saldo;
        private set => _saldo = value >= 0 ? value : 0;
    }

    public void SattIn(decimal belopp)
    {
        if (belopp > 0) Saldo += belopp;
    }

    public bool TaUt(decimal belopp)
    {
        if (belopp > Saldo) return false;
        Saldo -= belopp;
        return true;
    }
}

var konto = new BankKonto();
konto.SattIn(1000);
konto.TaUt(200);
// konto._saldo = -999; ← KOMPILERINGSFEL! private

public class Djur
{
    public string Namn { get; set; }
    public int Alder { get; set; }

    public void At() => Console.WriteLine($"{Namn} äter.");
    public virtual void LaterLjud() => Console.WriteLine("...");
}

public class Hund : Djur        // Hund ärver Djur
{
    public string Ras { get; set; }
    public override void LaterLjud() => Console.WriteLine("Vov!");
}

public class Katt : Djur
{
    public override void LaterLjud() => Console.WriteLine("Mjau!");
}

var h = new Hund { Namn = "Fido", Ras = "Labrador" };
h.At();        // "Fido äter."   ← ärvd från Djur
h.LaterLjud(); // "Vov!"         ← overridad i Hund

// Polymorfism — en lista med blandade djur
List<Djur> djur = new()
{
    new Hund { Namn = "Fido" },
    new Katt { Namn = "Misse" },
    new Fagel { Namn = "Tweety" }
};

foreach (var d in djur)
{
    d.LaterLjud(); // C# väljer rätt metod automatiskt!
}
// Vov!
// Mjau!
// Tweet!

// Overloading — samma namn, olika parametrar
public void Skriv(int tal)    => Console.WriteLine(tal);
public void Skriv(string text) => Console.WriteLine(text);
public void Skriv(int x, int y) => Console.WriteLine($"{x},{y}");

public interface INotifierare
{
    void SkickaNotis(string meddelande);
    bool ArTillganglig();
}

public class EpostNotifierare : INotifierare
{
    public void SkickaNotis(string med) => SendEmail(med);
    public bool ArTillganglig() => true;
}

public class SmsNotifierare : INotifierare
{
    public void SkickaNotis(string med) => SendSms(med);
    public bool ArTillganglig() => CheckSmsGateway();
}

// Din service beror bara på interfacet — lätt att byta!
public class OrderService
{
    private readonly INotifierare _notis;
    public OrderService(INotifierare notis) => _notis = notis; // DI
    public void PlaceraOrder() => _notis.SkickaNotis("Order klar!");
}

public abstract class Rapport
{
    public string Titel { get; set; }

    // Klar metod – används av ALLA subklasser
    public void SkrivUt()
    {
        Console.WriteLine($"=== {Titel} ===");
        Console.WriteLine(GenereraInnehall()); // anropar subklassens version
    }

    // Abstrakt – MÅSTE overridas av subklassen
    public abstract string GenereraInnehall();
}

public class PdfRapport : Rapport
{
    public override string GenereraInnehall() => "PDF-formaterat innehall...";
}

public class ExcelRapport : Rapport
{
    public override string GenereraInnehall() => "Excel-formaterat innehall...";
}

var r = new PdfRapport { Titel = "Arsredovisning" };
r.SkrivUt();
// === Arsredovisning ===
// PDF-formaterat innehall...

Regel: om en metod gör I/O (DB, HTTP, fil) – gör den async. Annars blockerar du tråden i onödan.

// SYNKRONT – blockerar tråden
public string HämtaData()
{
    var result = db.Users.ToList();  // tråden väntar här
    return result;
}

// ASYNKRONT – frigörs tråden under väntan
public async Task<List<User>> HämtaDataAsync(CancellationToken ct)
{
    var result = await db.Users.ToListAsync(ct);  // tråden är fri!
    return result;
}

// Parallellt – flera saker samtidigt
public async Task ParallellAsync()
{
    var t1 = HämtaAnvändareAsync();
    var t2 = HämtaProdukterAsync();
    await Task.WhenAll(t1, t2);  // båda kör samtidigt!
}

// Vanligt misstag – .Result blockerar och kan deadlocka!
var data = HämtaDataAsync().Result;  // GÖR INTE SÅ
var data = await HämtaDataAsync();   // GÖR SÅ ISTÄLLET

// SQL Injection – GÖR INTE SÅ
var sql = $"SELECT * FROM Users WHERE Name = '{input}'";
// Om input = "'; DROP TABLE Users;--" → katastrof!

// GÖR SÅ – parametriserad query (EF Core)
var user = await db.Users
    .Where(u => u.Name == input)  // EF skyddar automatiskt
    .FirstOrDefaultAsync();

// XSS – Razor HTML-encodar automatiskt
<p>@Model.AnvändarInput</p>           // SÄKER – encodas
<p>@Html.Raw(Model.AnvändarInput)</p> // FARLIG – kör rå HTML

// CORS i ASP.NET Core
builder.Services.AddCors(opt => opt.AddPolicy("MittAPI", p =>
    p.WithOrigins("https://minapp.se")
     .AllowAnyMethod()
     .AllowAnyHeader()));

// HTTPS-omdirigering
app.UseHttpsRedirection();
app.UseHsts();

// DNS-uppslag i C#
var addresses = await Dns.GetHostAddressesAsync("google.se");

// HTTP-request i C# med HttpClient
var client = new HttpClient();
var response = await client.GetAsync("https://api.example.com/data");
var json = await response.Content.ReadAsStringAsync();

// Kontrollera statuskod
if (response.IsSuccessStatusCode)
    Console.WriteLine("OK!");
else
    Console.WriteLine($"Fel: {response.StatusCode}");

// TCP-socket (lågnivå – sällan behövs direkt)
using var socket = new TcpClient("example.com", 80);
// HttpClient hanterar allt detta åt dig automatiskt

// Värdetyper (struct) – bor på stack
int x = 42;
bool aktiv = true;
DateTime now = DateTime.Now;

// Referenstyper (class) – bor på heap
var bil = new Bil("Volvo");   // "bil"-variabeln på stack pekar på heap
var lista = new List<int>();

// IDisposable – frigör ej-hanterade resurser (filer, DB, HTTP)
// using-satsen anropar Dispose() automatiskt när blocket avslutas
using var fil = File.OpenRead("data.txt");
using var conn = new SqlConnection(connStr);
// Dispose() anropas automatiskt här – även vid exception

// Många kopior vs delad referens
int a = 5;
int b = a;   // kopia – b = 5, ändrar a påverkar inte b

var bil1 = new Bil("Volvo");
var bil2 = bil1;   // SAMMA objekt! ändrar bil2 → ändrar bil1 också

// Dictionary – O(1)-uppslag
var priser = new Dictionary<string, decimal>
{
    ["Mjölk"] = 15.90m,
    ["Bröd"] = 29.50m
};
decimal pris = priser["Mjölk"];   // O(1) – blixtsnabbt

// HashSet – kontrollera unikhet O(1)
var besökta = new HashSet<int>();
besökta.Add(42);
bool finnsDen = besökta.Contains(42);   // O(1)

// List – O(n) sökning – använd bara när ordning spelar roll
var lista = new List<string> { "A", "B", "C" };
bool finns = lista.Contains("B");   // O(n) – går igenom alla

// Binär sökning på sorterad lista
var sorterad = new List<int> { 1, 3, 5, 7, 9, 11 };
int index = sorterad.BinarySearch(7);   // O(log n)

// LINQ använder rätt algoritm internt
var snabb = dict.ContainsKey("Mjölk");       // O(1)
var långsammare = lista.Any(x => x == "B");  // O(n)

// Try/catch/finally
public async Task<User> HämtaAnvändareAsync(int id)
{
    try
    {
        return await db.Users.FindAsync(id)
            ?? throw new NotFoundException($"Användare {id} hittades inte");
    }
    catch (NotFoundException)
    {
        throw;  // Skicka vidare – låt anroparen hantera
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Oväntat fel vid hämtning av användare {Id}", id);
        throw;
    }
    finally
    {
        // Körs ALLTID – bra för cleanup
    }
}

// Eget exception
public class NotFoundException : Exception
{
    public NotFoundException(string msg) : base(msg) { }
}

// Result-mönstret – inga exceptions för kända fel
public record Result<T>(T? Value, string? Error, bool IsSuccess);

public Result<User> LoggaIn(string epost, string lösenord)
{
    var user = db.Users.FirstOrDefault(u => u.Epost == epost);
    if (user == null) return new(null, "Användare finns ej", false);
    if (!VerifyPassword(lösenord, user.Hash))
        return new(null, "Fel lösenord", false);
    return new(user, null, true);
}

// Anroparen kollar resultatet – inga try/catch behövs
var result = LoggaIn("test@test.se", "abc");
if (result.IsSuccess)
    Console.WriteLine($"Välkommen {result.Value!.Namn}!");
else
    Console.WriteLine($"Fel: {result.Error}");