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

namespace Soneta.Skills.Test.KadryPlace.Pracownik;

/// <summary>
/// Rozdział E/F (część druga) — operacje na planie pracy i RCP wykraczające poza CRUD dni:
/// <list type="bullet">
/// <item>E3 — aktualizacja kalendarza pracownika (worker seryjny, wymaga Context → <c>[Ignore]</c>),</item>
/// <item>E4 — uzgodnienie doby pracowniczej (worker dnia/grupowy, wymaga Context → <c>[Ignore]</c>),</item>
/// <item>E5 — odczyt normy i czasu przepracowanego przez <c>pracownik.Czasy : KalkulatorPracownika</c> (★ pełny odczyt),</item>
/// <item>F3 — import RCP: sam import plikowy <c>[Ignore]</c>; przeliczenie we/wy przez <c>ImportDniaWorker</c> (★),</item>
/// <item>F4 — weryfikacja/korekta RCP: <c>DzienRCP</c>/<c>StanRCP</c> (★ korekta na świeżym dniu),</item>
/// <item>F5 — praca hybrydowa: strefy dnia i podzielniki (★ odczyt).</item>
/// </list>
/// <para>
/// Operujemy wyłącznie na <b>publicznym kontrakcie</b> platformy Soneta (jak dodatek zewnętrzny),
/// na bazie Demo (GoldStandard) z automatycznym rollbackiem. Daty Demo planu/pracy są nieznane, więc
/// odczyty istniejących danych traktujemy defensywnie (kolekcja istnieje / indeksator nie rzuca),
/// a scenariusze zapisu budujemy na własnych, jawnych datach dla pracownika „006".
/// </para>
/// <para>
/// <b>Granica testowalności.</b> Operacje wymagające <see cref="Context"/> (worker E3/E4 grupowy —
/// <c>Params : ContextBase</c> z ctorem <c>(Context)</c>, karmiony zaznaczeniem listy) lub źródła
/// zewnętrznego (import RCP z pliku/czytnika) są oznaczone <c>[Ignore]</c> z uzasadnieniem — opisują
/// kontrakt, nie wykonują operacji. <c>KalkulatorPracownika</c>/<c>CzasDni</c>/<c>ZestawienieNadgodzin</c>
/// nie są wierszami ORM — to obiekty liczące (czysty odczyt bez transakcji).
/// </para>
/// </summary>
[TestFixture]
public class RozdzialEFrest_PlanRcpTest : PracownikTestBase
{
    // Jawne daty/okresy do scenariuszy (nie Date.Today — data biznesowa Demo bywa inna).
    private static readonly Date Dzien = new(2026, 6, 1);
    private static readonly FromTo Okres = new(new Date(2026, 6, 1), new Date(2026, 6, 30));
    private static readonly YearMonth Miesiac = new(2026, 6);

    // ============================== E3 — Aktualizacja kalendarza pracownika ==============================

    [Test]
    [Description("E3 (kontrakt, [Ignore]): AktualizujKalendarzWorker to worker seryjny z menu Czynności. " +
                 "Pracownicy/Pars są set-only, a Params : ContextBase ma ctor (Context) — bez zaznaczenia " +
                 "listy (Context) nie da się zbudować parametrów, więc operacji nie wykonujemy w teście.")]
    [Ignore("E3: AktualizujKalendarzWorker.Params : ContextBase wymaga Context (zaznaczenie listy pracowników) — brak czystego API bezkontekstowego.")]
    public void E3_AktualizujKalendarz_WymagaContext_Ignore()
    {
        // Świadomie nie wykonujemy — operacja seryjna sterowana zaznaczeniem UI (Context).
        // worker.Pracownicy = context.Get<Pracownik[]>();
        // worker.Pars = new AktualizujKalendarzWorker.Params(context) { Data = ..., Docelowy = ..., Zmiana = true };
        // worker.Aktualizuj();   // Logout + Commit wewnątrz
        Assert.Fail("Test oznaczony [Ignore] — nie powinien być uruchamiany.");
    }

    [Test]
    [Description("E3 (odczyt konfiguracji): kalendarz docelowy/źródłowy aktualizacji to konfiguracja " +
                 "Etat.Kalendarz oraz interpretacja Etat.InterpretacjaKalendarza — odczyt nie wymaga workera " +
                 "ani Context i nie rzuca; pokazuje skąd worker E3 bierze stan wejściowy.")]
    public void E3_KalendarzIInterpretacja_OdczytKonfiguracjiEtatu_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        p.Should().NotBeNull("pracownik '006' istnieje w bazie Demo");

        System.Action odczyt = () =>
        {
            // Etat leży na bieżącym zapisie historycznym (pracownik.Last.Etat); kalendarz i interpretacja
            // sterują aktualizacją (E3).
            var etat = p.Last?.Etat;
            if (etat is not null)
            {
                Kalendarz kal = etat.Kalendarz;                    // kalendarz roboczy (źródło/cel zmiany)
                InterpretacjaKalendarza interpretacja = etat.InterpretacjaKalendarza;
                _ = interpretacja;
                if (kal is not null)
                {
                    Time _ = kal.NormaDobowa;                      // norma dobowa kalendarza
                }
            }
        };
        odczyt.Should().NotThrow("odczyt kalendarza/interpretacji z Etatu nie wymaga Context ani transakcji");
    }

    // ============================== E4 — Uzgodnienie doby pracowniczej ==============================

    [Test]
    [Description("E4 (kontrakt, odczyt): granica doby to atrybuty KONFIGURACYJNE Etatu " +
                 "(ConfigPoczątekDobyNiedzieledIŚwięta — read-only, NormaDobowa) — nie ma edytowalnego pola " +
                 "początku doby na pojedynczym DzienPracy. Odczyt tych pól nie rzuca.")]
    public void E4_ModelDoby_OdczytKonfiguracjiEtatu_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        p.Should().NotBeNull("pracownik '006' istnieje w bazie Demo");

        System.Action odczyt = () =>
        {
            var etat = p.Last?.Etat;
            if (etat is not null)
            {
                Time poczatekDobySwieta = etat.ConfigPoczątekDobyNiedzieledIŚwięta; // konfiguracyjne, read-only
                Time normaDobowa = etat.NormaDobowa;
                _ = poczatekDobySwieta;
                _ = normaDobowa;
            }
        };
        odczyt.Should().NotThrow("granica doby/normy to konfiguracja Etatu — czysty odczyt");
    }

    [Test]
    [Description("E4 (kontrakt, [Ignore]): worker pojedynczego dnia DzienPracy.UzgodnijDobePracowniczaWorker " +
                 "ma Dzień set-only i wymaga istniejącego dnia ewidencji oraz IsEnabled; worker grupowy " +
                 "(Params : ContextBase) wymaga Context. W Demo brak deterministycznej doby nocnej do uzgodnienia, " +
                 "więc operacji nie wykonujemy — opisujemy kontrakt (IsEnabled + Uzgodnij/Przenieś).")]
    [Ignore("E4: UzgodnijDobePracownicza — worker dnia wymaga deterministycznego dnia nocnego (brak w Demo); worker grupowy wymaga Context.")]
    public void E4_UzgodnijDobePracownicza_WymagaContextLubDanych_Ignore()
    {
        // var dzien = pracownik.DniPracy[data];
        // if (DzienPracy.UzgodnijDobePracowniczaWorker.IsEnabledUzgodnijDobePracownicza(dzien)) { ... }
        // new DzienPracy.UzgodnijDobePracowniczaWorker { Dzień = dzien }.UzgodnijDobePracownicza();
        Assert.Fail("Test oznaczony [Ignore] — nie powinien być uruchamiany.");
    }

    // ============================== E5 — Odczyt normy / czasu przepracowanego (★ testowalne) ==============================

    [Test]
    [Description("E5: pracownik.Czasy zwraca KalkulatorPracownika (NIE Row — obiekt liczący, czysty odczyt " +
                 "bez transakcji). Kalkulator istnieje dla pracownika z bazy Demo.")]
    public void E5_Czasy_ZwracaKalkulatorPracownika_NieNull()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        p.Should().NotBeNull("pracownik '006' istnieje w bazie Demo");

        KalkulatorPracownika kalk = p.Czasy;
        kalk.Should().NotBeNull("pracownik.Czasy daje kalkulator czasu pracy (kontekst pracownika)");
    }

    [Test]
    [Description("E5: Norma(okres) (plan) i Praca(okres) (realizacja) zwracają CzasDni (Czas : Time, Dni : int). " +
                 "Wywołanie to czysty odczyt — nie rzuca i nie wymaga transakcji. Wartości mogą być Empty/Invalid " +
                 "(brak danych Demo w okresie), więc sprawdzamy tylko sam kontrakt odczytu.")]
    public void E5_NormaIPraca_OdczytZaOkres_ZwracaCzasDni_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        var kalk = p.Czasy;

        CzasDni norma = CzasDni.Invalid;
        CzasDni praca = CzasDni.Invalid;

        System.Action odczyt = () =>
        {
            norma = kalk.Norma(Okres);                 // params Item[] condition — wywołanie bez filtra
            praca = kalk.Praca(Okres);                 // czas przepracowany (realizacja)
            _ = kalk.PracaRozliczana(Okres);           // czas rozliczany (do nadgodzin)
        };
        odczyt.Should().NotThrow("odczyt Norma/Praca przez KalkulatorPracownika jest bezpieczny (bez transakcji)");

        // CzasDni to obiekt wynikowy (Time + int) — pola tylko do odczytu; dostęp nie rzuca.
        System.Action poleCzasDni = () =>
        {
            Time _ = norma.Czas; int __ = norma.Dni;
            Time ___ = praca.Czas; int ____ = praca.Dni;
        };
        poleCzasDni.Should().NotThrow("CzasDni wystawia Czas/Dni jako odczyt");
    }

    [Test]
    [Description("E5: NormaKodeksowa(YearMonth) zwraca normę kodeksową miesiąca (pełny etat) jako CzasDni; " +
                 "dla czerwca 2026 (20 dni roboczych × 8h) norma kodeksowa jest dodatnia — wynik nie jest Invalid " +
                 "i ma policzalne Dni/Czas.")]
    public void E5_NormaKodeksowa_DlaMiesiaca_JestDodatnia()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        var kalk = p.Czasy;

        CzasDni norma = kalk.NormaKodeksowa(Miesiac);

        // Norma kodeksowa miesiąca nie zależy od danych pracownika — to kalendarz kodeksowy.
        norma.Should().NotBe(CzasDni.Invalid, "norma kodeksowa istnieje dla każdego pełnego miesiąca");
        norma.Dni.Should().BeGreaterThan(0, "czerwiec 2026 ma dni robocze");
        norma.Czas.TotalMinutes.Should().BeGreaterThan(0, "pełny etat = dodatnia norma czasu pracy");
    }

    [Test]
    [Description("E5: Nadgodziny(YearMonth) zwraca ZestawienieNadgodzin (struct: N50/N100/NSW/Razem — wszystkie Time, " +
                 "read-only). Nocne(okres) zwraca Time. Czysty odczyt — nie rzuca; przy braku danych Demo wynik = Zero.")]
    public void E5_NadgodzinyINocne_OdczytStatystyk_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        var kalk = p.Czasy;

        ZestawienieNadgodzin nadg = ZestawienieNadgodzin.Zero;
        Time nocne = new(0);

        System.Action odczyt = () =>
        {
            nadg = kalk.Nadgodziny(Miesiac);
            nocne = kalk.Nocne(Okres);
        };
        odczyt.Should().NotThrow("odczyt nadgodzin/czasu nocnego jest bezpieczny");

        // Pola zestawienia to odczyt; Razem agreguje składowe (nie rzuca, może być Zero).
        System.Action pola = () => { Time _ = nadg.N50; Time __ = nadg.N100; Time ___ = nadg.Razem; _ = nocne; };
        pola.Should().NotThrow("ZestawienieNadgodzin wystawia N50/N100/Razem jako odczyt");
    }

    [Test]
    [Description("E5: DniNie(okres)/NormaNie(okres) odczytują liczbę i normę dni nieobecności za okres. " +
                 "DniNie zwraca int (>=0), NormaNie zwraca CzasDni. Czysty odczyt — nie rzuca.")]
    public void E5_NieobecnosciZaOkres_OdczytLiczbyINormy_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        var kalk = p.Czasy;

        int dniNie = -1;
        System.Action odczyt = () =>
        {
            dniNie = kalk.DniNie(Okres);          // liczba dni nieobecności
            _ = kalk.NormaNie(Okres);             // norma nieobecności (CzasDni)
        };
        odczyt.Should().NotThrow("odczyt nieobecności za okres przez kalkulator jest bezpieczny");
        dniNie.Should().BeGreaterThanOrEqualTo(0, "liczba dni nieobecności nie jest ujemna");
    }

    // ============================== F3 — Import RCP (przeliczenie we/wy, ★) ==============================

    [Test]
    [Description("F3 ([Ignore]): import surowych odbić z pliku/czytnika RCP wymaga zewnętrznego źródła " +
                 "(plik/serwis/format) — brak czystego API w publicznym kontrakcie. Testowalny jest jedynie " +
                 "fragment po wczytaniu: przeliczenie już-wpisanych we/wy przez ImportDniaWorker (osobny test).")]
    [Ignore("F3: import z pliku/urządzenia RCP wymaga zewnętrznego źródła (I/O) — poza zakresem testu kontraktu.")]
    public void F3_ImportZPliku_WymagaZrodlaZewnetrznego_Ignore()
    {
        Assert.Fail("Test oznaczony [Ignore] — nie powinien być uruchamiany.");
    }

    [Test]
    [Description("F3 (przeliczenie, ★): po wpisaniu zdarzeń we/wy na dzień ewidencji (jak po imporcie) " +
                 "ImportDniaWorker { DzienPracy = dzien }.Przelicz() przelicza odbicia na czas pracy — operacja " +
                 "na obiektach sesji (bez I/O). Worker ma bezparametrowy ctor i property DzienPracy {get;set;}.")]
    public void F3_ImportDniaWorker_PrzeliczWeWy_NieRzuca()
    {
        Guid guidPrac = Guid.Empty;

        InTransaction(() =>
        {
            var p = Pracownik(Pracownik_.Andrzejewski);
            guidPrac = p.Guid;

            // Dzień ewidencji (właściciel zdarzeń) — tworzymy ctorem + AddRow (sam ctor nie rejestruje).
            var dp = p.DniPracy[Dzien] ?? Session.AddRow(new DzienPracy(p, Dzien));

            // Surowe odbicia we/wy (tabela pośrednia) — tak wyglądają dane „po imporcie", przed przeliczeniem.
            var we = new WejscieWyjscie(dp);
            Kalend.WejsciaWyjscia.AddRow(we);
            we.Godzina = new Time(8, 0);
            we.Typ = TypWejsciaWyjscia.Wejscie;

            var wy = new WejscieWyjscie(dp);
            Kalend.WejsciaWyjscia.AddRow(wy);
            wy.Godzina = new Time(16, 0);
            wy.Typ = TypWejsciaWyjscia.Wyjscie;

            // Przeliczenie odbić na czas pracy dnia (bez pliku/urządzenia).
            System.Action przelicz = () => new ImportDniaWorker { DzienPracy = dp }.Przelicz();
            przelicz.Should().NotThrow("ImportDniaWorker.Przelicz() przelicza we/wy na czas pracy bez I/O");
        });
        SaveDispose();

        // Po przeliczeniu dzień ewidencji nadal jest dostępny przez indeksator [Date].
        var p2 = Get<Prac>(guidPrac);
        var dp2 = p2.DniPracy[Dzien];
        dp2.Should().NotBeNull("dzień ewidencji z przeliczonymi odbiciami istnieje po zapisie");
        dp2.WeWy.Cast<WejscieWyjscie>().Should().HaveCount(2, "wejście i wyjście zostały zachowane");
    }

    // ============================== F4 — Weryfikacja / korekta RCP (★ testowalne) ==============================

    [Test]
    [Description("F4 (odczyt): DniRCP to DateSubTable<DzienRCP> (typowane) — indeksator [Date] zwraca DzienRCP/null " +
                 "i nie rzuca. DzienRCP to wynik importu/weryfikacji; w Demo zwykle brak (null) dla naszej daty. " +
                 "Odczytujemy StanRCP (enum StanWeryfikacjiRCP) i Praca.Czas defensywnie.")]
    public void F4_DniRCP_OdczytIndeksatoremPoDacie_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        p.DniRCP.Should().NotBeNull("kolekcja zweryfikowanego RCP (DniRCP) istnieje");

        System.Action odczyt = () =>
        {
            DzienRCP dzienRcp = p.DniRCP[Dzien];          // typowane: DzienRCP lub null
            if (dzienRcp is not null)
            {
                StanWeryfikacjiRCP stan = dzienRcp.StanRCP;   // enum stanu weryfikacji
                Time czas = dzienRcp.Praca.Czas;              // czas na subrowie Praca
                bool rcpOk = dzienRcp.RcpOK;                  // flaga stanu po imporcie
                _ = stan; _ = czas; _ = rcpOk;
            }
        };
        odczyt.Should().NotThrow("indeksator [Date] na DniRCP to bezpieczny odczyt");
    }

    [Test]
    [Description("F4 (korekta, ★): na świeżo utworzonym DzienRCP korygujemy godziny na subrowie Praca, " +
                 "ustawiamy StanRCP (enum) na Poprawny i dopisujemy Uwagi (MemoText). Po zapisie DniRCP[data] " +
                 "zwraca dzień ze zmienionym stanem i godzinami. Czas/OdGodziny na rootcie są kalkulowane (read-only).")]
    public void F4_KorektaDzienRCP_ZmianaStanuIGodzin_ZapisOdczyt()
    {
        Guid guidPrac = Guid.Empty;

        InTransaction(() =>
        {
            var p = Pracownik(Pracownik_.Andrzejewski);
            guidPrac = p.Guid;

            // W Demo DzienRCP zwykle nie istnieje na naszej dacie — do scenariusza korekty
            // tworzymy go ctorem + AddRow (analogicznie do DzienPracy). Korekta dotyczy istniejącego rekordu.
            var dzienRcp = p.DniRCP[Dzien] ?? Session.AddRow(new DzienRCP(p, Dzien));

            // Korekta godzin na subrowie Praca (root Czas/OdGodziny są kalkulowane).
            dzienRcp.Praca.OdGodziny = new Time(8, 0);
            dzienRcp.Praca.DoGodziny = new Time(16, 0);

            // Zmiana stanu weryfikacji (enum, nie string) + uwagi.
            dzienRcp.StanRCP = StanWeryfikacjiRCP.Poprawny;
            dzienRcp.Uwagi = (MemoText)"Skorygowano wyjście";
        });
        SaveDispose();

        var p2 = Get<Prac>(guidPrac);
        var rcp2 = p2.DniRCP[Dzien];
        rcp2.Should().NotBeNull("po zapisie dzień RCP jest dostępny przez indeksator [Date]");
        rcp2.StanRCP.Should().Be(StanWeryfikacjiRCP.Poprawny, "stan weryfikacji został ustawiony");
        rcp2.Praca.OdGodziny.Should().Be(new Time(8, 0));
        rcp2.Praca.DoGodziny.Should().Be(new Time(16, 0));
    }

    // ============================== F5 — Praca hybrydowa / strefy / podzielniki (odczyt) ==============================

    [Test]
    [Description("F5 (odczyt): DzienPracy.Strefy to SubTable<StrefaPracy> — podział dnia na strefy " +
                 "(stacjonarna / zdalna). Każda StrefaPracy ma Definicja : DefinicjaStrefy i CzasRozliczany : Time. " +
                 "Kolekcja istnieje (może być pusta w Demo); iteracja i odczyt pól nie rzucają.")]
    public void F5_StrefyDniaPracy_OdczytPodzialuNaStrefy_NieRzuca()
    {
        Guid guidPrac = Guid.Empty;

        // Świeży dzień pracy daje deterministyczną (pustą) kolekcję Strefy do bezpiecznego odczytu.
        InTransaction(() =>
        {
            var p = Pracownik(Pracownik_.Andrzejewski);
            guidPrac = p.Guid;
            _ = p.DniPracy[Dzien] ?? Session.AddRow(new DzienPracy(p, Dzien));
        });
        SaveDispose();

        var p2 = Get<Prac>(guidPrac);
        var dzien = p2.DniPracy[Dzien];
        dzien.Should().NotBeNull("dzień ewidencji istnieje");
        dzien.Strefy.Should().NotBeNull("kolekcja stref pracy (Strefy) zawsze istnieje");

        System.Action odczyt = () =>
        {
            foreach (StrefaPracy s in dzien.Strefy.Cast<StrefaPracy>())
            {
                DefinicjaStrefy def = s.Definicja;   // strefa (np. praca zdalna)
                Time rozliczany = s.CzasRozliczany;  // czas rozliczany w strefie
                _ = def; _ = rozliczany;
            }
        };
        odczyt.Should().NotThrow("iteracja po strefach dnia i odczyt pól są bezpieczne");
    }

    [Test]
    [Description("F5 (odczyt podzielników): pracownik.RozliczeniaCzasuPracy (dokumenty) oraz " +
                 "pracownik.ElementyRozliczeniaCzasuPracy (pozycje) to SubTable — kolekcje istnieją (mogą być puste " +
                 "w Demo). Element ma Definicja : DefinicjaStrefy i Czas : Time; odczyt nie rzuca. Budowy dokumentu " +
                 "rozliczenia nie testujemy — wymaga DefinicjaRozliczeniaCzasuPracy i przebiega przez extendery/UI.")]
    public void F5_PodzielnikiRozliczeniaCzasuPracy_OdczytKolekcji_NieRzuca()
    {
        var p = Pracownik(Pracownik_.Andrzejewski);
        p.RozliczeniaCzasuPracy.Should().NotBeNull("kolekcja dokumentów rozliczenia czasu pracy istnieje");
        p.ElementyRozliczeniaCzasuPracy.Should().NotBeNull("kolekcja pozycji rozliczenia (podzielniki) istnieje");

        System.Action odczyt = () =>
        {
            foreach (ElementRozliczeniaCzasuPracy el in p.ElementyRozliczeniaCzasuPracy.Cast<ElementRozliczeniaCzasuPracy>())
            {
                DefinicjaStrefy def = el.Definicja;
                Time czas = el.Czas;
                _ = def; _ = czas;
            }
        };
        odczyt.Should().NotThrow("iteracja po pozycjach podzielnika i odczyt pól są bezpieczne");
    }

    [Test]
    [Description("F5 (kontrakt typów): DefinicjaStrefy wystawia stałe Guid Praca_Zdalna / PracaZdalnaOkazjonalna " +
                 "(identyfikacja stref pracy zdalnej) oraz enum TypStrefy (NieWplywa/Zwieksza/Zmniejsza). " +
                 "Stałe są niepuste — to publiczne punkty zaczepienia rozliczenia pracy hybrydowej.")]
    public void F5_DefinicjaStrefy_StalePracaZdalnaIEnumTypStrefy_SaDostepne()
    {
        DefinicjaStrefy.Praca_Zdalna.Should().NotBe(Guid.Empty, "stała identyfikuje strefę pracy zdalnej");
        DefinicjaStrefy.PracaZdalnaOkazjonalna.Should().NotBe(Guid.Empty, "stała identyfikuje strefę pracy zdalnej okazjonalnej");

        // Enum TypStrefy steruje wpływem strefy na rozliczenie czasu.
        System.Enum.IsDefined(typeof(TypStrefy), TypStrefy.NieWplywa).Should().BeTrue();
        System.Enum.IsDefined(typeof(TypStrefy), TypStrefy.Zwieksza).Should().BeTrue();
        System.Enum.IsDefined(typeof(TypStrefy), TypStrefy.Zmniejsza).Should().BeTrue();
    }
}