// az általános kivételből ember által olvasható üzenet; a Formnak nem kell ismernie a típusokat
public static string Magyarazat(Exception ex)
{
    if (ex is FileNotFoundException) { return "A fájl nem található."; }
    if (ex is DirectoryNotFoundException) { return "A mappa nem érhető el (kivették a meghajtót?)."; }
    if (ex is UnauthorizedAccessException) { return "Nincs jogosultság a művelethez (a fájl csak olvasható, vagy védett mappa)."; }
    if (ex is PathTooLongException) { return "Az útvonal túl hosszú."; }

    IOException io = ex as IOException;

    if (io != null)
    {
        int kod = io.HResult & 0xFFFF;   // a Win32 hibakód alsó 16 bitje

        if (kod == 32 || kod == 33) { return "A fájlt másik program használja. Zárd be, és próbáld újra."; }
        if (kod == 39 || kod == 112) { return "A lemez megtelt."; }

        return "Fájlművelet-hiba: " + io.Message;
    }

    return "Váratlan hiba: " + ex.Message;
}

// ELÉG? NEM: az ellenőrzés és a használat KÖZÖTT a fájl eltűnhet (versenyhelyzet: TOCTOU)
if (File.Exists(ut))
{
    // ... közben egy másik program törli / zárolja / a hálózat megszakad ...
    string s = File.ReadAllText(ut);   // FileNotFoundException még mindig lehet!
}

// HELYES: a try–catch az igazság; az Exists csak kényelmi előszűrő (jobb üzenet)
public static string OlvasBiztonsagosan(string ut, out string hiba)
{
    hiba = null;

    try { return File.ReadAllText(ut); }
    catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is ArgumentException || ex is NotSupportedException)
    {
        hiba = Magyarazat(ex);

        return null;
    }
}

// használat
string hibaUzenet;
string tartalom = FajlSegedek.OlvasBiztonsagosan(txtUt.Text, out hibaUzenet);

if (tartalom == null) { tsslUzenet.Text = hibaUzenet; return; }

// ÚJRAPRÓBÁLÁS: a fájlzár gyakran átmeneti (víruskereső, felhő-szinkron, másik program)
public static void MentUjraprobalva(string ut, string tartalom, int probak = 4)
{
    for (int proba = 1; ; proba++)
    {
        try
        {
            MentBiztonsagosan(ut, tartalom);

            return;
        }
        catch (IOException ex) when (proba < probak && ZarHiba(ex))   // csak a zárhibánál, és csak ennyiszer
        {
            Thread.Sleep(150 * proba);   // növekvő várakozás (háttérszálon; felületi szálon: await Task.Delay, 11.4 lecke)
        }
        // az utolsó próbánál (vagy más hibánál) a kivétel továbbszáll
    }
}

private static bool ZarHiba(IOException ex) { int k = ex.HResult & 0xFFFF; return k == 32 || k == 33; }

// BIZTONSÁGOS MENTÉS (10.9 lecke): ideiglenes fájl, majd csere; a régi tartalom nem sérül, ha a mentés megszakad
public static void MentBiztonsagosan(string ut, string tartalom)
{
    string tmp = ut + ".tmp";

    try
    {
        File.WriteAllText(tmp, tartalom, new UTF8Encoding(false));

        if (File.Exists(ut)) { File.Replace(tmp, ut, ut + ".bak"); }   // atomi csere, biztonsági másolattal
        else { File.Move(tmp, ut); }
    }
    catch
    {
        try { if (File.Exists(tmp)) { File.Delete(tmp); } } catch { }   // takarítás; a takarítás hibája ne fedje el az eredetit

        throw;   // az eredeti kivétel megy tovább
    }
}

// ERŐFORRÁS: using: a fájl mindig lezárul (try–finally)
using (StreamReader r = new StreamReader(ut)) { string sor = r.ReadLine(); }

public class AdatbazisHiba : Exception { public AdatbazisHiba(string uzenet, Exception ok) : base(uzenet, ok) { } }

public class JegyzetAdatbazis
{
    private readonly string kapcsolat;

    public JegyzetAdatbazis(string fajl) { kapcsolat = "Data Source=" + fajl; }

    public void Letrehoz()
    {
        Vegrehajt("CREATE TABLE IF NOT EXISTS jegyzet (id INTEGER PRIMARY KEY AUTOINCREMENT, cim TEXT NOT NULL UNIQUE, szoveg TEXT)");
    }

    public void Hozzaad(string cim, string szoveg)
    {
        // PARAMÉTERES lekérdezés: SOHA ne fűzd össze a bemenetet az SQL-lel (SQL-injekció, aposztróf hiba)
        Vegrehajt("INSERT INTO jegyzet (cim, szoveg) VALUES ($cim, $szoveg)", ("$cim", cim), ("$szoveg", szoveg));
    }

    private void Vegrehajt(string sql, params (string nev, object ertek)[] parameterek)
    {
        try
        {
            using (SqliteConnection kap = new SqliteConnection(kapcsolat))   // using: a kapcsolat mindig lezárul
            using (SqliteCommand parancs = kap.CreateCommand())
            {
                kap.Open();
                parancs.CommandText = sql;

                foreach (var p in parameterek) { parancs.Parameters.AddWithValue(p.nev, p.ertek ?? DBNull.Value); }

                parancs.ExecuteNonQuery();
            }
        }
        catch (SqliteException ex) when (ex.SqliteErrorCode == 19)   // 19: megszorítás megsértése (UNIQUE, NOT NULL)
        {
            throw new AdatbazisHiba("Ilyen című jegyzet már létezik, vagy hiányzik egy kötelező adat.", ex);
        }
        catch (SqliteException ex) when (ex.SqliteErrorCode == 5 || ex.SqliteErrorCode == 6)   // 5: SQLITE_BUSY, 6: LOCKED
        {
            throw new AdatbazisHiba("Az adatbázis foglalt, próbáld újra később.", ex);
        }
        catch (SqliteException ex)
        {
            throw new AdatbazisHiba("Adatbázis-hiba: " + ex.Message, ex);
        }
    }

    // TRANZAKCIÓ: több művelet együtt: vagy mind sikerül, vagy egyik sem
    public void Importal(IEnumerable<(string cim, string szoveg)> jegyzetek)
    {
        try
        {
            using (SqliteConnection kap = new SqliteConnection(kapcsolat))
            {
                kap.Open();

                using (SqliteTransaction tr = kap.BeginTransaction())
                {
                    try
                    {
                        foreach (var j in jegyzetek)
                        {
                            using (SqliteCommand p = kap.CreateCommand())
                            {
                                p.Transaction = tr;
                                p.CommandText = "INSERT INTO jegyzet (cim, szoveg) VALUES ($c, $s)";
                                p.Parameters.AddWithValue("$c", j.cim);
                                p.Parameters.AddWithValue("$s", j.szoveg);
                                p.ExecuteNonQuery();
                            }
                        }

                        tr.Commit();   // csak ha minden sikerült
                    }
                    catch
                    {
                        tr.Rollback();   // bármi hiba: mindent visszavon
                        throw;
                    }
                }
            }
        }
        catch (SqliteException ex) { throw new AdatbazisHiba("Az importálás nem sikerült, egyetlen jegyzet sem került be: " + ex.Message, ex); }
    }
}