// ---- Models/Konyv.cs ----
namespace Konyvtar.Core.Models
{
    public class Konyv
    {
        public int Id { get; private set; }
        public string Cim { get; private set; }
        public string Szerzo { get; private set; }
        public int Ev { get; private set; }
        public string Kolcsonzo { get; private set; }
        public DateTime? Hatarido { get; private set; }

        public bool Kikolcsonozve { get { return Kolcsonzo != null; } }

        public Konyv(int id, string cim, string szerzo, int ev)
        {
            if (string.IsNullOrWhiteSpace(cim)) { throw new ArgumentException("A cím kötelező.", "cim"); }
            if (string.IsNullOrWhiteSpace(szerzo)) { throw new ArgumentException("A szerző kötelező.", "szerzo"); }
            if (ev < 1400 || ev > DateTime.Now.Year + 1) { throw new ArgumentException("Az év 1400 és " + (DateTime.Now.Year + 1) + " között lehet.", "ev"); }

            Id = id; Cim = cim.Trim(); Szerzo = szerzo.Trim(); Ev = ev;
        }

        public void Kolcsonoz(string nev, DateTime mikor, int napok = 14)
        {
            if (Kikolcsonozve) { throw new InvalidOperationException("A könyv már ki van kölcsönözve (" + Kolcsonzo + ")."); }
            if (string.IsNullOrWhiteSpace(nev)) { throw new ArgumentException("A kölcsönző neve kötelező.", "nev"); }
            if (napok < 1) { throw new ArgumentOutOfRangeException("napok"); }

            Kolcsonzo = nev.Trim();
            Hatarido = mikor.Date.AddDays(napok);
        }

        public void Visszahoz()
        {
            if (!Kikolcsonozve) { throw new InvalidOperationException("A könyv nincs kikölcsönözve."); }

            Kolcsonzo = null; Hatarido = null;
        }

        public bool Kesett(DateTime mikor) { return Hatarido.HasValue && mikor.Date > Hatarido.Value; }
        public int KesesNap(DateTime mikor) { return Kesett(mikor) ? (mikor.Date - Hatarido.Value).Days : 0; }

        public void Visszaallit(string kolcsonzo, DateTime? hatarido)   // csak betöltéshez
        {
            Kolcsonzo = string.IsNullOrWhiteSpace(kolcsonzo) ? null : kolcsonzo;
            Hatarido = Kolcsonzo == null ? null : hatarido;
        }

        public string Allapot(DateTime mikor)
        {
            if (!Kikolcsonozve) { return "Elérhető"; }
            if (Kesett(mikor)) { return "Késik " + KesesNap(mikor) + " napot (" + Kolcsonzo + ")"; }

            return "Kikölcsönözve: " + Kolcsonzo + ", " + Hatarido.Value.ToString("MM.dd") + "-ig";
        }
    }
}

// ---- Services/KonyvtarSzolgaltatas.cs ----
namespace Konyvtar.Core.Services
{
    public interface IKonyvTarolo
    {
        List<Konyv> Betolt();
        void Ment(IEnumerable<Konyv> konyvek);
    }

    public class KonyvtarSzolgaltatas
    {
        private readonly IKonyvTarolo tarolo;
        private readonly Func<DateTime> ora;
        private readonly List<Konyv> konyvek = new List<Konyv>();
        private int kovetkezoId = 1;

        public bool Modositott { get; private set; }
        public IReadOnlyList<Konyv> Konyvek { get { return konyvek; } }
        public DateTime Most { get { return ora(); } }
        public event EventHandler Valtozott;

        public KonyvtarSzolgaltatas(IKonyvTarolo tarolo, Func<DateTime> ora = null)
        {
            if (tarolo == null) { throw new ArgumentNullException("tarolo"); }

            this.tarolo = tarolo;
            this.ora = ora ?? (() => DateTime.Now);
        }

        public void Betolt()
        {
            konyvek.Clear();
            konyvek.AddRange(tarolo.Betolt());
            kovetkezoId = konyvek.Count == 0 ? 1 : konyvek.Max(k => k.Id) + 1;
            Modositott = false;
            Jelez();
        }

        public void Ment() { tarolo.Ment(konyvek.ToList()); Modositott = false; }

        public Konyv Hozzaad(string cim, string szerzo, int ev)
        {
            Konyv k = new Konyv(kovetkezoId, cim, szerzo, ev);

            kovetkezoId++;
            konyvek.Add(k);
            Valtozas();

            return k;
        }

        public void Torol(int id)
        {
            Konyv k = Keres(id);

            if (k.Kikolcsonozve) { throw new InvalidOperationException("Kikölcsönzött könyv nem törölhető."); }

            konyvek.Remove(k);
            Valtozas();
        }

        public void Kolcsonoz(int id, string nev) { Keres(id).Kolcsonoz(nev, ora()); Valtozas(); }
        public void Visszahoz(int id) { Keres(id).Visszahoz(); Valtozas(); }

        public IEnumerable<Konyv> Kereses(string szoveg, bool csakElerheto)
        {
            IEnumerable<Konyv> q = konyvek;

            if (!string.IsNullOrWhiteSpace(szoveg))
            {
                string s = szoveg.Trim();

                q = q.Where(k => k.Cim.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0 || k.Szerzo.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0);
            }

            if (csakElerheto) { q = q.Where(k => !k.Kikolcsonozve); }

            return q.OrderBy(k => k.Cim, StringComparer.CurrentCultureIgnoreCase);
        }

        public IEnumerable<Konyv> Kesettek() { return konyvek.Where(k => k.Kesett(ora())); }

        public string Statisztika()
        {
            int ki = konyvek.Count(k => k.Kikolcsonozve);

            return "Összes: " + konyvek.Count + ", kikölcsönözve: " + ki + ", késik: " + Kesettek().Count();
        }

        private Konyv Keres(int id)
        {
            Konyv k = konyvek.FirstOrDefault(x => x.Id == id);

            if (k == null) { throw new ArgumentException("Nincs ilyen könyv.", "id"); }

            return k;
        }

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

// ---- Storage ----
namespace Konyvtar.Core.Storage
{
    public class TaroloHiba : Exception { public TaroloHiba(string uzenet, Exception ok) : base(uzenet, ok) { } }

    public class KonyvAdat
    {
        public int Id { get; set; }
        public string Cim { get; set; }
        public string Szerzo { get; set; }
        public int Ev { get; set; }
        public string Kolcsonzo { get; set; }
        public DateTime? Hatarido { get; set; }
    }

    internal static class Fordito
    {
        public static KonyvAdat Adatta(Konyv k) { return new KonyvAdat { Id = k.Id, Cim = k.Cim, Szerzo = k.Szerzo, Ev = k.Ev, Kolcsonzo = k.Kolcsonzo, Hatarido = k.Hatarido }; }

        public static Konyv Modellre(KonyvAdat a)
        {
            Konyv k = new Konyv(a.Id, a.Cim, a.Szerzo, a.Ev);

            k.Visszaallit(a.Kolcsonzo, a.Hatarido);

            return k;
        }
    }

    public class MemoriaKonyvTarolo : IKonyvTarolo
    {
        private List<KonyvAdat> adatok = new List<KonyvAdat>();

        public int MentesekSzama { get; private set; }

        public List<Konyv> Betolt() { return adatok.Select(Fordito.Modellre).ToList(); }
        public void Ment(IEnumerable<Konyv> konyvek) { adatok = konyvek.Select(Fordito.Adatta).ToList(); MentesekSzama++; }
    }

    public class JsonKonyvTarolo : IKonyvTarolo
    {
        private readonly string ut;

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

        public List<Konyv> Betolt()
        {
            if (!File.Exists(ut)) { return new List<Konyv>(); }

            try
            {
                List<KonyvAdat> adatok = JsonSerializer.Deserialize<List<KonyvAdat>>(File.ReadAllText(ut, Encoding.UTF8)) ?? new List<KonyvAdat>();

                return adatok.Select(Fordito.Modellre).ToList();
            }
            catch (JsonException ex) { throw new TaroloHiba("A könyvtárfájl sérült, nem olvasható.", ex); }
            catch (ArgumentException ex) { throw new TaroloHiba("A könyvtárfájl érvénytelen adatot tartalmaz: " + ex.Message, ex); }
            catch (UnauthorizedAccessException ex) { throw new TaroloHiba("Nincs jogosultság a könyvtárfájlhoz.", ex); }
            catch (IOException ex) { throw new TaroloHiba("A könyvtárfájl nem érhető el: " + ex.Message, ex); }
        }

        public void Ment(IEnumerable<Konyv> konyvek)
        {
            try
            {
                string json = JsonSerializer.Serialize(konyvek.Select(Fordito.Adatta).ToList(), new JsonSerializerOptions { WriteIndented = true });
                string tmp = ut + ".tmp";

                File.WriteAllText(tmp, json, new UTF8Encoding(false));

                if (File.Exists(ut)) { File.Copy(ut, ut + ".bak", true); File.Delete(ut); }

                File.Move(tmp, ut);
            }
            catch (UnauthorizedAccessException ex) { throw new TaroloHiba("Nincs jogosultság a mentéshez.", ex); }
            catch (IOException ex) { throw new TaroloHiba("A mentés nem sikerült: " + ex.Message, ex); }
        }
    }
}

// ---- Presenters/KonyvtarPresenter.cs ----
public interface IKonyvtarNezet
{
    string Cim { get; set; }
    string Szerzo { get; set; }
    int Ev { get; }
    string Keres { get; }
    bool CsakElerheto { get; }
    string Kolcsonzo { get; set; }
    int? KivalasztottId { get; }

    void MutatKonyvek(IEnumerable<KonyvSor> sorok);
    void MutatStatisztika(string szoveg);
    void MutatUzenet(string uzenet);
    void GombokAllapota(bool kolcsonozhet, bool visszahozhat, bool torolhet, bool menthet);

    event EventHandler HozzaadKerve, KolcsonozKerve, VisszahozKerve, TorlesKerve, SzuresValtozott, KijelolesValtozott;
}

public class KonyvSor { public int Id; public string Cim, Szerzo, Allapot; public int Ev; public bool Figyelmeztet; }

public class KonyvtarPresenter
{
    private readonly IKonyvtarNezet nezet;
    private readonly KonyvtarSzolgaltatas szolg;

    public KonyvtarPresenter(IKonyvtarNezet nezet, KonyvtarSzolgaltatas szolg)
    {
        this.nezet = nezet; this.szolg = szolg;

        nezet.HozzaadKerve += (s, e) => Vegrehajt(() => { szolg.Hozzaad(nezet.Cim, nezet.Szerzo, nezet.Ev); nezet.Cim = ""; nezet.Szerzo = ""; });
        nezet.KolcsonozKerve += (s, e) => Vegrehajt(() => { szolg.Kolcsonoz(nezet.KivalasztottId.Value, nezet.Kolcsonzo); nezet.Kolcsonzo = ""; });
        nezet.VisszahozKerve += (s, e) => Vegrehajt(() => szolg.Visszahoz(nezet.KivalasztottId.Value));
        nezet.TorlesKerve += (s, e) => Vegrehajt(() => szolg.Torol(nezet.KivalasztottId.Value));
        nezet.SzuresValtozott += (s, e) => Frissit();
        nezet.KijelolesValtozott += (s, e) => Gombok();
        szolg.Valtozott += (s, e) => Frissit();

        Frissit();
    }

    private void Vegrehajt(Action muvelet)
    {
        try { muvelet(); nezet.MutatUzenet(""); }
        catch (ArgumentException ex) { nezet.MutatUzenet(ex.Message); }
        catch (InvalidOperationException ex) { nezet.MutatUzenet(ex.Message); }
    }

    private void Frissit()
    {
        DateTime most = szolg.Most;

        nezet.MutatKonyvek(szolg.Kereses(nezet.Keres, nezet.CsakElerheto).Select(k => new KonyvSor { Id = k.Id, Cim = k.Cim, Szerzo = k.Szerzo, Ev = k.Ev, Allapot = k.Allapot(most), Figyelmeztet = k.Kesett(most) }));
        nezet.MutatStatisztika(szolg.Statisztika());
        Gombok();
    }

    private void Gombok()
    {
        Konyv k = nezet.KivalasztottId == null ? null : szolg.Konyvek.FirstOrDefault(x => x.Id == nezet.KivalasztottId.Value);

        nezet.GombokAllapota(k != null && !k.Kikolcsonozve, k != null && k.Kikolcsonozve, k != null && !k.Kikolcsonozve, szolg.Modositott);
    }
}

// ---- Program.cs ----
static void Main(string[] args)
{
    Application.EnableVisualStyles();

    IKonyvTarolo tarolo;

    if (args.Contains("--memoria")) { tarolo = new MemoriaKonyvTarolo(); }
    else
    {
        string mappa = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Konyvtar");

        Directory.CreateDirectory(mappa);
        tarolo = new JsonKonyvTarolo(Path.Combine(mappa, "konyvek.json"));
    }

    KonyvtarSzolgaltatas szolg = new KonyvtarSzolgaltatas(tarolo);
    KonyvtarForm form = new KonyvtarForm(szolg);

    try { szolg.Betolt(); }
    catch (TaroloHiba ex) { MessageBox.Show(ex.Message, "Betöltési hiba"); }

    new KonyvtarPresenter(form, szolg);
    Application.Run(form);
}

// ---- Forms/KonyvtarForm.cs (a nézet megvalósítása, vékony) ----
public partial class KonyvtarForm : Form, IKonyvtarNezet
{
    private readonly KonyvtarSzolgaltatas szolg;

    public event EventHandler HozzaadKerve, KolcsonozKerve, VisszahozKerve, TorlesKerve, SzuresValtozott, KijelolesValtozott;

    public KonyvtarForm(KonyvtarSzolgaltatas szolg) { InitializeComponent(); this.szolg = szolg; }

    public string Cim { get { return txtCim.Text; } set { txtCim.Text = value; } }
    public string Szerzo { get { return txtSzerzo.Text; } set { txtSzerzo.Text = value; } }
    public int Ev { get { return (int)nudEv.Value; } }
    public string Keres { get { return txtKeres.Text; } }
    public bool CsakElerheto { get { return chkElerheto.Checked; } }
    public string Kolcsonzo { get { return txtKolcsonzo.Text; } set { txtKolcsonzo.Text = value; } }
    public int? KivalasztottId { get { return lvKonyvek.SelectedItems.Count == 0 ? (int?)null : (int)lvKonyvek.SelectedItems[0].Tag; } }

    public void MutatKonyvek(IEnumerable<KonyvSor> sorok)
    {
        int? kijelolt = KivalasztottId;

        lvKonyvek.BeginUpdate();
        lvKonyvek.Items.Clear();

        foreach (KonyvSor s in sorok)
        {
            ListViewItem it = new ListViewItem(new string[] { s.Cim, s.Szerzo, s.Ev.ToString(), s.Allapot }) { Tag = s.Id };

            if (s.Figyelmeztet) { it.ForeColor = Color.Firebrick; it.Font = new Font(lvKonyvek.Font, FontStyle.Bold); }   // a szöveg is jelzi ("Késik"): nem csak a szín

            lvKonyvek.Items.Add(it);
            if (kijelolt == s.Id) { it.Selected = true; }
        }

        lvKonyvek.EndUpdate();
    }

    public void MutatStatisztika(string szoveg) { lblStat.Text = szoveg; }
    public void MutatUzenet(string uzenet) { tsslUzenet.Text = uzenet; }

    public void GombokAllapota(bool kolcsonozhet, bool visszahozhat, bool torolhet, bool menthet)
    {
        btnKolcsonoz.Enabled = kolcsonozhet; btnVisszahoz.Enabled = visszahozhat; btnTorles.Enabled = torolhet; btnMent.Enabled = menthet;
    }

    private void btnHozzaad_Click(object s, EventArgs e) { HozzaadKerve?.Invoke(this, e); }
    private void btnKolcsonoz_Click(object s, EventArgs e) { KolcsonozKerve?.Invoke(this, e); }
    private void btnVisszahoz_Click(object s, EventArgs e) { VisszahozKerve?.Invoke(this, e); }
    private void btnTorles_Click(object s, EventArgs e) { TorlesKerve?.Invoke(this, e); }
    private void txtKeres_TextChanged(object s, EventArgs e) { SzuresValtozott?.Invoke(this, e); }
    private void chkElerheto_CheckedChanged(object s, EventArgs e) { SzuresValtozott?.Invoke(this, e); }
    private void lvKonyvek_SelectedIndexChanged(object s, EventArgs e) { KijelolesValtozott?.Invoke(this, e); }

    private async void btnMent_Click(object s, EventArgs e)
    {
        btnMent.Enabled = false;

        try { await Task.Run(() => szolg.Ment()); 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 = szolg.Modositott; }
    }

    private void KonyvtarForm_FormClosing(object s, FormClosingEventArgs e)
    {
        if (!szolg.Modositott) { return; }

        DialogResult v = MessageBox.Show(this, "Mentetlen változások vannak. Mented?", Text, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

        if (v == DialogResult.Cancel) { e.Cancel = true; return; }

        if (v == DialogResult.Yes)
        {
            try { szolg.Ment(); }
            catch (TaroloHiba ex) { MessageBox.Show(this, ex.Message, "Mentési hiba"); e.Cancel = true; }
        }
    }
}

public static class Tesztek
{
    private static int hibak;

    private static void Igaz(bool f, string nev)
    {
        if (!f) { hibak++; System.Diagnostics.Debug.WriteLine("HIBA " + nev); }
        else { System.Diagnostics.Debug.WriteLine("ok    " + nev); }
    }

    private static bool Kivetel<T>(Action a) where T : Exception
    {
        try { a(); return false; } catch (T) { return true; }
    }

    public static int Mindet()
    {
        hibak = 0;

        DateTime ido = new DateTime(2025, 3, 1);
        MemoriaKonyvTarolo tarolo = new MemoriaKonyvTarolo();
        KonyvtarSzolgaltatas sz = new KonyvtarSzolgaltatas(tarolo, () => ido);   // az idő a teszt kezében van

        Konyv a = sz.Hozzaad("Abigél", "Szabó Magda", 1970);
        Konyv b = sz.Hozzaad("Az ember tragédiája", "Madách Imre", 1861);

        Igaz(a.Id == 1 && b.Id == 2, "azonosítók egymás után");
        Igaz(Kivetel<ArgumentException>(() => sz.Hozzaad("", "X", 2000)), "üres cím kivétel");
        Igaz(Kivetel<ArgumentException>(() => sz.Hozzaad("Régi", "X", 1200)), "túl régi év kivétel");

        sz.Kolcsonoz(a.Id, "Anna");

        Igaz(a.Kikolcsonozve && a.Hatarido == new DateTime(2025, 3, 15), "kölcsönzés: 14 napos határidő");
        Igaz(Kivetel<InvalidOperationException>(() => sz.Kolcsonoz(a.Id, "Béla")), "dupla kölcsönzés kivétel");
        Igaz(Kivetel<InvalidOperationException>(() => sz.Torol(a.Id)), "kikölcsönzött nem törölhető");
        Igaz(!a.Kesett(new DateTime(2025, 3, 15)), "a határidő napján nem késik");
        Igaz(a.Kesett(new DateTime(2025, 3, 16)) && a.KesesNap(new DateTime(2025, 3, 18)) == 3, "késés napokban");

        ido = new DateTime(2025, 3, 20);

        Igaz(sz.Kesettek().Count() == 1, "a késő könyvek listája");
        Igaz(sz.Kereses("szabó", false).Count() == 1, "keresés szerző szerint, kis-nagybetű nélkül");
        Igaz(sz.Kereses("", true).Count() == 1, "csak az elérhetők");

        sz.Visszahoz(a.Id);

        Igaz(!a.Kikolcsonozve && sz.Kesettek().Count() == 0, "visszahozás után nem késik");

        sz.Kolcsonoz(b.Id, "Cili");
        sz.Ment();

        KonyvtarSzolgaltatas ujra = new KonyvtarSzolgaltatas(tarolo, () => ido);

        ujra.Betolt();

        Igaz(ujra.Konyvek.Count == 2 && ujra.Konyvek.First(k => k.Id == 2).Kolcsonzo == "Cili", "mentés és újratöltés megőrzi a kölcsönzést");
        Igaz(ujra.Hozzaad("Új", "Szerző", 2000).Id == 3, "az azonosító folytatódik a betöltés után");
        Igaz(!ujra.Modositott || ujra.Konyvek.Count == 3, "a hozzáadás módosítottnak jelöli a listát");

        return hibak;
    }
}