using System;
using System.Linq;
using AwesomeAssertions;
using NUnit.Framework;
using Soneta.Kadry;
using Soneta.Place;
using Soneta.Types;
using Prac = Soneta.Kadry.Pracownik;

namespace Soneta.Skills.Test.KadryPlace.Pracownik;

/// <summary>
/// Rozdział G (reszta) — „Umowy cywilnoprawne" (receptury G3, G4, G5).
/// <para>
/// Testy są <b>wykonywalną dokumentacją</b> publicznego kontraktu platformy Soneta dla operacji na
/// umowach cywilnoprawnych: operacja seryjna „Dodaj umowy" dla grupy osób (G3), rachunek/rozliczenie
/// umowy = wypłata <c>WyplataUmowa</c> naliczana mechanizmem płac (G4), oraz zgłoszenia ZUS
/// zleceniobiorców na podstawie schematu ubezpieczeń umowy (G5).
/// </para>
/// <para>
/// Wszystko działa na bazie Demo (GoldStandard) z automatycznym rollbackiem po teście. Pracownicy
/// etatowi z Demo (kody "006".."039") nie mają jeszcze umów cywilnoprawnych — czysty punkt wejścia.
/// Operujemy wyłącznie na <b>publicznym kontrakcie</b> — tak jak dodatek programisty zewnętrznego bez
/// dostępu do kodu źródłowego aplikacji.
/// </para>
/// </summary>
[TestFixture]
public class RozdzialGrest_UmowyTest : PracownikTestBase
{
    // Pobranie definicji elementu = rodzaju umowy ze słownika konfiguracyjnego po stałej Guid.
    private DefinicjaElementu DefUmowy(Guid rodzaj) =>
        Place.DefElementow[rodzaj] as DefinicjaElementu;

    // Dobiera datę mieszczącą się w okresie aktywnego etatu pracownika (jak w H): koniec miesiąca
    // rozpoczęcia etatu, ograniczony do [From, To]. Etaty Demo są zwykle otwarte (To = MaxValue).
    private static Date DataWEtacie(Prac pracownik)
    {
        var okres = pracownik.Last.Etat.Okres;
        var from = okres.From;
        var koniecMiesiaca = new Date(from.Year, from.Month, 1).AddMonths(1).AddDays(-1);
        if (koniecMiesiaca < from) koniecMiesiaca = from;
        if (okres.To != Date.MaxValue && koniecMiesiaca > okres.To) koniecMiesiaca = okres.To;
        return koniecMiesiaca;
    }

    // ====================== G3 — Operacja seryjna „Dodaj umowy" dla grupy osób ======================

    [Test]
    [Description("G3 (wariant B - petla, jak G1): operacja seryjna 'Dodaj umowy' = G1 powtorzone dla " +
                 "każdej osoby z grupy. Dla każdego pracownika tworzymy Session.AddRow(new Umowa(p)) " +
                 "z tymi samymi danymi nagłówkowymi (Element, Okres, RodzajRozliczenia, TypWartosci, " +
                 "Wydzial) i kwotą na umowa.Last.Wartosc. Każda osoba dostaje osobny rekord Umowa.")]
    public void G3_DodajUmowySeryjnie_PetlaPoGrupie_TworzyUmoweKazdejOsobie()
    {
        var defZlecenie = DefUmowy(DefinicjaElementu.UmowaZlecenie);
        defZlecenie.Should().NotBeNull("baza Demo zawiera definicję umowy zlecenie");

        var okres = new FromTo(new Date(2026, 1, 1), new Date(2026, 12, 31));
        var kody = new[] { Pracownik_.Andrzejewski, Pracownik_.Bednarek, Pracownik_.Bujak };
        var guidy = new Guid[kody.Length];

        InTransaction(() =>
        {
            for (int i = 0; i < kody.Length; i++)
            {
                var p = Pracownik(kody[i]);
                p.Should().NotBeNull();
                p.Umowy.Cast<Umowa>().Should().BeEmpty("pracownik Demo nie ma jeszcze umów");

                // Jawne tworzenie jak w G1 — operacja seryjna to to samo powtórzone w pętli.
                var umowa = Session.AddRow(new Umowa(p));
                umowa.Element = defZlecenie;
                umowa.Data = okres.From;
                umowa.Okres = okres;
                umowa.Tytul = "Umowa zlecenie - projekt grupowy";
                umowa.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
                umowa.TypWartosci = TypWartosciUmowy.Brutto;
                umowa.Wydzial = Kadry.Wydzialy.Firma;     // jednostka organizacyjna wymagana przy Save
                umowa.Last.Wartosc = new Currency(4000m); // kwota na zapisie historycznym
                guidy[i] = p.Guid;
            }
        });
        SaveDispose();

        // Każda osoba z grupy ma teraz jedną umowę o tych samych danych nagłówkowych.
        foreach (var g in guidy)
        {
            var u = Get<Prac>(g).Umowy.Cast<Umowa>().Single();
            // Element to definicja konfiguracyjna — po SaveDispose porównujemy po Guid (inna instancja).
            u.Element.Guid.Should().Be(defZlecenie.Guid);
            u.Element.RodzajZrodla.Should().Be(RodzajŹródłaWypłaty.Umowa);
            u.Tytul.Should().Be("Umowa zlecenie - projekt grupowy");
            u.RodzajRozliczenia.Should().Be(RodzajeRozliczeniaUmowy.KwotaDoWypłaty);
            u.Okres.From.Should().Be(okres.From);
            u.Last.Wartosc.Should().Be(new Currency(4000m));
        }
    }

    [Test]
    [Description("G3 (wariant A — worker platformy): Pracownik.DodajUmowęWorker (DataType Pracownik, " +
                 "ctor przyjmuje Session) z ustawionymi Pracownicy (grupa) i Pars " +
                 "(DodajUmowęWorker.Params(Context): Element, Okres, Data, Tytuł, RodzajRozliczenia, " +
                 "TypWartości, Wartość, Wydział). Akcja DodajUmowę() (void) tworzy umowę każdej osobie.")]
    public void G3_DodajUmowyWorker_TworzyUmoweKazdejZaznaczonejOsobie()
    {
        var defZlecenie = DefUmowy(DefinicjaElementu.UmowaZlecenie);
        var okres = new FromTo(new Date(2026, 1, 1), new Date(2026, 12, 31));

        var osoby = new[]
        {
            Pracownik(Pracownik_.Andrzejewski),
            Pracownik(Pracownik_.Bednarek),
            Pracownik(Pracownik_.Bujak),
        };
        var guidy = osoby.Select(p => p.Guid).ToArray();
        foreach (var p in osoby)
            p.Umowy.Cast<Umowa>().Should().BeEmpty("pracownik Demo nie ma jeszcze umów");

        // Parametry operacji seryjnej — Params(Context) (ContextBase), pola z diakrytykami.
        var pars = new Prac.DodajUmowęWorker.Params(Context);
        pars.Element = defZlecenie;
        pars.Okres = okres;
        pars.Data = okres.From;
        pars.Tytuł = "Umowa zlecenie - operacja seryjna";
        pars.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
        pars.TypWartości = TypWartosciUmowy.Brutto;
        pars.Wartość = new Currency(3500m);
        pars.Wydział = Kadry.Wydzialy.Firma;   // wymagany

        // Worker przyjmuje Session w konstruktorze; Pracownicy = grupa z zaznaczenia.
        var worker = new Prac.DodajUmowęWorker(Session) { Pracownicy = osoby, Pars = pars };
        worker.DodajUmowę();   // void — tworzy umowy wszystkim Pracownicy
        SaveDispose();

        // Każda osoba dostała umowę o danych z Pars.
        foreach (var g in guidy)
        {
            var u = Get<Prac>(g).Umowy.Cast<Umowa>().Single();
            u.Element.Guid.Should().Be(defZlecenie.Guid);   // porównanie po Guid (inna instancja)
            u.Tytul.Should().Be("Umowa zlecenie - operacja seryjna");
            u.Okres.From.Should().Be(okres.From);
            u.Last.Wartosc.Should().Be(new Currency(3500m));
        }
    }

    // ====================== G4 — Rachunek do umowy (rozliczenie = WyplataUmowa) ======================

    [Test]
    [Description("G4: 'rachunek do umowy zlecenia' = wyplata WyplataUmowa naliczana mechanizmem plac " +
                 "(jak H2), NIE rekord w pracownik.Rachunki (to rachunki bankowe). Tworzymy umowę " +
                 "(G1), potem new NaliczanieSeryjne.Umowy(new UmowaParams(Context)) { Umowa = u }." +
                 "Nalicz(); wynik to WyplataUmowa (Typ == Umowa). Stan rozliczenia: Umowa.Stan, " +
                 "Umowa.Splacono, Umowa.Pozostało.")]
    public void G4_RachunekDoUmowy_NaliczanieTworzyWyplateUmowa_IZmieniaStan()
    {
        var pracownik = Pracownik(Pracownik_.Strzelecki);
        pracownik.Should().NotBeNull();

        var data = DataWEtacie(pracownik);
        var okresUmowy = new FromTo(new Date(data.Year, data.Month, 1), data);

        // 1) Umowa zlecenie (jak G1) — dane operacyjne tworzymy w trybie edycji.
        Guid guidUmowy = Guid.Empty;
        InTransaction(() =>
        {
            var u = Session.AddRow(new Umowa(pracownik));
            u.Element = DefUmowy(DefinicjaElementu.UmowaZlecenie);
            u.Data = okresUmowy.From;
            u.Okres = okresUmowy;
            u.Tytul = "Umowa zlecenie - rachunek G4";
            u.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
            u.TypWartosci = TypWartosciUmowy.Brutto;
            u.Wydzial = Kadry.Wydzialy.Firma;
            u.Last.Wartosc = new Currency(3000m);
            guidUmowy = u.Guid;
        });
        SaveDispose();

        var umowa = Get<Umowa>(guidUmowy);
        // Przed rozliczeniem umowa jest niewypłacona.
        umowa.Stan.Should().Be(StanUmowy.Niewypłacona, "świeżo dodana umowa nie ma rachunku");

        // 2) Rachunek = naliczenie wypłaty z umowy (jak H2). UmowaParams NIE ustawia Naliczanie.
        var pars = new NaliczanieSeryjne.UmowaParams(Context);
        pars.DataWypłaty = data;
        pars.DataListy = pars.DataWypłaty;

        // Ustawienie Umowa nadpisuje Pracownik właścicielem umowy. Nalicz() commituje sam.
        var naliczanie = new NaliczanieSeryjne.Umowy(pars) { Umowa = umowa };
        NaliczanieWypłat wynik = naliczanie.Nalicz();

        var wyplaty = wynik.WszystkieWypłaty.Cast<Wyplata>().ToList();
        wyplaty.Should().NotBeEmpty("naliczenie umowy tworzy rachunek (WyplataUmowa)");

        var w = wyplaty[0];
        w.Typ.Should().Be(TypWyplaty.Umowa, "rachunek do umowy to wypłata typu Umowa");
        w.Should().BeAssignableTo<WyplataUmowa>("rachunek to konkretny typ WyplataUmowa");
        ((WyplataUmowa)w).Umowa.Guid.Should().Be(umowa.Guid, "WyplataUmowa wskazuje swoją umowę");
        SaveDispose();

        // 3) Stan rozliczenia umowy po wystawieniu rachunku.
        var umowa2 = Get<Umowa>(guidUmowy);
        umowa2.Stan.Should().NotBe(StanUmowy.Niewypłacona,
            "po naliczeniu rachunku umowa nie jest już całkowicie niewypłacona");
        umowa2.Splacono.Value.Should().BeGreaterThan(0m, "część/całość kwoty została rozliczona");
        // Splacono + Pozostało odpowiada modelowi rozliczenia (kwoty Currency).
        (umowa2.Splacono.Value + umowa2.Pozostało.Value).Should().BeGreaterThanOrEqualTo(0m);
    }

    [Test]
    [Description("G4 (odczyt): rachunki (wypłaty) wystawione do umowy odczytujemy przez " +
                 "pracownik.Wyplaty.OfType<WyplataUmowa>().Where(x => x.Umowa == umowa); składniki " +
                 "rachunku to WypElement (Wartosc). pracownik.Rachunki to rachunki BANKOWE — nie umowy.")]
    public void G4_OdczytRachunkowUmowy_PrzezWyplatyUmowa()
    {
        var pracownik = Pracownik(Pracownik_.Andrzejewski);
        var data = DataWEtacie(pracownik);
        var okresUmowy = new FromTo(new Date(data.Year, data.Month, 1), data);

        Guid guidUmowy = Guid.Empty;
        InTransaction(() =>
        {
            var u = Session.AddRow(new Umowa(pracownik));
            u.Element = DefUmowy(DefinicjaElementu.UmowaZlecenie);
            u.Data = okresUmowy.From;
            u.Okres = okresUmowy;
            u.Tytul = "Umowa zlecenie - odczyt rachunków";
            u.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
            u.TypWartosci = TypWartosciUmowy.Brutto;
            u.Wydzial = Kadry.Wydzialy.Firma;
            u.Last.Wartosc = new Currency(2500m);
            guidUmowy = u.Guid;
        });
        SaveDispose();

        var umowa = Get<Umowa>(guidUmowy);
        var pars = new NaliczanieSeryjne.UmowaParams(Context);
        pars.DataWypłaty = data;
        pars.DataListy = pars.DataWypłaty;
        new NaliczanieSeryjne.Umowy(pars) { Umowa = umowa }.Nalicz();
        SaveDispose();

        var pracownik2 = Pracownik(Pracownik_.Andrzejewski);
        var umowa2 = Get<Umowa>(guidUmowy);

        // Rachunki = wypłaty z umowy filtrowane po umowie (po Guid, bo różne instancje Row).
        var rachunki = pracownik2.Wyplaty.OfType<WyplataUmowa>()
            .Where(x => x.Umowa != null && x.Umowa.Guid == umowa2.Guid)
            .ToList();
        rachunki.Should().NotBeEmpty("wystawiliśmy rachunek do umowy");

        foreach (var r in rachunki)
            foreach (WypElement e in r.Elementy)
                e.Definicja.Should().NotBeNull("każdy składnik rachunku ma definicję elementu");

        // Składniki naliczone bezpośrednio z umowy (Umowa.Elementy).
        umowa2.Elementy.Cast<WypElement>().Should().NotBeEmpty(
            "naliczony rachunek wiąże składniki z umową (Umowa.Elementy)");
    }

    // ====================== G5 — Zgłoszenia ZUS zleceniobiorców (ZUA / ZZA / ZWUA) ======================

    [Test]
    [Description("G5 (schemat ubezpieczeń): typ zgłoszenia (ZUA vs ZZA) wynika ze schematu " +
                 "UmowaHistoria.Ubezpieczenia (umowa.Last.Ubezpieczenia), nie z parametru workera. " +
                 "ZUA = społeczne obowiązkowe (Emerytalne/Rentowe) + zdrowotne; Tyub4 pobierany ze " +
                 "słownika konfiguracyjnego Kadry.TytulyUbezpiecz4. Spoleczne.Od jest read-only — " +
                 "datę objęcia ustawiamy zbiorczo przez Ubezpieczenia.ObowiazkoweOd.")]
    public void G5_SchematUbezpieczenUmowy_ZUA_SpoleczneObowiazkoweIZdrowotne()
    {
        var pracownik = Pracownik(Pracownik_.Bednarek);
        var okres = new FromTo(new Date(2026, 1, 1), new Date(2026, 12, 31));

        // Tytuł ubezpieczenia zleceniobiorcy pobieramy DYNAMICZNIE ze słownika (nie tworzymy w locie).
        var tyub4 = Kadry.TytulyUbezpiecz4.Cast<TytulUbezpieczenia4>().FirstOrDefault();
        tyub4.Should().NotBeNull("baza Demo zawiera słownik tytułów ubezpieczenia (TytulyUbezpiecz4)");

        Guid guidUmowy = Guid.Empty;
        InTransaction(() =>
        {
            var u = Session.AddRow(new Umowa(pracownik));
            u.Element = DefUmowy(DefinicjaElementu.UmowaZlecenie);
            u.Data = okres.From;
            u.Okres = okres;
            u.Tytul = "Umowa zlecenie - ZUA";
            u.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
            u.TypWartosci = TypWartosciUmowy.Brutto;
            u.Wydzial = Kadry.Wydzialy.Firma;
            u.Last.Wartosc = new Currency(4000m);

            // Schemat ubezpieczeń umowy (historyczny) — ZUA: społeczne obowiązkowe + zdrowotne.
            var ub = u.Last.Ubezpieczenia;
            ub.Tyub4 = tyub4;
            ub.ObowiazkoweOd = okres.From;          // data objęcia społecznymi obowiązkowymi
            ub.Emerytalne.Obowiazkowe = true;
            ub.Rentowe.Obowiazkowe = true;
            ub.Zdrowotne.ObowiazkoweOd = okres.From; // na Zdrowotne ObowiazkoweOd jest zapisywalne
            guidUmowy = u.Guid;
        });
        SaveDispose();

        var umowa = Get<Umowa>(guidUmowy);
        var ub2 = umowa.Last.Ubezpieczenia;
        ub2.Tyub4.Should().NotBeNull("tytuł ubezpieczenia zapisany na schemacie umowy");
        ub2.Emerytalne.Obowiazkowe.Should().BeTrue("ZUA: społeczne obowiązkowe (emerytalne)");
        ub2.Rentowe.Obowiazkowe.Should().BeTrue("ZUA: społeczne obowiązkowe (rentowe)");
        ub2.Zdrowotne.ObowiazkoweOd.Should().Be(okres.From, "ZUA obejmuje też zdrowotne");
        // Schemat ubezpieczeń umowy leży na zapisie historycznym (delegat umowa.Ubezpieczenia).
        umowa.Ubezpieczenia.Should().NotBeNull("Umowa.Ubezpieczenia to delegat do Last.Ubezpieczenia");
    }

    [Test]
    [Description("G5 (ZZA): zleceniobiorca podlegający TYLKO zdrowotnemu (np. uczeń/student/zbieg " +
                 "tytułów) → ZZA. Na schemacie UmowaHistoria.Ubezpieczenia zostawiamy Emerytalne/" +
                 "Rentowe.Obowiazkowe = false, ustawiamy tylko Zdrowotne.ObowiazkoweOd.")]
    public void G5_SchematUbezpieczenUmowy_ZZA_TylkoZdrowotne()
    {
        var pracownik = Pracownik(Pracownik_.Bujak);
        var okres = new FromTo(new Date(2026, 1, 1), new Date(2026, 6, 30));
        var tyub4 = Kadry.TytulyUbezpiecz4.Cast<TytulUbezpieczenia4>().FirstOrDefault();

        Guid guidUmowy = Guid.Empty;
        InTransaction(() =>
        {
            var u = Session.AddRow(new Umowa(pracownik));
            u.Element = DefUmowy(DefinicjaElementu.UmowaZlecenie);
            u.Data = okres.From;
            u.Okres = okres;
            u.Tytul = "Umowa zlecenie - ZZA";
            u.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
            u.TypWartosci = TypWartosciUmowy.Brutto;
            u.Wydzial = Kadry.Wydzialy.Firma;
            u.Last.Wartosc = new Currency(2000m);

            var ub = u.Last.Ubezpieczenia;
            ub.Tyub4 = tyub4;
            // ZZA: brak społecznych obowiązkowych, tylko zdrowotne.
            // UWAGA: domyślnie umowa zlecenie ma Emerytalne/Rentowe.Obowiazkowe = true (schemat ZUA);
            // dla ZZA trzeba je JAWNIE wyłączyć — samo ustawienie zdrowotnego nie wystarcza.
            ub.Emerytalne.Obowiazkowe = false;
            ub.Rentowe.Obowiazkowe = false;
            ub.Zdrowotne.ObowiazkoweOd = okres.From;
            guidUmowy = u.Guid;
        });
        SaveDispose();

        var ub2 = Get<Umowa>(guidUmowy).Last.Ubezpieczenia;
        ub2.Emerytalne.Obowiazkowe.Should().BeFalse("ZZA: brak społecznych obowiązkowych (emerytalne)");
        ub2.Rentowe.Obowiazkowe.Should().BeFalse("ZZA: brak społecznych obowiązkowych (rentowe)");
        ub2.Zdrowotne.ObowiazkoweOd.Should().Be(okres.From, "ZZA: tylko zdrowotne");
    }

    [Test]
    [Ignore("Generowanie zgłoszenia ZUA/ZZA workerem ZarejestrujUmowyWorker.Rejestracja wymaga " +
            "kompletnej konfiguracji płatnika/KEDU i kontekstu deklaracji ZUS, niedostępnego w " +
            "izolowanym środowisku testów Demo (bez sieci). Dokumentujemy kontrakt workera bez " +
            "uruchamiania generowania (ZarejestrujUmowy() / WyrejestrujUmowy()).")]
    [Description("G5 (worker — kontrakt): Soneta.Deklaracje.ZUS.ZarejestrujUmowyWorker (DataType " +
                 "Umowa, ctor bezparametrowy, Umowy: Umowa[]). Zgłoszenie: zagnieżdżona Rejestracja " +
                 "(Pars: ParamsZ — Okres, DataDokumentu, DataWypełnienia, ZarejestrujRodzinę) i akcja " +
                 "ZarejestrujUmowy(): object generująca ZUA/ZZA wg schematu ubezpieczeń umowy. " +
                 "Wyrejestrowanie analogicznie WyrejestrujUmowy() → ZWUA. KEDU/wysyłka → sieć.")]
    public void G5_ZgloszenieZUS_Worker_KontraktBezGenerowania()
    {
        var pracownik = Pracownik(Pracownik_.Bednarek);
        var okres = new FromTo(new Date(2026, 1, 1), new Date(2026, 12, 31));

        Guid guidUmowy = Guid.Empty;
        InTransaction(() =>
        {
            var u = Session.AddRow(new Umowa(pracownik));
            u.Element = DefUmowy(DefinicjaElementu.UmowaZlecenie);
            u.Data = okres.From;
            u.Okres = okres;
            u.Tytul = "Umowa zlecenie - zgłoszenie ZUS";
            u.RodzajRozliczenia = RodzajeRozliczeniaUmowy.KwotaDoWypłaty;
            u.TypWartosci = TypWartosciUmowy.Brutto;
            u.Wydzial = Kadry.Wydzialy.Firma;
            u.Last.Wartosc = new Currency(4000m);
            guidUmowy = u.Guid;
        });
        SaveDispose();

        var umowa = Get<Umowa>(guidUmowy);

        // Worker zgłoszeniowy na typie Umowa — operuje na zaznaczonych umowach.
        // Uwaga: Umowy oraz Pars są write-only (set-only) — przekazujemy je przez inicjalizator/setter.
        var worker = new Soneta.Deklaracje.ZUS.ZarejestrujUmowyWorker { Umowy = new[] { umowa } };

        // Parametry zgłoszenia: ParamsZ(Context) — bazowe Okres/DataDokumentu/DataWypełnienia ustawiane
        // na wspólnym kontrakcie ZarejestrujBaseWorker (ParamsZ przekazujemy jako Pars do Rejestracji).
        var pars = new Soneta.Deklaracje.ZUS.ZarejestrujBaseWorker.ParamsZ(Context);
        pars.ZarejestrujRodzinę = false;

        var rejestracja = new Soneta.Deklaracje.ZUS.ZarejestrujUmowyWorker.Rejestracja { Pars = pars };

        // Generowanie (ZUA/ZZA wg schematu ubezpieczeń) — wymaga kontekstu deklaracji/KEDU:
        rejestracja.ZarejestrujUmowy();
        SaveDispose();
    }
}