Imports System.IO
Imports System.Text.RegularExpressions
Imports System.Windows.Forms
Imports DigitalData.Controls.LookupGrid
Imports DigitalData.Modules.Logging
Imports DigitalData.Modules.ZooFlow
Imports WINDREAMLib

''' <summary>
''' Defines common Functions for Checking for and replacing placeholders.
''' This Class also includes a child class `Pattern` for passing around Patterns.
''' 
''' The format of all placeholders is:
''' {#TYPE#VALUE}
''' 
''' Some Examples:
''' {#INT#USERNAME}
''' {#CTRL#CMB_2}
''' {#WMI#String 39}
''' </summary>
Public Class Patterns2
    ''' <summary>
    ''' Complex patterns that rely on Windream
    ''' </summary>
    Public Const PATTERN_WMI = "WMI"

    ''' <summary>
    ''' Complex patterns that rely on IDB Attribute values
    ''' </summary>
    Public Const PATTERN_IDBA = "IDBA"

    ''' <summary>
    ''' Complex patterns that rely on Control Values
    ''' </summary>
    Public Const PATTERN_CTRL = "CTRL"

    ''' <summary>
    ''' Simple patterns that rely on Data from the TBDD_USER table
    ''' </summary>
    Public Const PATTERN_USER = "USER"

    Public Const USER_VALUE_PRENAME = "PRENAME"
    Public Const USER_VALUE_SURNAME = "SURNAME"
    Public Const USER_VALUE_EMAIL = "EMAIL"
    Public Const USER_VALUE_SHORTNAME = "SHORTNAME"
    Public Const USER_VALUE_LANGUAGE = "LANGUAGE"
    Public Const USER_VALUE_USER_ID = "USER_ID"
    Public Const VALUE_PROFILE_ID = "PROFILE_ID"
    Public Const VALUE_PROFILE_TITLE = "PROFILE_TITLE"

    Private ReadOnly LogConfig As LogConfig
    Private ReadOnly Logger As Logger
    Private ReadOnly Base As Modules.BaseModule

    Private ReadOnly ControlPanel As Panel
    Private ReadOnly IDBActive As Boolean

    Private ReadOnly Modules As New List(Of IModule)

    Public Sub New(pLogConfig As LogConfig)
        LogConfig = pLogConfig
        Logger = pLogConfig.GetLogger()
        Base = New Modules.BaseModule(LogConfig)

        Modules.AddRange({
            New Modules.Internal(LogConfig),
            New Modules.Clipboard(LogConfig),
            New Modules.Controls(LogConfig),
            New Modules.User(LogConfig),
            New Modules.FileInformation(LogConfig)
        })
    End Sub

    Public Sub New(pLogConfig As LogConfig, pControlPanel As Panel, pIDBActive As Boolean)
        MyClass.New(pLogConfig)
        ControlPanel = pControlPanel
        IDBActive = pIDBActive
    End Sub

    Public Function ReplaceAllValues(pInput As String, pPanel As Panel, pUser As State.UserState, pFIleinfo As FileInfo) As String
        Dim oResult = pInput

        For Each oModule In Modules
            Try
                Dim oArgs = GetReplaceMapForModule(oModule, pPanel:=pPanel, pUser:=pUser, pFileInfo:=pFIleinfo)
                oResult = oModule.Replace(oResult, oArgs)
            Catch ex As Exception
                Logger.Warn("Placeholders for String [{0}] could not be replaced completely in Module [{1}]. Skipping.", pInput, oModule.GetType.Name)
                Logger.Error(ex)
            End Try
        Next

        Return oResult
    End Function

    Public Function ReplaceUserValues(pInput As String, pUser As State.UserState) As String
        Logger.Debug("Replacing User Values")
        Dim oResult = pInput

        Dim oModule = GetModule(Of Modules.User)()
        Dim oArgs = GetReplaceMapForModule(oModule, pUser:=pUser)
        oResult = DoReplaceForModule(oResult, oModule, oArgs)

        Return oResult
    End Function

    Public Function ReplaceFileValues(pInput As String, pFileInfo As FileInfo) As String
        Logger.Debug("Replacing File Values")
        Dim oResult = pInput

        Dim oModule = GetModule(Of Modules.FileInformation)()
        Dim oArgs = GetReplaceMapForModule(oModule, pFileInfo:=pFileInfo)
        oResult = DoReplaceForModule(oResult, oModule, oArgs)

        Return oResult
    End Function

    Public Function ReplaceControlValues(pInput As String, pPanel As Panel) As String
        Logger.Debug("Replacing Control Values")
        Dim oResult = pInput

        Dim oModule = GetModule(Of Modules.Controls)()
        Dim oArgs = GetReplaceMapForModule(oModule, pPanel:=pPanel)
        oResult = DoReplaceForModule(oResult, oModule, oArgs)

        Return oResult
    End Function

    Public Function ReplaceWindreamValues(pInput As String, pWMObject As WMObject) As String
        Logger.Debug("Replacing Windream Values")
        Dim oResult = pInput

        Dim oModule = GetModule(Of Modules.Windream)()
        Dim oArgs = GetReplaceMapForModule(oModule, pWMObject:=pWMObject)
        oResult = DoReplaceForModule(oResult, oModule, oArgs)

        Return oResult
    End Function

    Public Function ReplaceInternalValues(pInput As String) As String
        Logger.Debug("Replacing Internal Values")
        Dim oResult = pInput

        Dim oInternalModule = GetModule(Of Modules.Internal)()
        Dim oInternalArgs = GetReplaceMapForModule(oInternalModule)
        oResult = DoReplaceForModule(oResult, oInternalModule, oInternalArgs)

        Dim oClipboardModule = GetModule(Of Modules.Clipboard)()
        Dim oClipboardArgs = GetReplaceMapForModule(oClipboardModule)
        oResult = DoReplaceForModule(oResult, oClipboardModule, oClipboardArgs)

        Return oResult
    End Function

    Public Function ReplaceGlobixValues(pInput As String, pGlobixIndexes As Dictionary(Of String, List(Of String))) As String
        Logger.Debug("Replacing Globix Values")
        Dim oResult = pInput

        Dim oGlobixModule = GetModule(Of Modules.Globix)()
        Dim oGlobixArgs = GetReplaceMapForModule(oGlobixModule, pGlobixIndexes:=pGlobixIndexes)
        oResult = DoReplaceForModule(oResult, oGlobixModule, oGlobixArgs)

        Return oResult
    End Function



    Private Function DoReplaceForModule(pInput As String, pModule As IModule, pArgs As Dictionary(Of String, Object)) As String
        Try
            If pModule IsNot Nothing AndAlso pModule?.GetType?.Name IsNot Nothing Then
                Logger.Debug("Calling Replace for Module [{0}]", pModule.GetType.Name)
            End If

            Logger.Debug("Calling Replace for Input String [{0}]", pInput)

            pInput = pModule.Replace(pInput, pArgs)
        Catch ex As Exception
            Logger.Warn("Placeholders for String [{0}] could not be replaced completely in Module [{1}]. Skipping.", pInput, pModule.GetType.Name)
            Logger.Error(ex)
        End Try

        Return pInput
    End Function

    Private Function GetModule(Of ModuleT)() As IModule
        Return Modules.
            Where(Function(m) TypeOf m Is ModuleT).
            SingleOrDefault()
    End Function

    Private Function GetReplaceMapForModule(pModule As IModule,
                                            Optional pPanel As Panel = Nothing,
                                            Optional pUser As State.UserState = Nothing,
                                            Optional pWMObject As WMObject = Nothing,
                                            Optional pGlobixIndexes As Dictionary(Of String, List(Of String)) = Nothing,
                                            Optional pFileInfo As FileInfo = Nothing
                                            ) As Dictionary(Of String, Object)
        Dim oArgs As New Dictionary(Of String, Object)

        If TypeOf pModule Is Modules.Clipboard Then
            Logger.Debug("Adding Arguments for Clipboard Module")
            Try
                oArgs.Add(Patterns.Modules.Clipboard.CLIP_VALUE_BOARD, My.Computer.Clipboard.GetText())
            Catch ex As Exception
                Logger.Error(ex)
            End Try

        ElseIf TypeOf pModule Is Modules.FileInformation Then
            Logger.Debug("Adding Arguments for File Module")
            Try
                oArgs.Add(Patterns.Modules.FileInformation.FILE_VALUE_FILEINFO, pFileInfo)
            Catch ex As Exception
                Logger.Error(ex)
            End Try

        ElseIf TypeOf pModule Is Modules.User Then
            Logger.Debug("Adding Arguments for User Module")
            Try
                oArgs.Add(Patterns.Modules.User.USER_VALUE_EMAIL, pUser.Email)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_LANGUAGE, pUser.Language)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_PRENAME, pUser.GivenName)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_SHORTNAME, pUser.ShortName)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_SURNAME, pUser.Surname)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_USER_ID, pUser.UserId)
                oArgs.Add(Patterns.Modules.User.USER_VALUE_USER_NAME, pUser.UserName)
            Catch ex As Exception
                Logger.Error(ex)
            End Try

        ElseIf TypeOf pModule Is Modules.Controls Then
            Logger.Debug("Adding Arguments for Controls Module")
            Try
                oArgs.Add(Patterns.Modules.Controls.CTRL_VALUE_PANEL, pPanel)
            Catch ex As Exception
                Logger.Error(ex)
            End Try

        ElseIf TypeOf pModule Is Modules.Windream Then
            Logger.Debug("Adding Arguments for Windream Module")
            Try
                oArgs.Add(Patterns.Modules.Windream.WM_VALUE_DOCUMENT, pWMObject)
            Catch ex As Exception
                Logger.Error(ex)
            End Try

        ElseIf TypeOf pModule Is Modules.Globix Then
            Logger.Debug("Adding Arguments for Globix Module")
            Try
                oArgs.Add(Patterns.Modules.Globix.GBX_VALUE_INDICIES, pGlobixIndexes)
            Catch ex As Exception
                Logger.Error(ex)
            End Try
        End If

        Return oArgs
    End Function

#Region "Helper Functions"
    ''' <summary>
    ''' Wraps a pattern-type and -value in the common format: {#type#value}
    ''' </summary>
    Public Function WrapPatternValue(pType As String, pValue As String) As String
        Return New Pattern(pType, pValue).ToString
    End Function

    Public Function HasAnyPatterns(input) As Boolean
        Return Modules.Any(Function(m) Base.HasPattern(input, m.PatternIdentifier))
    End Function

    Public Function HasComplexPatterns(input As String) As Boolean
        Return Modules.
            Where(Function(m) m.IsComplex = True).
            Any(Function(m) Base.HasPattern(input, m.PatternIdentifier))
    End Function

    Public Function HasOnlySimplePatterns(input As String) As Boolean
        Return Not HasComplexPatterns(input)
    End Function
#End Region

End Class