Imports System.Data.SqlClient
Imports System.Reflection

Public Class cAuditFlow

    Private ReadOnly SQL As New SQL

    ''' <summary>
    ''' Erzeugt alle fälligen Prüfungen ab dem gegebenen Startdatum.
    ''' Unterstützt sowohl Intervall-basierte als auch einmalige Prüfobjekte.
    ''' Berücksichtigt das Enddatum und Erinnerungsvorlauf jedes Prüfobjekts.
    ''' </summary>
    ''' <param name="vonDatum">Datum, ab dem fällige Prüfungen nachträglich berechnet werden sollen</param>
    Public Shared Sub ErzeugeFaelligePruefungen(vonDatum As Date)
        Dim pruefobjekte = cAuditFlow_Pruefobjekte.LoadAllAktiv()
        Dim heute As Date = Date.Today

        For Each obj In pruefobjekte
            ' Intervalltyp ermitteln (immer in Großbuchstaben, Leerzeichen entfernt)
            Dim intervallTyp As String = If(obj.wartPO_IntervallTyp, "").Trim().ToUpper()

            ' Erinnerungsvorlauf ermitteln
            Dim vorlauf As Integer = obj.wartPO_Erinnerung_VorlaufInTagen

            ' Enddatum aus Datenbank (leer = unbegrenzt)
            Dim dbEndDatum As Date = If(obj.wartPO_enddatum > Date.MinValue, obj.wartPO_enddatum, Date.MaxValue)

            ' System-Enddatum = heute + Vorlauf (aber max. bis zum definierten Enddatum)
            Dim systemEndDatum As Date = heute.AddDays(vorlauf)
            Dim endDatum As Date = If(systemEndDatum <= dbEndDatum, systemEndDatum, dbEndDatum)

            ' Startdatum zur Prüfung: das spätere von vonDatum oder Startdatum aus DB
            Dim startDatum As Date = If(vonDatum > obj.wartPO_startdatum, vonDatum, obj.wartPO_startdatum)

            ' Wenn Startdatum bereits hinter dem Enddatum liegt → überspringen
            If startDatum > endDatum Then Continue For

            ' === EINMALIGE PRÜFUNG ===
            If intervallTyp = "EINMALIG" Then
                Dim faellig As Date = obj.wartPO_startdatum
                If faellig >= startDatum AndAlso faellig <= endDatum Then
                    If Not cAuditFlow_Pruefungen.ExistiertBereits(obj.wartPO_Id, faellig) Then
                        Dim einmaligePruefung As New cAuditFlow_Pruefungen With {
                        .wartPruef_wartPOId = obj.wartPO_Id,
                        .wartPruef_Faelligkeitsdatum = faellig,
                        .wartPruef_Erledigung = False,
                        .wartPruef_Bemerkung = "Einmalige Prüfung"
                    }
                        einmaligePruefung.SAVE()
                    End If
                End If
                Continue For
            End If

            ' === WIEDERKEHRENDE PRÜFUNG ===
            If Not obj.wartPO_IntervallWert.HasValue Then Continue For

            Dim laufDatum As Date = startDatum
            Do While laufDatum <= endDatum
                If Not cAuditFlow_Pruefungen.ExistiertBereits(obj.wartPO_Id, laufDatum) Then
                    Dim neuePruefung As New cAuditFlow_Pruefungen With {
                    .wartPruef_wartPOId = obj.wartPO_Id,
                    .wartPruef_Faelligkeitsdatum = laufDatum,
                    .wartPruef_Erledigung = False
                }
                    neuePruefung.SAVE()
                End If

                ' Nächstes Datum berechnen
                laufDatum = BerechneNaechstesDatum(laufDatum, intervallTyp, obj.wartPO_IntervallWert.Value)
            Loop
        Next
    End Sub


    ''' <summary>
    ''' Berechnet das nächste Fälligkeitsdatum auf Basis eines Ausgangsdatums, des Intervalltyps und -werts.
    ''' </summary>
    ''' <param name="start">Ausgangspunkt für die nächste Fälligkeit</param>
    ''' <param name="typ">Intervalltyp: "TAGE", "WOCHEN", "MONATE", "JAHRE"</param>
    ''' <param name="wert">Anzahl der Einheiten, die zwischen zwei Fälligkeiten liegen</param>
    ''' <remarks>
    ''' Beispiele:
    '''   typ: "TAGE",    wert: 10   → alle 10 Tage
    '''   typ: "WOCHEN",  wert: 1    → jede Woche
    '''   typ: "MONATE",  wert: 3    → alle 3 Monate
    '''   typ: "JAHRE",   wert: 2    → alle 2 Jahre
    ''' </remarks>
    Private Shared Function BerechneNaechstesDatum(start As Date, typ As String, wert As Integer) As Date
        Select Case typ.Trim.ToUpper()
            Case "TAGE"
                Return start.AddDays(wert)
            Case "WOCHEN"
                Return start.AddDays(wert * 7)
            Case "MONATE"
                Return start.AddMonths(wert)
            Case "JAHRE"
                Return start.AddYears(wert)
            Case Else
                Throw New ArgumentException("Ungültiger Intervalltyp: " & typ)
        End Select
    End Function




    ''' <summary>
    ''' Löscht alle offenen (wartPruef_Erledigung = 0) Prüfungen für ein Prüfobjekt.
    ''' Standard: nur fällige (Faelligkeitsdatum <= heute). 
    ''' Rückgabewert: Anzahl gelöschter Datensätze; -1 bei Fehler.
    ''' </summary>
    Shared Function DELETE_ALL_OPEN_FAELLIGE(wartPOId As Integer, Optional onlyFaellige As Boolean = True) As Integer
        Try
            Dim sqlStr As String =
                "DELETE FROM [tblAuditFlow_Pruefungen] " &
                "WHERE [wartPruef_wartPOId]=@wartPruef_wartPOId " &
                "  AND ISNULL([wartPruef_Erledigung],0)=0"

            If onlyFaellige Then
                sqlStr &= " AND [wartPruef_Faelligkeitsdatum] <= CAST(GETDATE() AS DATE)"
            End If

            Using conn As SqlConnection = SQL.GetNewOpenConnectionFMZOLL()
                Using cmd As New SqlCommand(sqlStr, conn)
                    cmd.Parameters.AddWithValue("@wartPruef_wartPOId", wartPOId)
                    Dim affected As Integer = cmd.ExecuteNonQuery()
                    Return affected
                End Using
            End Using

        Catch ex As Exception
            VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace, MethodInfo.GetCurrentMethod().Name)
            Return -1
        End Try
    End Function

    ''' <summary>
    ''' Markiert eine Prüfung als erledigt, speichert das Datum und übergibt Base64-Anhänge an ein externes Archivsystem.
    ''' Die erzeugte dsId wird als Referenz in die Prüfung eingetragen.
    ''' </summary>
    ''' <param name="pruefungsId">ID der Prüfung, die erledigt werden soll</param>
    ''' <param name="anhaengeBase64">Liste von Base64-kodierten Dateiinhalten</param>
    ''' <returns>True, wenn erfolgreich gespeichert</returns>
    Public Shared Function SetzePruefungAufErledigtMitAnhaengen(pruefungsId As Integer, Bemerkung As String, anhaengeBase64 As List(Of String)) As Boolean
        Try
            ' Prüfung laden
            Dim pruefung As New cAuditFlow_Pruefungen(pruefungsId)
            If Not pruefung.hasEntry Then Return False

            ' 1. Archivierung der Base64-Dateien (Platzhalter)
            ' ===============================================
            ' Hier wird angenommen, dass du die Base64-Anhänge an dein Dokumentenarchiv (z. B. DMS) übergibst.
            ' Die Rückgabe ist eine eindeutige dsId (z. B. Integer oder Guid), die in der Prüfungstabelle gespeichert wird.

            Dim dsId As Integer = -1 ' <== Platzhalter für spätere Archivierung / Dateiübertragung
            ' TODO: Übergabe der Dateien und Erhalt der dsId vom Archivsystem

            ' 2. Prüfung als erledigt markieren
            ' =================================
            pruefung.wartPruef_Erledigung_Datum = Date.Now
            pruefung.wartPruef_Erledigung = True
            pruefung.wartPruef_Anhaenge_daId = dsId
            pruefung.wartPruef_Bemerkung = Bemerkung

            ' 3. Speichern
            Return pruefung.SAVE()

        Catch ex As Exception
            VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace, System.Reflection.MethodInfo.GetCurrentMethod.Name)
            Return False
        End Try
    End Function
End Class