using C4IT.Logging;
using System;
using System.Activities;
using System.ComponentModel;
using System.Reflection;
using static C4IT.Logging.cLogManager;
using Matrix42.Contracts.Platform.Data;
using Matrix42.ServiceRepository.Contracts.Components;
using Matrix42.Workflows.Contracts;
using System.Linq;
using Matrix42.Contracts.Platform.General;
using System.Json;
using Newtonsoft.Json;
using System.Collections.Generic;
using Matrix42.Workflows.Activities.Common.Data;
using System.Activities.Validation;
using System.Threading.Tasks;
using LiamWorkflowActivities;
using System.Runtime.CompilerServices;
using System.Security.Principal;
using static LiamAD.ADServiceGroupCreator;
using C4IT.LIAM;
using C4IT_IAM_Engine;

namespace C4IT.LIAM.Activities
{
    public class C4ITLIAMInitializeProviderActivity : cLIAMM42BaseActivity
    {
        [RequiredArgument]
        [Category("Input")]
        [DisplayName("Config Id")]
        public InArgument<Guid> ConfigID { get; set; }

        [RequiredArgument]
        [Category("Credentials")]
        public InArgument<SecureData> Password { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Message")]
        public OutArgument<string> Message { get; set; }

        [Category("Output")]
        [DisplayName("Error Code")]
        public OutArgument<string> ErrorCode { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {ConfigID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);
                ErrorCode.Set(context, string.Empty);
                Message.Set(context, string.Empty);

                SecureData secureData = Password.Get(context);
                var configEOID = ConfigID.Get(context);

                var dataMain = dataProvider.GetDataList(constFragmentNameConfigProviderMain,
                    "ID, [Expression-ObjectId] as EOID, GCCDomain, GCCTarget, GCCMaxDepth, " +
                    "GCCgroupLDAPFilter, GCCgroupOUPath, GCCPermissionGroupStrategy, GCCtargetType",
                    $"[Expression-ObjectId] = '{configEOID}'");

                Guid ConfigClassId = (Guid)dataMain.First()["ID"];
                var dataBase = dataProvider.GetDataList(constFragmentNameConfigProviderBase, "Account",
                    $"[Expression-ObjectID] = '{configEOID}'");
                var dataAdditional = dataProvider.GetDataList(constFragmentNameConfigProviderAdditionalAttributes, "Name, Value",
                    $"[Expression-ObjectID] = '{configEOID}'");
                var dataCustomTag = dataProvider.GetDataList(constFragmentNameCustomTagBase, "Key, Name",
                    $"[Expression-ObjectID] = '{configEOID}'");
                var dataNamingConvention = dataProvider.GetDataList(constFragmentNameConfigNamingConvention,
                    "ID, Usage, NamingConvention.Description as Description, NamingConvention.DescriptionTemplate as DescriptionTemplate, " +
                    "NamingConvention.Name as Name, NamingConvention.NamingTemplate as NamingTemplate, NamingConvention.Wildcard as Wildcard",
                    $"[Expression-ObjectID] = '{configEOID}'");

                var DataProvider = createProvider(dataMain.First(), dataBase.First(), dataAdditional, dataNamingConvention, dataCustomTag, secureData);

                var validLogon = DataProvider.LogonAsync().GetAwaiter().GetResult();
                if (validLogon)
                {
                    AddCache(ConfigClassId, configEOID, DataProvider);
                }
                else
                {
                    Message.Set(context, DataProvider.GetLastErrorMessage());
                    if (DataProvider is cLiamProviderExchange exProvider)
                        ErrorCode.Set(context, exProvider.GetLastErrorCode());
                    else
                        ErrorCode.Set(context, "WF_PROVIDER_LOGON_FAILED");
                }

                Success.Set(context, validLogon);
            }
            catch (Exception E)
            {
                LogException(E);
                Success.Set(context, false);
                ErrorCode.Set(context, "WF_ACTIVITY_EXCEPTION");
                Message.Set(context, E.Message);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMGetDataAreasFromProviderActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Output")]
        [DisplayName("DataAreas")]
        public OutArgument<JsonArray> DataAreas { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Error Code")]
        public OutArgument<string> ErrorCode { get; set; }

        [Category("Output")]
        [DisplayName("Error Message")]
        public OutArgument<string> ErrorMessage { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {ConfigID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);
                Success.Set(context, false);
                ErrorCode.Set(context, string.Empty);
                ErrorMessage.Set(context, string.Empty);

                var dataAreas = getDataAreasFromProvider(ConfigID.Get(context)).GetAwaiter().GetResult() ?? Enumerable.Empty<DataAreaEntry>();
                var dataAreaJson = dataAreas.Select(da => JsonValue.Parse(JsonConvert.SerializeObject(da)));
                DataAreas.Set(context, new JsonArray(dataAreaJson));
                Success.Set(context, true);

                if (!string.IsNullOrWhiteSpace(LastOperationErrorCode))
                {
                    Success.Set(context, false);
                    ErrorCode.Set(context, LastOperationErrorCode);
                    ErrorMessage.Set(context, LastOperationErrorMessage);
                }
            }
            catch (Exception E)
            {
                LogException(E);
                Success.Set(context, false);
                ErrorCode.Set(context, "WF_ACTIVITY_EXCEPTION");
                ErrorMessage.Set(context, E.Message);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMGetSecurityGroupsFromProviderActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Output")]
        [DisplayName("SecurityGroups")]
        public OutArgument<JsonArray> SecurityGroups { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Error Code")]
        public OutArgument<string> ErrorCode { get; set; }

        [Category("Output")]
        [DisplayName("Error Message")]
        public OutArgument<string> ErrorMessage { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {ConfigID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);
                Success.Set(context, false);
                ErrorCode.Set(context, string.Empty);
                ErrorMessage.Set(context, string.Empty);

                var securityGroups = getSecurityGroupsFromProvider(ConfigID.Get(context)).GetAwaiter().GetResult() ?? Enumerable.Empty<SecurityGroupEntry>();
                var securityGroupJson = securityGroups.Select(sg => JsonValue.Parse(JsonConvert.SerializeObject(sg)));
                SecurityGroups.Set(context, new JsonArray(securityGroupJson));
                Success.Set(context, true);

                if (!string.IsNullOrWhiteSpace(LastOperationErrorCode))
                {
                    Success.Set(context, false);
                    ErrorCode.Set(context, LastOperationErrorCode);
                    ErrorMessage.Set(context, LastOperationErrorMessage);
                }
            }
            catch (Exception E)
            {
                LogException(E);
                Success.Set(context, false);
                ErrorCode.Set(context, "WF_ACTIVITY_EXCEPTION");
                ErrorMessage.Set(context, E.Message);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMGetOwnersFromDataAreaActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("DataArea Id")]
        [RequiredArgument]
        public InArgument<Guid> DataAreaID { get; set; }

        [Category("Output")]
        [DisplayName("Owner User IDs")]
        public OutArgument<JsonArray> OwnerUserIDs { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {DataAreaID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);

                var ownersInfo = getOwnerInfosFromDataArea(DataAreaID.Get(context)).GetAwaiter().GetResult() ?? new List<cLiamUserInfo>();
                var owners = getPersonsFromUsers(ownersInfo) ?? new List<Guid>();
                var ownerJson = owners.Select(user => JsonValue.Parse(JsonConvert.SerializeObject(user)));
                OwnerUserIDs.Set(context, new JsonArray(ownerJson));
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMGrantPermissionActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("DataArea Id")]
        [RequiredArgument]
        public InArgument<Guid> DataAreaID { get; set; }

        [Category("Input")]
        [DisplayName("User Id")]
        [RequiredArgument]
        public InArgument<Guid> UserID { get; set; }

        [Category("Input")]
        [DisplayName("AccessType")]
        [RequiredArgument]
        public InArgument<Int32> AccessType { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {DataAreaID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);

                var result = grantPermission(DataAreaID.Get(context), UserID.Get(context), AccessType.Get(context), Guid.Empty).GetAwaiter().GetResult();
                Success.Set(context, result.Valid);
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }
        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }
    public class C4ITLIAMCloneTeamActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Input")]
        [DisplayName("Team Id")]
        [RequiredArgument]
        public InArgument<string> TeamId { get; set; }

        [Category("Input")]
        [DisplayName("Name")]
        [RequiredArgument]
        public InArgument<string> Name { get; set; }

        [Category("Input")]
        [DisplayName("Description")]
        [RequiredArgument]
        public InArgument<string> Description { get; set; }

        [Category("Input")]
        [DisplayName("Visibility")]
        [RequiredArgument]
        public InArgument<Int32> Visibility { get; set; }

        [Category("Input")]
        [DisplayName("Parts to Clone")]
        [RequiredArgument]
        public InArgument<Int32> PartsToClone { get; set; }

        [Category("Input")]
        [DisplayName("Additional Members")]
        [RequiredArgument]
        public InArgument<string> AdditionalMembers { get; set; }

        [Category("Input")]
        [DisplayName("Additional Owners")]
        [RequiredArgument]
        public InArgument<string> AdditionalOwners { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("CreatedTeamId")]
        public OutArgument<Guid> CreatedTeamId { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {TeamId.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);

                var result = cloneTeam(ConfigID.Get(context), TeamId.Get(context), Name.Get(context), Description.Get(context), Visibility.Get(context), PartsToClone.Get(context), AdditionalMembers.Get(context), AdditionalOwners.Get(context)).GetAwaiter().GetResult();
                Success.Set(context, result != null);

                if (result?.Result?.targetResourceId != null)
                {
                    string idString = result.Result.targetResourceId.ToString();
                    if (Guid.TryParse(idString, out Guid teamGuid))
                    {
                        CreatedTeamId.Set(context, teamGuid);
                    }
                    else
                    {
                        LogEntry($"targetResourceId '{idString}' is not a valid Guid.", LogLevels.Warning);
                        // Optional: alternativ hier einen Fehler werfen oder Guid.Empty zuweisen
                        CreatedTeamId.Set(context, Guid.Empty);
                    }
                }
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMRevokePermissionActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("DataArea Id")]
        [RequiredArgument]
        public InArgument<Guid> DataAreaID { get; set; }

        [Category("Input")]
        [DisplayName("User Id")]
        [RequiredArgument]
        public InArgument<Guid> UserID { get; set; }

        [Category("Input")]
        [DisplayName("AccessType")]
        [RequiredArgument]
        public InArgument<Int32> AccessType { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);

            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}':", LogLevels.Info);
                LogEntry($"  Local server name: {Environment.MachineName}", LogLevels.Info);
                LogEntry($"  Activity input string: {DataAreaID.Get(context)}", LogLevels.Info);

                EnsureDataProviders(context);

                var result = revokePermission(DataAreaID.Get(context), UserID.Get(context), AccessType.Get(context), Guid.Empty).GetAwaiter().GetResult();
                Success.Set(context, result);
            }
            catch (Exception E)
            {
                LogException(E);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMCreateDistributionGroupActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Input")]
        [DisplayName("Name")]
        [RequiredArgument]
        public InArgument<string> Name { get; set; }

        [Category("Input")]
        [DisplayName("Alias")]
        [RequiredArgument]
        public InArgument<string> Alias { get; set; }

        [Category("Input")]
        [DisplayName("Distribution List Display Name")]
        public InArgument<string> DistributionListDisplayName { get; set; }

        [Category("Input")]
        [DisplayName("Primary SMTP Address")]
        public InArgument<string> PrimarySmtpAddress { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Object GUID")]
        public OutArgument<Guid> ObjectGuid { get; set; }

        [Category("Output")]
        [DisplayName("Created Groups")]
        public OutArgument<List<Tuple<string, string, string, string>>> CreatedGroups { get; set; }

        [Category("Output")]
        [DisplayName("Error Code")]
        public OutArgument<string> ErrorCode { get; set; }

        [Category("Output")]
        [DisplayName("Error Message")]
        public OutArgument<string> ErrorMessage { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}'", LogLevels.Info);

                EnsureDataProviders(context);
                ErrorCode.Set(context, string.Empty);
                ErrorMessage.Set(context, string.Empty);

                var entry = getDataProvider(ConfigID.Get(context));
                if (entry != null && entry.Provider is cLiamProviderExchange ex)
                {
                    var result = ex.exchangeManager.CreateDistributionGroupWithOwnershipGroups(
                        Name.Get(context),
                        Alias.Get(context),
                        DistributionListDisplayName.Get(context),
                        PrimarySmtpAddress.Get(context),
                        out string errorCode,
                        out string errorMessage
                    );
                    ErrorCode.Set(context, errorCode);
                    ErrorMessage.Set(context, errorMessage);

                    if (result != null)
                    {
                        Success.Set(context, true);
                        ObjectGuid.Set(context, result.Item1);
                        CreatedGroups.Set(context, result.Item2);
                        LogEntry(
                            $"Distribution group creation succeeded. ObjectGuid='{result.Item1}', CreatedGroups='{result.Item2?.Count ?? 0}'",
                            LogLevels.Info);
                    }
                    else
                    {
                        Success.Set(context, false);
                        LogEntry(
                            $"Distribution group creation failed [{errorCode}] {errorMessage}",
                            LogLevels.Error);
                    }
                }
                else
                {
                    Success.Set(context, false);
                    ErrorCode.Set(context, "WF_PROVIDER_INVALID");
                    ErrorMessage.Set(context, $"Provider is not a cLiamProviderExchange for config '{ConfigID.Get(context)}'.");
                    LogEntry(
                        $"Distribution group creation failed [WF_PROVIDER_INVALID] Provider is not a cLiamProviderExchange for config '{ConfigID.Get(context)}'.",
                        LogLevels.Error);
                }
            }
            catch (Exception e)
            {
                LogException(e);
                Success.Set(context, false);
                ErrorCode.Set(context, "WF_ACTIVITY_EXCEPTION");
                ErrorMessage.Set(context, e.Message);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMCreateSharedMailboxActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Input")]
        [DisplayName("Name")]
        [RequiredArgument]
        public InArgument<string> Name { get; set; }

        [Category("Input")]
        [DisplayName("Alias")]
        [RequiredArgument]
        public InArgument<string> Alias { get; set; }

        [Category("Input")]
        [DisplayName("Shared Mailbox Display Name")]
        public InArgument<string> MailboxDisplayName { get; set; }

        [Category("Input")]
        [DisplayName("Primary SMTP Address")]
        public InArgument<string> PrimarySmtpAddress { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Object GUID")]
        public OutArgument<Guid> ObjectGuid { get; set; }

        [Category("Output")]
        [DisplayName("Created Groups")]
        public OutArgument<List<Tuple<string, string, string, string>>> CreatedGroups { get; set; }

        [Category("Output")]
        [DisplayName("Error Code")]
        public OutArgument<string> ErrorCode { get; set; }

        [Category("Output")]
        [DisplayName("Error Message")]
        public OutArgument<string> ErrorMessage { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}'", LogLevels.Info);

                EnsureDataProviders(context);
                ErrorCode.Set(context, string.Empty);
                ErrorMessage.Set(context, string.Empty);

                var entry = getDataProvider(ConfigID.Get(context));
                if (entry != null && entry.Provider is cLiamProviderExchange ex)
                {
                    var result = ex.exchangeManager.CreateSharedMailboxWithOwnershipGroups(
                        Name.Get(context),
                        Alias.Get(context),
                        MailboxDisplayName.Get(context),
                        PrimarySmtpAddress.Get(context),
                        out string errorCode,
                        out string errorMessage
                    );
                    ErrorCode.Set(context, errorCode);
                    ErrorMessage.Set(context, errorMessage);

                    if (result != null)
                    {
                        Success.Set(context, true);
                        ObjectGuid.Set(context, result.Item1);
                        CreatedGroups.Set(context, result.Item2);
                        LogEntry(
                            $"Shared mailbox creation succeeded. ObjectGuid='{result.Item1}', CreatedGroups='{result.Item2?.Count ?? 0}'",
                            LogLevels.Info);
                    }
                    else
                    {
                        Success.Set(context, false);
                        LogEntry(
                            $"Shared mailbox creation failed [{errorCode}] {errorMessage}",
                            LogLevels.Error);
                    }
                }
                else
                {
                    Success.Set(context, false);
                    ErrorCode.Set(context, "WF_PROVIDER_INVALID");
                    ErrorMessage.Set(context, $"Provider is not a cLiamProviderExchange for config '{ConfigID.Get(context)}'.");
                    LogEntry(
                        $"Shared mailbox creation failed [WF_PROVIDER_INVALID] Provider is not a cLiamProviderExchange for config '{ConfigID.Get(context)}'.",
                        LogLevels.Error);
                }
            }
            catch (Exception e)
            {
                LogException(e);
                Success.Set(context, false);
                ErrorCode.Set(context, "WF_ACTIVITY_EXCEPTION");
                ErrorMessage.Set(context, e.Message);
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMCreateADServiceGroupActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Input")]
        [DisplayName("Service Name")]
        [RequiredArgument]
        public InArgument<string> ServiceName { get; set; }

        [Category("Input")]
        [DisplayName("Description")]
        public InArgument<string> Description { get; set; }

        // Neu: Integer statt Enum
        [Category("Input")]
        [DisplayName("Group Scope (2=Global, 4=Local, 8=Universal)")]
        public InArgument<int> GroupScope { get; set; }

        [Category("Input")]
        [DisplayName("Group Type (1=Distribution Group, 0=Security/General)")]
        public InArgument<int> GroupType { get; set; }

        [Category("Input")]
        [DisplayName("Owner SIDs (optional)")]
        public InArgument<IEnumerable<string>> OwnerSids { get; set; }

        [Category("Input")]
        [DisplayName("Member SIDs (optional)")]
        public InArgument<IEnumerable<string>> MemberSids { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Created Groups")]
        public OutArgument<List<Tuple<string, string, string, string>>> CreatedGroups { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            if (!IsInitialized) Initialize(context);
            var CM = MethodBase.GetCurrentMethod();
            LogMethodBegin(CM);
            try
            {
                LogEntry($"Executing activity '{GetType().Name}'", LogLevels.Info);
                EnsureDataProviders(context);

                var entry = getDataProvider(ConfigID.Get(context));
                if (entry?.Provider is cLiamProviderAD adProv)
                {
                    var svcName = ServiceName.Get(context);
                    var desc = Description.Get(context);

                    // 1) Scope-Bit auslesen oder Default (8 = Universal)
                    int scopeBit = GroupScope.Expression != null
                        ? GroupScope.Get(context)
                        : 8;
                    eLiamAccessRoleScopes scopeEnum;
                    switch (scopeBit)
                    {
                        case 2:
                            scopeEnum = eLiamAccessRoleScopes.Global;
                            break;
                        case 4:
                            scopeEnum = eLiamAccessRoleScopes.DomainLocal;
                            break;
                        case 8:
                            scopeEnum = eLiamAccessRoleScopes.Universal;
                            break;
                        default:
                            throw new ArgumentOutOfRangeException(
                                nameof(scopeBit), $"Ungültiger Gruppenbereich: {scopeBit}");
                    }

                    // 2) Type-Bit auslesen oder Default (1 = Distribution)
                    int typeBit = GroupType.Expression != null
                        ? GroupType.Get(context)
                        : 1;
                    ADGroupType typeEnum;
                    switch (typeBit)
                    {
                        case 1:
                            typeEnum = ADGroupType.Distribution;
                            break;
                        case 0:
                            typeEnum = ADGroupType.Security;
                            break;
                        default:
                            throw new ArgumentOutOfRangeException(
                                nameof(typeBit), $"Ungültiger Gruppentyp: {typeBit}");
                    }

                    var ownerList = OwnerSids.Expression != null ? OwnerSids.Get(context) : null;
                    var memberList = MemberSids.Expression != null ? MemberSids.Get(context) : null;

                    var groups = adProv.CreateServiceGroups(
                        svcName,
                        desc,
                        scopeEnum,
                        typeEnum,
                        ownerList,
                        memberList);
                    Success.Set(context, groups != null);
                    CreatedGroups.Set(context, groups);
                }
                else
                {
                    Success.Set(context, false);
                }
            }
            finally
            {
                LogMethodEnd(CM);
            }
        }
        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }

    public class C4ITLIAMCreateDataAreaActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }
        [RequiredArgument] public InArgument<string> NewFolderPath { get; set; }
        [RequiredArgument] public InArgument<string> ParentFolderPath { get; set; }
        [Category("Output")][DisplayName("Result")] public OutArgument<JsonValue> ResultToken { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            EnsureDataProviders(context);
            var cfgId = ConfigID.Get(context);
            var provider = getDataProvider(cfgId).Provider as cLiamProviderNtfs;
            // evtl. CustomTags, OwnerSIDs etc. aus Activity-Inputs holen
            var res = provider.CreateDataAreaAsync(
                NewFolderPath.Get(context),
                ParentFolderPath.Get(context),
                /*customTags*/null,
                /*ownerSids*/null,
                /*readerSids*/null,
                /*writerSids*/null
            ).GetAwaiter().GetResult();
            ResultToken.Set(context, JsonValue.Parse(JsonConvert.SerializeObject(res)));
        }
        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }

    }

    public class C4ITLIAMEnsureNtfsPermissionGroupsActivity : cLIAMM42BaseActivity
    {
        [Category("Input")]
        [DisplayName("Config Id")]
        [RequiredArgument]
        public InArgument<Guid> ConfigID { get; set; }

        [Category("Input")]
        [DisplayName("Folder Path")]
        [RequiredArgument]
        public InArgument<string> FolderPath { get; set; }

        [Category("Input")]
        [DisplayName("Owner SIDs")]
        public InArgument<string> OwnerSids { get; set; }

        [Category("Input")]
        [DisplayName("Reader SIDs")]
        public InArgument<string> ReaderSids { get; set; }

        [Category("Input")]
        [DisplayName("Writer SIDs")]
        public InArgument<string> WriterSids { get; set; }

        [Category("Input")]
        [DisplayName("Ensure Traverse")]
        public InArgument<bool> EnsureTraverse { get; set; }

        [Category("Output")]
        [DisplayName("Success")]
        public OutArgument<bool> Success { get; set; }

        [Category("Output")]
        [DisplayName("Result")]
        public OutArgument<JsonValue> ResultToken { get; set; }

        protected override void Execute(NativeActivityContext context)
        {
            EnsureDataProviders(context);

            var cfgId = ConfigID.Get(context);
            var providerEntry = getDataProvider(cfgId);
            var provider = providerEntry?.Provider as cLiamProviderNtfs;
            var folderPath = FolderPath.Get(context);
            if (provider == null || string.IsNullOrWhiteSpace(folderPath))
            {
                Success.Set(context, false);
                ResultToken.Set(context, JsonValue.Parse(JsonConvert.SerializeObject(new ResultToken(GetType().Name)
                {
                    resultErrorId = 1,
                    resultMessage = provider == null ? "Configured provider is not NTFS or not initialized." : "Folder path is missing."
                })));
                return;
            }

            var result = provider.EnsureMissingPermissionGroupsAsync(
                folderPath,
                null,
                ParseSidList(OwnerSids.Get(context)),
                ParseSidList(ReaderSids.Get(context)),
                ParseSidList(WriterSids.Get(context)),
                EnsureTraverse.Get(context)).GetAwaiter().GetResult();

            Success.Set(context, result != null && result.resultErrorId == 0);
            ResultToken.Set(context, JsonValue.Parse(JsonConvert.SerializeObject(result)));
        }

        private IEnumerable<string> ParseSidList(string raw)
        {
            if (string.IsNullOrWhiteSpace(raw))
                return Enumerable.Empty<string>();

            var trimmed = raw.Trim();
            if (trimmed.StartsWith("["))
            {
                try
                {
                    return JsonConvert.DeserializeObject<List<string>>(trimmed) ?? Enumerable.Empty<string>();
                }
                catch
                {
                }
            }

            return trimmed
                .Split(new[] { ';', ',', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(i => i.Trim())
                .Where(i => !string.IsNullOrWhiteSpace(i))
                .Distinct(StringComparer.OrdinalIgnoreCase);
        }

        private void EnsureDataProviders(NativeActivityContext context)
        {
            if (executor == null)
                executor = context.GetExtension<IExtensionExecutor>();
            if (schemaReader == null)
                schemaReader = executor.Get<ISchemaReaderProvider>();
            if (dataProvider == null)
                dataProvider = executor.Get<IDataReaderProvider>();
        }
    }
}