private Stopwatch meroOra = Stopwatch.StartNew();
private long utolsoTick = 0, legnagyobb = 0;
private int negyzetX = 0, irany = 4;
private int felulet;

private void Form1_Load(object sender, EventArgs e)
{
    felulet = Environment.CurrentManagedThreadId;
    tmrMero.Interval = 50; tmrMero.Start();
    tmrAnim.Interval = 20; tmrAnim.Start();
}

private void tmrMero_Tick(object sender, EventArgs e)
{
    long most = meroOra.ElapsedMilliseconds;
    long keses = most - utolsoTick - tmrMero.Interval;

    utolsoTick = most;
    if (keses > legnagyobb) { legnagyobb = keses; }
    lblKeses.Text = "Legnagyobb késés: " + legnagyobb + " ms";
}

private void tmrAnim_Tick(object sender, EventArgs e)
{
    negyzetX += irany;
    if (negyzetX < 0 || negyzetX > pnlAnim.Width - 30) { irany = -irany; negyzetX += irany; }
    pnlNegyzet.Left = negyzetX;
}

private void Naploz(string s) { lstNaplo.Items.Insert(0, DateTime.Now.ToString("HH:mm:ss") + "  " + s); }

// ---- számolás ----
private long Primek(int hatar)
{
    long db = 0;

    for (int n = 2; n <= hatar; n++)
    {
        bool prim = true;

        for (int d = 2; (long)d * d <= n; d++) { if (n % d == 0) { prim = false; break; } }

        if (prim) { db++; }
    }

    return db;
}

private void btnFeluleti_Click(object sender, EventArgs e)
{
    Stopwatch sw = Stopwatch.StartNew();
    long db = Primek((int)nudHatar.Value);   // a felületi szálon: fagy

    lblEredmeny.Text = "Prímek: " + db + " (" + sw.ElapsedMilliseconds + " ms, felületi szál)";
}

private async void btnAszinkron_Click(object sender, EventArgs e)
{
    btnAszinkron.Enabled = false;
    btnFeluleti.Enabled = false;
    lblEredmeny.Text = "Számolok...";   // látszik: a felület él

    int hatar = (int)nudHatar.Value;   // a bemenetet A FELÜLETI SZÁLON olvassuk ki

    try
    {
        Stopwatch sw = Stopwatch.StartNew();
        int munkaSzal = 0;

        long db = await Task.Run(() => { munkaSzal = Environment.CurrentManagedThreadId; return Primek(hatar); });

        if (IsDisposed) { return; }   // közben bezárhatták

        lblEredmeny.Text = "Prímek: " + db + " (" + sw.ElapsedMilliseconds + " ms, munkaszál: " + munkaSzal + ", folytatás szála: " + Environment.CurrentManagedThreadId + ", felületi: " + felulet + ")";
    }
    catch (Exception ex) { tsslUzenet.Text = "Hiba: " + ex.Message; }
    finally
    {
        if (!IsDisposed) { btnAszinkron.Enabled = true; btnFeluleti.Enabled = true; }
    }
}

// ---- egymás után / egyszerre ----
private async Task<string> LetoltAsync(string nev, int ms)
{
    await Task.Delay(ms);

    return nev + " kész";
}

private async void btnEgymasUtan_Click(object sender, EventArgs e)
{
    btnEgymasUtan.Enabled = false;

    try
    {
        Stopwatch sw = Stopwatch.StartNew();
        string a = await LetoltAsync("A", 1000);
        string b = await LetoltAsync("B", 1500);
        string c = await LetoltAsync("C", 2000);

        Naploz("Egymás után: " + sw.ElapsedMilliseconds + " ms (" + a + ", " + b + ", " + c + ")");
    }
    finally { btnEgymasUtan.Enabled = true; }
}

private async void btnEgyszerre_Click(object sender, EventArgs e)
{
    btnEgyszerre.Enabled = false;

    try
    {
        Stopwatch sw = Stopwatch.StartNew();

        Task<string> ta = LetoltAsync("A", 1000), tb = LetoltAsync("B", 1500), tc = LetoltAsync("C", 2000);   // mind elindul
        string[] eredmenyek = await Task.WhenAll(ta, tb, tc);

        Naploz("Egyszerre (WhenAll): " + sw.ElapsedMilliseconds + " ms (" + string.Join(", ", eredmenyek) + ")");
    }
    finally { btnEgyszerre.Enabled = true; }
}

// ---- hibák ----
private async Task<int> HibasAsync(string uzenet)
{
    await Task.Delay(300);

    throw new InvalidOperationException(uzenet);
}

private async void btnAwaitHiba_Click(object sender, EventArgs e)
{
    try { await HibasAsync("await hiba"); }
    catch (InvalidOperationException ex) { tsslUzenet.Text = "await + catch: " + ex.Message + " (szál: " + Environment.CurrentManagedThreadId + ")"; }
}

private async void btnResultHiba_Click(object sender, EventArgs e)
{
    // a .Result BLOKKOLNA a felületi szálon: ezért háttérszálról hívjuk a demóhoz
    string uzenet = await Task.Run(() =>
    {
        try { return HibasAsync("result hiba").Result.ToString(); }
        catch (AggregateException ae) { return "AggregateException → InnerException: " + ae.InnerException.Message; }
    });

    tsslUzenet.Text = uzenet;
}

private async void btnWhenAllHiba_Click(object sender, EventArgs e)
{
    Task<int> t1 = HibasAsync("első hiba"), t2 = HibasAsync("második hiba"), t3 = Task.FromResult(3);
    Task osszes = Task.WhenAll(t1, t2, t3);

    try { await osszes; }
    catch (Exception)   // az await csak az ELSŐ kivételt dobja újra
    {
        AggregateException ae = osszes.Exception;

        Naploz("WhenAll: " + ae.InnerExceptions.Count + " hiba: " + string.Join("; ", ae.InnerExceptions.Select(x => x.Message)));
    }
}

private void btnElfelejtett_Click(object sender, EventArgs e)
{
    // szándékosan nem várjuk: a hibát a ContinueWith észleli és naplózza (különben elveszne)
    HibasAsync("elfelejtett").ContinueWith(t =>
    {
        try { BeginInvoke(new Action(() => Naploz("Az elfelejtett Task hibája: " + t.Exception.InnerException.Message))); }
        catch (InvalidOperationException) { }
    }, TaskContinuationOptions.OnlyOnFaulted);
}

// ---- időtúllépés ----
private async void btnIdotullepes_Click(object sender, EventArgs e)
{
    Task<string> lassu = LetoltAsync("Lassú", 10000);
    Task elso = await Task.WhenAny(lassu, Task.Delay(3000));

    if (elso != lassu) { Naploz("IDŐTÚLLÉPÉS: 3 másodperc alatt nem készült el (a feladat tovább fut)"); }
    else { Naploz("Elkészült: " + lassu.Result); }   // a lassu már kész: a Result nem blokkol
}

private async void btnGyors_Click(object sender, EventArgs e)
{
    Task<string> gyors = LetoltAsync("Gyors", 1000);
    Task elso = await Task.WhenAny(gyors, Task.Delay(3000));

    Naploz(elso == gyors ? "Időn belül elkészült: " + gyors.Result : "Időtúllépés");
}