// a lemezre kerülő forma: egyszerű, nyilvános tulajdonságokkal (a modell és a tárolt forma szétválik)
public class FeladatAdat
{
    public string Cim { get; set; } = "";
    public DateTime? Hatarido { get; set; }
    public Fontossag Fontos { get; set; }
    public bool Kesz { get; set; }
}

public class JsonFeladatTarolo
{
    private readonly string ut;

    public JsonFeladatTarolo(string ut) { this.ut = ut; }

    public List<Feladat> Betolt()
    {
        if (!File.Exists(ut)) { return new List<Feladat>(); }   // első indítás: üres lista, nem hiba

        string json = File.ReadAllText(ut, Encoding.UTF8);
        List<FeladatAdat> adatok = JsonSerializer.Deserialize<List<FeladatAdat>>(json) ?? new List<FeladatAdat>();

        List<Feladat> lista = new List<Feladat>();

        foreach (FeladatAdat a in adatok)
        {
            Feladat f = new Feladat(a.Cim) { Hatarido = a.Hatarido, Fontos = a.Fontos };

            if (a.Kesz) { f.Elvegez(); }
            lista.Add(f);
        }

        return lista;
    }

    public void Ment(IEnumerable<Feladat> feladatok)
    {
        List<FeladatAdat> adatok = feladatok.Select(f => new FeladatAdat { Cim = f.Cim, Hatarido = f.Hatarido, Fontos = f.Fontos, Kesz = f.Kesz }).ToList();

        string json = JsonSerializer.Serialize(adatok, new JsonSerializerOptions { WriteIndented = true });

        string ideiglenes = ut + ".tmp";

        File.WriteAllText(ideiglenes, json, new UTF8Encoding(false));   // előbb ideiglenes fájlba (10.9 lecke)

        if (File.Exists(ut)) { File.Delete(ut); }

        File.Move(ideiglenes, ut);   // majd átnevezés: a félbeszakadt mentés nem rontja el a régi fájlt
    }
}

// az INTERFACE: megmondja, MIT tud a tároló (nincs benne kód)
public interface IFeladatTarolo
{
    List<Feladat> Betolt();
    void Ment(IEnumerable<Feladat> feladatok);
}

// 1. megvalósítás: fájlba ment
public class JsonFeladatTarolo : IFeladatTarolo { /* Betolt, Ment: lásd fent */ }

// 2. megvalósítás: csak a memóriában tart (teszthez, vagy ideiglenes használathoz)
public class MemoriaFeladatTarolo : IFeladatTarolo
{
    private List<FeladatAdat> adatok = new List<FeladatAdat>();

    public int MentesekSzama { get; private set; }   // a teszt ellenőrizheti, hányszor mentettek

    public List<Feladat> Betolt()
    {
        return adatok.Select(a => Fordit(a)).ToList();
    }

    public void Ment(IEnumerable<Feladat> feladatok)
    {
        adatok = feladatok.Select(f => new FeladatAdat { Cim = f.Cim, Hatarido = f.Hatarido, Fontos = f.Fontos, Kesz = f.Kesz }).ToList();
        MentesekSzama++;
    }

    private static Feladat Fordit(FeladatAdat a)
    {
        Feladat f = new Feladat(a.Cim) { Hatarido = a.Hatarido, Fontos = a.Fontos };

        if (a.Kesz) { f.Elvegez(); }

        return f;
    }
}

// A FELADATLISTA (szolgáltatás): az interface-t kapja, nem a konkrét tárolót
public class FeladatLista
{
    private readonly IFeladatTarolo tarolo;
    private readonly List<Feladat> feladatok = new List<Feladat>();

    public bool Modositott { get; private set; }
    public IReadOnlyList<Feladat> Elemek { get { return feladatok; } }
    public event EventHandler Valtozott;

    public FeladatLista(IFeladatTarolo tarolo)   // KONSTRUKTOR-injektálás: kívülről kapja
    {
        if (tarolo == null) { throw new ArgumentNullException("tarolo"); }

        this.tarolo = tarolo;
    }

    public void Betolt() { feladatok.Clear(); feladatok.AddRange(tarolo.Betolt()); Modositott = false; Jelez(); }
    public void Ment() { tarolo.Ment(feladatok); Modositott = false; }

    public void Hozzaad(Feladat f) { feladatok.Add(f); Modositott = true; Jelez(); }
    public void Torol(Feladat f) { if (feladatok.Remove(f)) { Modositott = true; Jelez(); } }

    private void Jelez() { Valtozott?.Invoke(this, EventArgs.Empty); }
}

// A FORM: a szolgáltatást kapja a konstruktorban
public partial class Form1 : Form
{
    private readonly FeladatLista lista;

    public Form1(FeladatLista lista)
    {
        InitializeComponent();

        this.lista = lista;
        lista.Valtozott += (s, e) => Frissit();
    }
}

// A PROGRAM.CS: itt áll össze minden ("composition root"): ez az EGYETLEN hely, ahol a konkrét osztályt választod
static void Main()
{
    Application.EnableVisualStyles();

    string ut = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Feladatlista", "feladatok.json");
    Directory.CreateDirectory(Path.GetDirectoryName(ut));

    IFeladatTarolo tarolo = new JsonFeladatTarolo(ut);   // itt cserélhető: new MemoriaFeladatTarolo()
    FeladatLista lista = new FeladatLista(tarolo);

    Application.Run(new Form1(lista));
}

// saját kivétel: a Form ne ismerje a JsonException, IOException típusokat
public class TaroloHiba : Exception
{
    public TaroloHiba(string uzenet, Exception ok) : base(uzenet, ok) { }
}

// a tárolóban: a technikai hibát a felhasználónak szóló üzenetté alakítjuk
public List<Feladat> Betolt()
{
    try { /* olvasás és fordítás */ }
    catch (JsonException ex)           { throw new TaroloHiba("A feladatfájl sérült, nem olvasható.", ex); }
    catch (UnauthorizedAccessException ex) { throw new TaroloHiba("Nincs jogosultság a feladatfájlhoz.", ex); }
    catch (IOException ex)                { throw new TaroloHiba("A feladatfájl nem érhető el: " + ex.Message, ex); }
}

// a Formban: egyetlen catch, érthető üzenet; az eredeti kivétel az InnerException-ben megmarad a naplóhoz
private async void btnMent_Click(object sender, EventArgs e)
{
    btnMent.Enabled = false;

    try
    {
        await Task.Run(() => lista.Ment());   // a mentés a háttérben: a felület nem akad (11. fejezet)

        tsslUzenet.Text = "Mentve: " + DateTime.Now.ToString("HH:mm:ss");
    }
    catch (TaroloHiba ex)
    {
        tsslUzenet.Text = ex.Message;
        MessageBox.Show(this, ex.Message, "Mentési hiba", MessageBoxButtons.OK, MessageBoxIcon.Warning);
    }
    finally { btnMent.Enabled = lista.Modositott; }
}