Contentstack015_BulkOperationTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Contentstack.Management.Core.Exceptions;
using Contentstack.Management.Core.Models;
using Contentstack.Management.Core.Tests.Helpers;
using Contentstack.Management.Core.Models.Fields;
using Contentstack.Management.Core.Tests.Model;
using Contentstack.Management.Core.Abstractions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;

namespace Contentstack.Management.Core.Tests.IntegrationTest
{
    /// <summary>
    /// Bulk operation integration tests. ClassInitialize ensures environment (find or create "bulk_test_env"), then finds or creates workflow "workflow_test" (2 stages: New stage 1, New stage 2) and publish rule (Stage 2) once.
    /// Tests are independent. Four workflow-based tests assign entries to Stage 1/Stage 2 then run bulk unpublish/publish with/without version and params.
    /// No cleanup so you can verify workflow, publish rules, and entry allotment in the UI.
    /// </summary>
    [TestClass]
    public class Contentstack015_BulkOperationTest
    {
        private Stack _stack;
        private string _contentTypeUid = "bulk_test_content_type";
        private string _testEnvironmentUid = "bulk_test_environment";
#pragma warning disable CS0414
        private string _testReleaseUid = "bulk_test_release";
#pragma warning restore CS0414
        private List<EntryInfo> _createdEntries = new List<EntryInfo>();

        // Workflow and publishing rule for bulk tests (static so one create/delete across all test instances)
#pragma warning disable CS0649
        private static string _bulkTestWorkflowUid;
        private static string _bulkTestWorkflowStageUid;   // Stage 2 (Complete) – used by publish rule and backward compat
        private static string _bulkTestWorkflowStage1Uid;  // Stage 1 (Review)
        private static string _bulkTestWorkflowStage2Uid;  // Stage 2 (Complete) – selected in publishing rule
        private static string _bulkTestPublishRuleUid;
        private static string _bulkTestEnvironmentUid;     // Environment used for workflow/publish rule (ensured in ClassInitialize or Test000b/000c)
        private static string _bulkTestWorkflowSetupError; // Reason workflow setup failed (so workflow_tests can show it)
#pragma warning restore CS0649

        /// <summary>
        /// Fails the test with a clear message from ContentstackErrorException or generic exception.
        /// </summary>
        private static void FailWithError(string operation, Exception ex)
        {
            if (ex is ContentstackErrorException cex)
                AssertLogger.Fail($"{operation} failed. HTTP {(int)cex.StatusCode} ({cex.StatusCode}). ErrorCode: {cex.ErrorCode}. Message: {cex.ErrorMessage ?? cex.Message}");
            else
                AssertLogger.Fail($"{operation} failed: {ex.Message}");
        }

        /// <summary>
        /// Asserts that the exception is a ContentstackErrorException with validation-related status codes (400, 422, etc.)
        /// </summary>
        private static void AssertBulkValidationError(ContentstackErrorException ex, string context)
        {
            var validationStatuses = new[] { HttpStatusCode.BadRequest, HttpStatusCode.UnprocessableEntity, 
                HttpStatusCode.NotFound, HttpStatusCode.Conflict, HttpStatusCode.PreconditionFailed };
            AssertLogger.IsTrue(validationStatuses.Contains(ex.StatusCode), 
                $"{context}: Expected validation error status (400, 422, 404, 409, 412) but got {(int)ex.StatusCode} ({ex.StatusCode}). ErrorCode: {ex.ErrorCode}. Message: {ex.ErrorMessage ?? ex.Message}", 
                "ValidationErrorStatus");
        }

        /// <summary>
        /// Asserts that the exception is a ContentstackErrorException with auth-related status codes
        /// </summary>
        private static void AssertBulkAuthError(ContentstackErrorException ex, string context)
        {
            var authStatuses = new[] { HttpStatusCode.Unauthorized, HttpStatusCode.Forbidden, 
                HttpStatusCode.BadRequest, HttpStatusCode.UnprocessableEntity, HttpStatusCode.PreconditionFailed };
            AssertLogger.IsTrue(authStatuses.Contains(ex.StatusCode), 
                $"{context}: Expected auth error status (401, 403, 400, 422, 412) but got {(int)ex.StatusCode} ({ex.StatusCode}). ErrorCode: {ex.ErrorCode}. Message: {ex.ErrorMessage ?? ex.Message}", 
                "AuthErrorStatus");
        }

        /// <summary>
        /// Asserts that the exception is network-related (timeout, connection failure, etc.)
        /// </summary>
        private static void AssertBulkNetworkError(Exception ex, string context)
        {
            AssertLogger.IsTrue(ex is TaskCanceledException || ex is TimeoutException || 
                ex is HttpRequestException || ex.Message.Contains("timeout") || ex.Message.Contains("connection"), 
                $"{context}: Expected network error but got {ex.GetType().Name}: {ex.Message}", 
                "NetworkErrorType");
        }

        /// <summary>
        /// Expects a bulk operation to fail with specific HTTP status codes
        /// </summary>
        private static void ExpectBulkOperationFailure(System.Action action, string operation, params HttpStatusCode[] acceptableStatuses)
        {
            try
            {
                action();
                AssertLogger.Fail($"{operation} should have failed but succeeded", "BulkOperationShouldFail");
            }
            catch (ContentstackErrorException ex)
            {
                AssertLogger.IsTrue(acceptableStatuses.Contains(ex.StatusCode), 
                    $"{operation}: Expected one of [{string.Join(", ", acceptableStatuses)}] but got {(int)ex.StatusCode} ({ex.StatusCode}). ErrorCode: {ex.ErrorCode}. Message: {ex.ErrorMessage ?? ex.Message}", 
                    "ExpectedFailureStatus");
            }
        }

        /// <summary>
        /// Creates invalid bulk publish details for negative testing
        /// </summary>
        private static BulkPublishDetails CreateInvalidBulkPublishDetails()
        {
            return new BulkPublishDetails
            {
                Entries = new List<BulkPublishEntry>
                {
                    new BulkPublishEntry
                    {
                        Uid = "invalid_entry_uid_" + Guid.NewGuid(),
                        ContentType = "non_existent_content_type",
                        Version = 999,
                        Locale = "invalid-locale"
                    }
                },
                Locales = new List<string> { "invalid-locale" },
                Environments = new List<string> { "non_existent_environment" }
            };
        }

        /// <summary>
        /// Creates empty bulk delete details for negative testing
        /// </summary>
        private static BulkDeleteDetails CreateEmptyBulkDeleteDetails()
        {
            return new BulkDeleteDetails
            {
                Entries = new List<BulkDeleteEntry>()
            };
        }

        /// <summary>
        /// Creates invalid bulk workflow update body for negative testing
        /// </summary>
        private static BulkWorkflowUpdateBody CreateInvalidWorkflowUpdateBody()
        {
            return new BulkWorkflowUpdateBody
            {
                Entries = new List<BulkWorkflowEntry>
                {
                    new BulkWorkflowEntry
                    {
                        Uid = "invalid_entry_uid_" + Guid.NewGuid(),
                        ContentType = "non_existent_content_type",
                        Locale = "invalid-locale"
                    }
                },
                Workflow = new BulkWorkflowStage
                {
                    Uid = "non_existent_workflow_stage_" + Guid.NewGuid(),
                    Comment = "Test invalid workflow assignment",
                    DueDate = "invalid_date_format",
                    Notify = false
                }
            };
        }

        /// <summary>
        /// Asserts that the workflow and both stages were created in ClassInitialize. Call at the start of workflow-based tests so they fail clearly when setup failed.
        /// </summary>
        private static void AssertWorkflowCreated()
        {
            string reason = string.IsNullOrEmpty(_bulkTestWorkflowSetupError) ? "Check auth and stack permissions for workflow create." : _bulkTestWorkflowSetupError;
            AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestWorkflowUid), "Workflow was not created in ClassInitialize. " + reason, "WorkflowUid");
            AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestWorkflowStage1Uid), "Workflow Stage 1 (New stage 1) was not set. " + reason, "WorkflowStage1Uid");
            AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestWorkflowStage2Uid), "Workflow Stage 2 (New stage 2) was not set. " + reason, "WorkflowStage2Uid");
        }

        private static ContentstackClient _client;

        /// <summary>
        /// Returns a Stack instance for the test run (used by ClassInitialize/ClassCleanup).
        /// </summary>
        private static Stack GetStack()
        {
            StackResponse response = StackResponse.getStack(_client.serializer);
            return _client.Stack(response.Stack.APIKey);
        }

        [ClassInitialize]
        public static void ClassInitialize(TestContext context)
        {
            _client = Contentstack.CreateAuthenticatedClient();
            try
            {
                Stack stack = GetStack();
                EnsureBulkTestWorkflowAndPublishingRuleAsync(stack).GetAwaiter().GetResult();
            }
            catch (Exception)
            {
                // Workflow/publish rule setup failed (e.g. auth, plan limits); tests can still run without them
            }
        }

        [ClassCleanup]
        public static void ClassCleanup()
        {
            // Intentionally no cleanup: workflow, publish rules, and entries are left so you can verify them in the UI.
            try { _client?.Logout(); } catch { }
            _client = null;
        }

        [TestInitialize]
        public async Task Initialize()
        {
            StackResponse response = StackResponse.getStack(_client.serializer);
            _stack = _client.Stack(response.Stack.APIKey);

            // Create test environment and release for bulk operations (for new stack)
            try
            {
                await CreateTestEnvironment();
            }
            catch (ContentstackErrorException ex)
            {
                // Environment may already exist on this stack; no action needed
                Console.WriteLine($"[Initialize] CreateTestEnvironment skipped: HTTP {(int)ex.StatusCode} ({ex.StatusCode}). ErrorCode: {ex.ErrorCode}. Message: {ex.ErrorMessage ?? ex.Message}");
            }

            try
            {
                await CreateTestRelease();
            }
            catch (ContentstackErrorException ex)
            {
                Console.WriteLine($"[Initialize] CreateTestRelease skipped: HTTP {(int)ex.StatusCode} ({ex.StatusCode}). ErrorCode: {ex.ErrorCode}. Message: {ex.ErrorMessage ?? ex.Message}");
            }

            if (string.IsNullOrEmpty(_bulkTestWorkflowUid))
            {
                try
                {
                    EnsureBulkTestWorkflowAndPublishingRuleAsync(_stack).GetAwaiter().GetResult();
                }
                catch (Exception ex)
                {
                    _bulkTestWorkflowSetupError = ex is ContentstackErrorException cex
                        ? $"HTTP {(int)cex.StatusCode} ({cex.StatusCode}). ErrorCode: {cex.ErrorCode}. Message: {cex.ErrorMessage ?? cex.Message}"
                        : ex.Message;
                    Console.WriteLine($"[Initialize] Workflow setup failed: {_bulkTestWorkflowSetupError}");
                }
            }
        }

        // Stack.Workflow() not yet migrated — Test000a commented out
        //[TestMethod]
        //[DoNotParallelize]
        //public void Test000a_Should_Create_Workflow_With_Two_Stages()
        //{
        //    TestOutputLogger.LogContext("TestScenario", "CreateWorkflowWithTwoStages");
        //    try
        //    {
        //        const string workflowName = "workflow_test";

        //// Check if a workflow with the same name already exists (e.g. from a previous test run)
        //try
        //{
        //ContentstackResponse listResponse = _stack.Workflow().FindAll();
        //if (listResponse.IsSuccessStatusCode)
        //{
        //var listJson = listResponse.OpenJsonObjectResponse();
        //var existing = (listJson["workflows"]?.AsArray()) ?? (listJson["workflow"]?.AsArray());
        //if (existing != null)
        //{
        //foreach (var wf in existing)
        //{
        //if (wf["name"]?.ToString() == workflowName && wf["uid"] != null)
        //{
        //_bulkTestWorkflowUid = wf["uid"].ToString();
        //var existingStages = wf["workflow_stages"]?.AsArray();
        //if (existingStages != null && existingStages.Count >= 2)
        //{
        //_bulkTestWorkflowStage1Uid = existingStages[0]["uid"]?.ToString();
        //_bulkTestWorkflowStage2Uid = existingStages[1]["uid"]?.ToString();
        //_bulkTestWorkflowStageUid = _bulkTestWorkflowStage2Uid;
        //AssertLogger.IsNotNull(_bulkTestWorkflowStage1Uid, "Stage1Uid");
        //AssertLogger.IsNotNull(_bulkTestWorkflowStage2Uid, "Stage2Uid");
        //return; // Already exists with stages – nothing more to do
        //}
        //}
        //}
        //}
        //}
        //}
        //catch { /* If listing fails, proceed to create */ }
        //
        //var sysAcl = new Dictionary<string, object>
        //{
        //["roles"] = new Dictionary<string, object> { ["uids"] = new List<string>() },
        //["users"] = new Dictionary<string, object> { ["uids"] = new List<string> { "$all" } },
        //["others"] = new Dictionary<string, object>()
        //};
        //
        //var workflowModel = new WorkflowModel
        //{
        //Name = workflowName,
        //Enabled = true,
        //Branches = new List<string> { "main" },
        //ContentTypes = new List<string> { "$all" },
        //AdminUsers = new Dictionary<string, object> { ["users"] = new List<object>() },
        //WorkflowStages = new List<WorkflowStage>
        //{
        //new WorkflowStage
        //{
        //Name = "New stage 1",
        //Color = "#fe5cfb",
        //SystemACL = sysAcl,
        //NextAvailableStages = new List<string> { "$all" },
        //AllStages = true,
        //AllUsers = true,
        //SpecificStages = false,
        //SpecificUsers = false,
        //EntryLock = "$none"
        //},
        //new WorkflowStage
        //{
        //Name = "New stage 2",
        //Color = "#3688bf",
        //SystemACL = new Dictionary<string, object>
        //{
        //["roles"] = new Dictionary<string, object> { ["uids"] = new List<string>() },
        //["users"] = new Dictionary<string, object> { ["uids"] = new List<string> { "$all" } },
        //["others"] = new Dictionary<string, object>()
        //},
        //NextAvailableStages = new List<string> { "$all" },
        //AllStages = true,
        //AllUsers = true,
        //SpecificStages = false,
        //SpecificUsers = false,
        //EntryLock = "$none"
        //}
        //}
        //};
        //
        //// Print what we are sending so failures show the exact request JSON
        //string sentJson = JsonSerializer.Serialize(new { workflow = workflowModel });
        //
        //ContentstackResponse response = _stack.Workflow().Create(workflowModel);
        //string responseBody = null;
        //try { responseBody = response.OpenResponse(); } catch { }
        //
        //AssertLogger.IsNotNull(response, "workflowCreateResponse");
        //AssertLogger.IsTrue(response.IsSuccessStatusCode,
        //$"Workflow create failed: HTTP {(int)response.StatusCode}.\n--- REQUEST BODY ---\n{sentJson}\n--- RESPONSE BODY ---\n{responseBody}", "workflowCreateSuccess");
        //
        //var responseJson = JsonNode.Parse(responseBody ?? "{}")!.AsObject();
        //var workflowObj = responseJson["workflow"];
        //AssertLogger.IsNotNull(workflowObj, "workflowObj");
        //AssertLogger.IsFalse(string.IsNullOrEmpty(workflowObj["uid"]?.ToString()), "Workflow UID is empty.", "workflowUid");
        //
        //_bulkTestWorkflowUid = workflowObj["uid"].ToString();
        //TestOutputLogger.LogContext("WorkflowUid", _bulkTestWorkflowUid);
        //var stages = workflowObj["workflow_stages"]?.AsArray();
        //AssertLogger.IsNotNull(stages, "workflow_stages");
        //AssertLogger.IsTrue(stages.Count >= 2, $"Expected at least 2 stages, got {stages.Count}.", "stagesCount");
        //_bulkTestWorkflowStage1Uid = stages[0]["uid"].ToString(); // New stage 1
        //_bulkTestWorkflowStage2Uid = stages[1]["uid"].ToString(); // New stage 2
        //_bulkTestWorkflowStageUid = _bulkTestWorkflowStage2Uid;
        //}
        //catch (Exception ex)
        //{
        //FailWithError("Create workflow with two stages", ex);
        //}
        //}
        //
        //[TestMethod]
        //[DoNotParallelize]
        //public void Test000b_Should_Create_Publishing_Rule_For_Workflow_Stage2()
        //{
        //TestOutputLogger.LogContext("TestScenario", "CreatePublishingRuleForWorkflowStage2");
        //try
        //{
        //AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestWorkflowUid), "Workflow UID not set. Run Test000a first.", "WorkflowUid");
        //AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestWorkflowStage2Uid), "Workflow Stage 2 UID not set. Run Test000a first.", "WorkflowStage2Uid");
        //
        //if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
        //EnsureBulkTestEnvironment(_stack);
        //AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestEnvironmentUid), "No environment. Run Test000c or ensure ClassInitialize ran (ensure environment failed).", "EnvironmentUid");
        //TestOutputLogger.LogContext("WorkflowUid", _bulkTestWorkflowUid ?? "");
        //TestOutputLogger.LogContext("EnvironmentUid", _bulkTestEnvironmentUid ?? "");
        //
        //// Find existing publish rule for this workflow + stage + environment (e.g. from a previous run)
        //try
        //{
        //ContentstackResponse listResponse = _stack.Workflow().PublishRule().FindAll();
        //if (listResponse.IsSuccessStatusCode)
        //{
        //var listJson = listResponse.OpenJsonObjectResponse();
        //var rules = (listJson["publishing_rules"]?.AsArray()) ?? (listJson["publishing_rule"]?.AsArray());
        //if (rules != null)
        //{
        //foreach (var rule in rules)
        //{
        //if (rule["workflow"]?.ToString() == _bulkTestWorkflowUid
        //&& rule["workflow_stage"]?.ToString() == _bulkTestWorkflowStage2Uid
        //&& rule["environment"]?.ToString() == _bulkTestEnvironmentUid
        //&& rule["uid"] != null)
        //{
        //_bulkTestPublishRuleUid = rule["uid"].ToString();
        //return; // Already exists
        //}
        //}
        //}
        //}
        //}
        //catch { /* If listing fails, proceed to create */ }
        //
        //var publishRuleModel = new PublishRuleModel
        //{
        //WorkflowUid = _bulkTestWorkflowUid,
        //WorkflowStageUid = _bulkTestWorkflowStage2Uid,
        //Environment = _bulkTestEnvironmentUid,
        //Branches = new List<string> { "main" },
        //ContentTypes = new List<string> { "$all" },
        //Locales = new List<string> { "en-us" },
        //Actions = new List<string>(),
        //Approvers = new Approvals { Users = new List<string>(), Roles = new List<string>() },
        //DisableApproval = false
        //};
        //
        //string sentJson = JsonSerializer.Serialize(new { publishing_rule = publishRuleModel });
        //
        //ContentstackResponse response = _stack.Workflow().PublishRule().Create(publishRuleModel);
        //string responseBody = null;
        //try { responseBody = response.OpenResponse(); } catch { }
        //
        //AssertLogger.IsNotNull(response, "publishRuleResponse");
        //AssertLogger.IsTrue(response.IsSuccessStatusCode,
        //$"Publish rule create failed: HTTP {(int)response.StatusCode}.\n--- REQUEST BODY ---\n{sentJson}\n--- RESPONSE BODY ---\n{responseBody}", "publishRuleCreateSuccess");
        //
        //var responseJson = JsonNode.Parse(responseBody ?? "{}")!.AsObject();
        //var ruleObj = responseJson["publishing_rule"];
        //AssertLogger.IsNotNull(ruleObj, "publishing_rule");
        //AssertLogger.IsFalse(string.IsNullOrEmpty(ruleObj["uid"]?.ToString()), "Publishing rule UID is empty.", "publishRuleUid");
        //
        //_bulkTestPublishRuleUid = ruleObj["uid"].ToString();
        //}
        //catch (Exception ex)
        //{
        //FailWithError("Create publishing rule for workflow stage 2", ex);
        //}
        //}


        [TestMethod]
        [DoNotParallelize]
        public async Task Test001_Should_Create_Content_Type_With_Title_Field()
        {
            TestOutputLogger.LogContext("TestScenario", "CreateContentTypeWithTitleField");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                try { await CreateTestEnvironment(); } catch (ContentstackErrorException) { /* optional */ }
                try { await CreateTestRelease(); } catch (ContentstackErrorException) { /* optional */ }
                // Create a content type with only a title field
                var contentModelling = new ContentModelling
                {
                    Title = "bulk_test_content_type",
                    Uid = _contentTypeUid,
                    Schema = new List<Field>
                    {
                        new TextboxField
                        {
                            DisplayName = "Title",
                            Uid = "title",
                            DataType = "text",
                            Mandatory = true,
                            Unique = false,
                            Multiple = false
                        }
                    }
                };

                // Create the content type
                ContentstackResponse response = _stack.ContentType().Create(contentModelling);
                var responseJson = response.OpenJsonObjectResponse();

                AssertLogger.IsNotNull(response, "createContentTypeResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, "contentTypeCreateSuccess");
                AssertLogger.IsNotNull(responseJson["content_type"], "content_type");
                AssertLogger.AreEqual(_contentTypeUid, responseJson["content_type"]["uid"].ToString(), "contentTypeUid");
            }
            catch (Exception ex)
            {
                FailWithError("Create content type with title field", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test002_Should_Create_Five_Entries()
        {
            TestOutputLogger.LogContext("TestScenario", "CreateFiveEntries");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                AssertWorkflowCreated();

                // Ensure content type exists (fetch or create)
                bool contentTypeExists = false;
                try
                {
                    ContentstackResponse ctResponse = _stack.ContentType(_contentTypeUid).Fetch();
                    contentTypeExists = ctResponse.IsSuccessStatusCode;
                }
                catch { /* not found */ }
                if (!contentTypeExists)
                {
                    var contentModelling = new ContentModelling
                    {
                        Title = "bulk_test_content_type",
                        Uid = _contentTypeUid,
                        Schema = new List<Field>
                        {
                            new TextboxField
                            {
                                DisplayName = "Title",
                                Uid = "title",
                                DataType = "text",
                                Mandatory = true,
                                Unique = false,
                                Multiple = false
                            }
                        }
                    };
                    _stack.ContentType().Create(contentModelling);
                }

                _createdEntries.Clear();
                var entryTitles = new[] { "First Entry", "Second Entry", "Third Entry", "Fourth Entry", "Fifth Entry" };

                foreach (var title in entryTitles)
                {
                    var entry = new SimpleEntry { Title = title };
                    ContentstackResponse response = _stack.ContentType(_contentTypeUid).Entry().Create(entry);
                    var responseJson = response.OpenJsonObjectResponse();

                    AssertLogger.IsNotNull(response, "createEntryResponse");
                    AssertLogger.IsTrue(response.IsSuccessStatusCode, "entryCreateSuccess");
                    AssertLogger.IsNotNull(responseJson["entry"], "entry");
                    AssertLogger.IsNotNull(responseJson["entry"]["uid"], "entryUid");

                    int version = responseJson["entry"]["_version"] != null ? (int)responseJson["entry"]["_version"] : 1;
                    _createdEntries.Add(new EntryInfo
                    {
                        Uid = responseJson["entry"]["uid"].ToString(),
                        Title = responseJson["entry"]["title"]?.ToString() ?? title,
                        Version = version
                    });
                }

                AssertLogger.AreEqual(5, _createdEntries.Count, "Should have created exactly 5 entries", "createdEntriesCount");

                await AssignEntriesToWorkflowStagesAsync(_createdEntries);
            }
            catch (Exception ex)
            {
                FailWithError("Create five entries", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test003_Should_Perform_Bulk_Publish_Operation()
        {
           TestOutputLogger.LogContext("TestScenario", "BulkPublishOperation");
           TestOutputLogger.LogContext("ContentType", _contentTypeUid);
           try
           {
               // Fetch existing entries from the content type
               List<EntryInfo> availableEntries = await FetchExistingEntries();
               AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");

               // Get available environments or use empty list if none available
               List<string> availableEnvironments = await GetAvailableEnvironments();

               // Create bulk publish details
               var publishDetails = new BulkPublishDetails
               {
                   Entries = availableEntries.Select(e => new BulkPublishEntry
                   {
                       Uid = e.Uid,
                       ContentType = _contentTypeUid,
                       Version = 1,
                       Locale = "en-us"
                   }).ToList(),
                   Locales = new List<string> { "en-us" },
                   Environments = availableEnvironments
               };

               // Perform bulk publish; skipWorkflowStage=true bypasses publish rules enforced by workflow stages
               ContentstackResponse response = _stack.BulkOperation().Publish(publishDetails, skipWorkflowStage: true, approvals: true);
               var responseJson = response.OpenJsonObjectResponse();

               AssertLogger.IsNotNull(response, "bulkPublishResponse");
               AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkPublishSuccess");
           }
           catch (ContentstackErrorException cex) when ((int)cex.StatusCode == 422)
           {
               // 422 means entries do not satisfy publish rules (workflow stage restriction); acceptable in integration tests
               Console.WriteLine($"[Test003] Bulk publish skipped due to publish rules: HTTP {(int)cex.StatusCode}. ErrorCode: {cex.ErrorCode}. Message: {cex.ErrorMessage ?? cex.Message}");
           }
           catch (Exception ex)
           {
               FailWithError("Bulk publish", ex);
           }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test004_Should_Perform_Bulk_Unpublish_Operation()
        {
           TestOutputLogger.LogContext("TestScenario", "BulkUnpublishOperation");
           TestOutputLogger.LogContext("ContentType", _contentTypeUid);
           try
           {
               // Fetch existing entries from the content type
               List<EntryInfo> availableEntries = await FetchExistingEntries();
               AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");

               // Get available environments
               List<string> availableEnvironments = await GetAvailableEnvironments();

               // Create bulk unpublish details
               var unpublishDetails = new BulkPublishDetails
               {
                   Entries = availableEntries.Select(e => new BulkPublishEntry
                   {
                       Uid = e.Uid,
                       ContentType = _contentTypeUid,
                       Version = 1,
                       Locale = "en-us"
                   }).ToList(),
                   Locales = new List<string> { "en-us" },
                   Environments = availableEnvironments
               };

               // Perform bulk unpublish; skipWorkflowStage=true bypasses publish rules enforced by workflow stages
               ContentstackResponse response = _stack.BulkOperation().Unpublish(unpublishDetails, skipWorkflowStage: true, approvals: true);
               var responseJson = response.OpenJsonObjectResponse();

               AssertLogger.IsNotNull(response, "bulkUnpublishResponse");
               AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkUnpublishSuccess");
           }
           catch (ContentstackErrorException cex) when ((int)cex.StatusCode == 422)
           {
               // 422 means entries do not satisfy publish rules (workflow stage restriction); acceptable in integration tests
               Console.WriteLine($"[Test004] Bulk unpublish skipped due to publish rules: HTTP {(int)cex.StatusCode}. ErrorCode: {cex.ErrorCode}. Message: {cex.ErrorMessage ?? cex.Message}");
           }
           catch (Exception ex)
           {
               FailWithError("Bulk unpublish", ex);
           }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test003a_Should_Perform_Bulk_Publish_With_SkipWorkflowStage_And_Approvals()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishWithSkipWorkflowStageAndApprovals");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                    await EnsureBulkTestEnvironmentAsync(_stack);
                AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestEnvironmentUid), "No environment. Ensure Test000c or ClassInitialize ran.", "EnvironmentUid");
                TestOutputLogger.LogContext("EnvironmentUid", _bulkTestEnvironmentUid ?? "");

                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation. Run Test002 first.", "availableEntriesCount");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = availableEntries.Select(e => new BulkPublishEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Version = e.Version,
                        Locale = "en-us"
                    }).ToList(),
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { _bulkTestEnvironmentUid },
                    PublishWithReference = true
                };

                ContentstackResponse response = _stack.BulkOperation().Publish(publishDetails, skipWorkflowStage: true, approvals: true);

                AssertLogger.IsNotNull(response, "bulkPublishResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkPublishSuccess");
                AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode");

                var responseJson = response.OpenJsonObjectResponse();
                AssertLogger.IsNotNull(responseJson, "responseJson");
            }
            catch (Exception ex)
            {
                if (ex is ContentstackErrorException cex)
                {
                    string errorsJson = cex.Errors != null && cex.Errors.Count > 0
                        ? JsonSerializer.Serialize(cex.Errors)
                        : "(none)";
                    string failMessage = string.Format(
                        "Bulk publish with skipWorkflowStage and approvals failed. HTTP {0} ({1}). ErrorCode: {2}. Message: {3}. Errors: {4}",
                        (int)cex.StatusCode, cex.StatusCode, cex.ErrorCode, cex.ErrorMessage ?? cex.Message, errorsJson);
                    if ((int)cex.StatusCode == 422 && cex.ErrorCode == 141)
                    {
                        Console.WriteLine(failMessage);
                        AssertLogger.AreEqual(422, (int)cex.StatusCode, "Expected 422 Unprocessable Entity.", "statusCode");
                        AssertLogger.AreEqual(141, cex.ErrorCode, "Expected ErrorCode 141 (entries do not satisfy publish rules).", "errorCode");
                        return;
                    }
                    AssertLogger.Fail(failMessage);
                }
                else
                {
                    FailWithError("Bulk publish with skipWorkflowStage and approvals", ex);
                }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test004a_Should_Perform_Bulk_UnPublish_With_SkipWorkflowStage_And_Approvals()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkUnpublishWithSkipWorkflowStageAndApprovals");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                    await EnsureBulkTestEnvironmentAsync(_stack);
                AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestEnvironmentUid), "No environment. Ensure Test000c or ClassInitialize ran.", "EnvironmentUid");
                TestOutputLogger.LogContext("EnvironmentUid", _bulkTestEnvironmentUid ?? "");

                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation. Run Test002 first.", "availableEntriesCount");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = availableEntries.Select(e => new BulkPublishEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Version = e.Version,
                        Locale = "en-us"
                    }).ToList(),
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { _bulkTestEnvironmentUid },
                    PublishWithReference = true
                };

                ContentstackResponse response = _stack.BulkOperation().Unpublish(publishDetails, skipWorkflowStage: false, approvals: true);

                AssertLogger.IsNotNull(response, "bulkUnpublishResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkUnpublishSuccess");
                AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode");

                var responseJson = response.OpenJsonObjectResponse();
                AssertLogger.IsNotNull(responseJson, "responseJson");
            }
            catch (Exception ex)
            {
                if (ex is ContentstackErrorException cex)
                {
                    string errorsJson = cex.Errors != null && cex.Errors.Count > 0
                        ? JsonSerializer.Serialize(cex.Errors)
                        : "(none)";
                    string failMessage = string.Format(
                        "Bulk unpublish with skipWorkflowStage and approvals failed. HTTP {0} ({1}). ErrorCode: {2}. Message: {3}. Errors: {4}",
                        (int)cex.StatusCode, cex.StatusCode, cex.ErrorCode, cex.ErrorMessage ?? cex.Message, errorsJson);
                    if ((int)cex.StatusCode == 422 && (cex.ErrorCode == 141 || cex.ErrorCode == 0))
                    {
                        Console.WriteLine(failMessage);
                        AssertLogger.AreEqual(422, (int)cex.StatusCode, "Expected 422 Unprocessable Entity.", "statusCode");
                        AssertLogger.IsTrue(cex.ErrorCode == 141 || cex.ErrorCode == 0, "Expected ErrorCode 141 or 0 (entries do not satisfy publish rules).", "errorCode");
                        return;
                    }
                    AssertLogger.Fail(failMessage);
                }
                else
                {
                    FailWithError("Bulk unpublish with skipWorkflowStage and approvals", ex);
                }
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test003b_Should_Perform_Bulk_Publish_With_ApiVersion_3_2_With_SkipWorkflowStage_And_Approvals()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishApiVersion32WithSkipWorkflowStageAndApprovals");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                    await EnsureBulkTestEnvironmentAsync(_stack);
                AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestEnvironmentUid), "No environment. Ensure Test000c or ClassInitialize ran.", "EnvironmentUid");

                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation. Run Test002 first.", "availableEntriesCount");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = availableEntries.Select(e => new BulkPublishEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Version = e.Version,
                        Locale = "en-us"
                    }).ToList(),
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { _bulkTestEnvironmentUid },
                    PublishWithReference = true
                };

                ContentstackResponse response = _stack.BulkOperation().Publish(publishDetails, skipWorkflowStage: true, approvals: true, apiVersion: "3.2");

                AssertLogger.IsNotNull(response, "bulkPublishResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk publish with api_version 3.2 failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkPublishSuccess");
                AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode");

                var responseJson = response.OpenJsonObjectResponse();
                AssertLogger.IsNotNull(responseJson, "responseJson");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish with api_version 3.2", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test004b_Should_Perform_Bulk_UnPublish_With_ApiVersion_3_2_With_SkipWorkflowStage_And_Approvals()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkUnpublishApiVersion32WithSkipWorkflowStageAndApprovals");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                    await EnsureBulkTestEnvironmentAsync(_stack);
                AssertLogger.IsFalse(string.IsNullOrEmpty(_bulkTestEnvironmentUid), "No environment. Ensure Test000c or ClassInitialize ran.", "EnvironmentUid");

                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation. Run Test002 first.", "availableEntriesCount");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = availableEntries.Select(e => new BulkPublishEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Version = e.Version,
                        Locale = "en-us"
                    }).ToList(),
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { _bulkTestEnvironmentUid },
                    PublishWithReference = true
                };

                ContentstackResponse response = _stack.BulkOperation().Unpublish(publishDetails, skipWorkflowStage: true, approvals: true, apiVersion: "3.2");

                AssertLogger.IsNotNull(response, "bulkUnpublishResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Bulk unpublish with api_version 3.2 failed with status {(int)response.StatusCode} ({response.StatusCode}).", "bulkUnpublishSuccess");
                AssertLogger.AreEqual(HttpStatusCode.OK, response.StatusCode, $"Expected 200 OK, got {(int)response.StatusCode}.", "statusCode");

                var responseJson = response.OpenJsonObjectResponse();
                AssertLogger.IsNotNull(responseJson, "responseJson");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk unpublish with api_version 3.2", ex);
            }
        }
        //
        //
        //[TestMethod]
        //[DoNotParallelize]
        //public async Task Test005_Should_Perform_Bulk_Release_Operations()
        //{
        //TestOutputLogger.LogContext("TestScenario", "BulkReleaseOperations");
        //TestOutputLogger.LogContext("ContentType", _contentTypeUid);
        //try
        //{
        //// Fetch existing entries from the content type
        //List<EntryInfo> availableEntries = await FetchExistingEntries();
        //AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");
        //
        //// Fetch an available release
        //string availableReleaseUid = await FetchAvailableRelease();
        //AssertLogger.IsFalse(string.IsNullOrEmpty(availableReleaseUid), "No release available for bulk operations", "availableReleaseUid");
        //if (!string.IsNullOrEmpty(availableReleaseUid))
        //TestOutputLogger.LogContext("ReleaseUid", availableReleaseUid);
        //
        //// First, add items to the release
        //var addItemsData = new BulkAddItemsData
        //{
        //Items = availableEntries.Select(e => new BulkAddItem
        //{
        //Uid = e.Uid,
        //ContentType = _contentTypeUid
        //}).ToList()
        //};
        //
        //// Now perform bulk release operations using AddItems in deployment mode (only 4 entries)
        //var releaseData = new BulkAddItemsData
        //{
        //Release = availableReleaseUid,
        //Action = "publish",
        //Locale = new List<string> { "en-us" },
        //Reference = false,
        //Items = availableEntries.Take(4).Select(e => new BulkAddItem
        //{
        //Uid = e.Uid,
        //ContentType = _contentTypeUid,
        //ContentTypeUid = _contentTypeUid,
        //Version = e.Version,
        //Locale = "en-us",
        //Title = e.Title
        //}).ToList()
        //};
        //
        //// Perform bulk release using AddItems in deployment mode
        //ContentstackResponse releaseResponse = _stack.BulkOperation().AddItems(releaseData, "2.0");
        //var releaseResponseJson = releaseResponse.OpenJsonObjectResponse();
        //
        //AssertLogger.IsNotNull(releaseResponse, "releaseResponse");
        //AssertLogger.IsTrue(releaseResponse.IsSuccessStatusCode, "releaseAddItemsSuccess");
        //
        //// Check if job was created
        //AssertLogger.IsNotNull(releaseResponseJson["job_id"], "job_id");
        //string jobId = releaseResponseJson["job_id"].ToString();
        //
        //// Wait a bit and check job status
        //await Task.Delay(2000);
        //await CheckBulkJobStatus(jobId,"2.0");
        //}
        //catch (Exception ex)
        //{
        //FailWithError("Bulk release operations", ex);
        //}
        //}
        //
        //[TestMethod]
        //[DoNotParallelize]
        //public async Task Test006_Should_Update_Items_In_Release()
        //{
        //TestOutputLogger.LogContext("TestScenario", "UpdateItemsInRelease");
        //TestOutputLogger.LogContext("ContentType", _contentTypeUid);
        //try
        //{
        //// Fetch existing entries from the content type
        //List<EntryInfo> availableEntries = await FetchExistingEntries();
        //AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");
        //
        //// Fetch an available release
        //string availableReleaseUid = await FetchAvailableRelease();
        //AssertLogger.IsFalse(string.IsNullOrEmpty(availableReleaseUid), "No release available for bulk operations", "availableReleaseUid");
        //if (!string.IsNullOrEmpty(availableReleaseUid))
        //TestOutputLogger.LogContext("ReleaseUid", availableReleaseUid);
        //
        //// Alternative: Test bulk update items with version 2.0 for release items
        //var releaseData = new BulkAddItemsData
        //{
        //Release = availableReleaseUid,
        //Action = "publish",
        //Locale = new List<string> { "en-us" },
        //Reference = false,
        //Items = availableEntries.Skip(4).Take(1).Select(e => new BulkAddItem
        //{
        //Uid = e.Uid,
        //ContentType = _contentTypeUid,
        //ContentTypeUid = _contentTypeUid,
        //Version = e.Version,
        //Locale = "en-us",
        //Title = e.Title
        //}).ToList()
        //};
        //
        //ContentstackResponse bulkUpdateResponse = _stack.BulkOperation().UpdateItems(releaseData, "2.0");
        //var bulkUpdateResponseJson = bulkUpdateResponse.OpenJsonObjectResponse();
        //
        //AssertLogger.IsNotNull(bulkUpdateResponse, "bulkUpdateResponse");
        //AssertLogger.IsTrue(bulkUpdateResponse.IsSuccessStatusCode, "bulkUpdateSuccess");
        //
        //if (bulkUpdateResponseJson["job_id"] != null)
        //{
        //string bulkJobId = bulkUpdateResponseJson["job_id"].ToString();
        //
        //// Check job status
        //await Task.Delay(2000);
        //await CheckBulkJobStatus(bulkJobId, "2.0");
        //}
        //}
        //catch (Exception ex)
        //{
        //FailWithError("Update items in release", ex);
        //}
        //}
        //
        //[TestMethod]
        //[DoNotParallelize]
        public async Task Test007_Should_Perform_Bulk_Delete_Operation()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkDeleteOperation");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");

                var deleteDetails = new BulkDeleteDetails
                {
                    Entries = availableEntries.Select(e => new BulkDeleteEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Locale = "en-us"
                    }).ToList()
                };

                // Skip actual delete so entries remain for UI verification. SDK usage is validated by building the payload.
                AssertLogger.IsNotNull(deleteDetails, "deleteDetails");
                AssertLogger.IsTrue(deleteDetails.Entries.Count > 0, "deleteDetailsEntriesCount");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk delete", ex);
            }
        }

       
        [TestMethod]
        [DoNotParallelize]
        public async Task Test008_Should_Perform_Bulk_Workflow_Operations()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowOperations");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                // Fetch existing entries from the content type
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                AssertLogger.IsTrue(availableEntries.Count > 0, "No entries available for bulk operation", "availableEntriesCount");

                // Test bulk workflow update operations (use real stage UID from EnsureBulkTestWorkflowAndPublishingRuleAsync when available)
                string workflowStageUid = !string.IsNullOrEmpty(_bulkTestWorkflowStageUid) ? _bulkTestWorkflowStageUid : "workflow_stage_uid";
                var workflowUpdateBody = new BulkWorkflowUpdateBody
                {
                    Entries = availableEntries.Select(e => new BulkWorkflowEntry
                    {
                        Uid = e.Uid,
                        ContentType = _contentTypeUid,
                        Locale = "en-us"
                    }).ToList(),
                    Workflow = new BulkWorkflowStage
                    {
                        Comment = "Bulk workflow update test",
                        DueDate = DateTime.Now.AddDays(7).ToString("ddd MMM dd yyyy"),
                        Notify = false,
                        Uid = workflowStageUid
                    }
                };

                ContentstackResponse response = _stack.BulkOperation().Update(workflowUpdateBody);
                var responseJson = response.OpenJsonObjectResponse();

                AssertLogger.IsNotNull(response, "bulkWorkflowResponse");
                AssertLogger.IsTrue(response.IsSuccessStatusCode, "bulkWorkflowSuccess");
                AssertLogger.IsNotNull(responseJson["job_id"], "job_id");
                string jobId = responseJson["job_id"].ToString();
                await CheckBulkJobStatus(jobId);
            }
            catch (ContentstackErrorException ex) when (ex.StatusCode == (HttpStatusCode)412 && ex.ErrorCode == 366)
            {
                // Stage Update Request Failed (412/366) – acceptable when workflow/entry state does not allow the transition
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow operations", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test009_Should_Cleanup_Test_Resources()
        {
            TestOutputLogger.LogContext("TestScenario", "CleanupTestResources");
            TestOutputLogger.LogContext("ContentType", _contentTypeUid);
            try
            {
                // 1. Delete all entries created during the test run
                if (_createdEntries != null)
                {
                    foreach (var entry in _createdEntries)
                    {
                        try
                        {
                            _stack.ContentType(_contentTypeUid).Entry(entry.Uid).Delete();
                            Console.WriteLine($"[Cleanup] Deleted entry: {entry.Uid}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"[Cleanup] Failed to delete entry {entry.Uid}: {ex.Message}");
                        }
                    }
                    _createdEntries.Clear();
                }

                // 2. Delete the content type
                if (!string.IsNullOrEmpty(_contentTypeUid))
                {
                    try
                    {
                        _stack.ContentType(_contentTypeUid).Delete();
                        Console.WriteLine($"[Cleanup] Deleted content type: {_contentTypeUid}");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"[Cleanup] Failed to delete content type {_contentTypeUid}: {ex.Message}");
                    }
                }

                // 3. Cleanup workflow and publishing rule
                CleanupBulkTestWorkflowAndPublishingRule(_stack);
                Console.WriteLine("[Cleanup] Workflow and publishing rule cleanup done.");

                // 4. Cleanup release
                if (!string.IsNullOrEmpty(_testReleaseUid))
                {
                    try
                    {
                        _stack.Release(_testReleaseUid).Delete();
                        Console.WriteLine($"[Cleanup] Deleted release: {_testReleaseUid}");
                        _testReleaseUid = null;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"[Cleanup] Failed to delete release {_testReleaseUid}: {ex.Message}");
                    }
                }

                // 5. Delete the test environment
                if (!string.IsNullOrEmpty(_testEnvironmentUid))
                {
                    try
                    {
                        _stack.Environment(_testEnvironmentUid).Delete();
                        Console.WriteLine($"[Cleanup] Deleted environment: {_testEnvironmentUid}");
                        _testEnvironmentUid = null;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"[Cleanup] Failed to delete environment {_testEnvironmentUid}: {ex.Message}");
                    }
                }
            }
            catch (Exception ex)
            {
                FailWithError("Cleanup test resources", ex);
            }
        }

        // ==================== CLIENT-SIDE VALIDATION ERROR TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public void Test010_BulkPublish_Should_Throw_ArgumentNullException_For_Null_Details()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishNullDetailsValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().Publish(null), "BulkPublish_NullDetails");
                AssertLogger.IsTrue(ex.ParamName == "details" || ex.Message.Contains("details"),
                    "Expected parameter name 'details' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish null details validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test011_BulkUnpublish_Should_Throw_ArgumentNullException_For_Null_Details()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkUnpublishNullDetailsValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().Unpublish(null), "BulkUnpublish_NullDetails");
                AssertLogger.IsTrue(ex.ParamName == "details" || ex.Message.Contains("details"),
                    "Expected parameter name 'details' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk unpublish null details validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test012_BulkDelete_Should_Throw_ArgumentNullException_For_Null_Details()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkDeleteNullDetailsValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().Delete(null), "BulkDelete_NullDetails");
                AssertLogger.IsTrue(ex.ParamName == "details" || ex.Message.Contains("details"),
                    "Expected parameter name 'details' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk delete null details validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test013_BulkWorkflowUpdate_Should_Throw_ArgumentNullException_For_Null_Body()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowUpdateNullBodyValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().Update(null), "BulkWorkflowUpdate_NullBody");
                AssertLogger.IsTrue(ex.ParamName == "body" || ex.Message.Contains("body"),
                    "Expected parameter name 'body' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow update null body validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test014_BulkAddItems_Should_Throw_ArgumentNullException_For_Null_Data()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkAddItemsNullDataValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().AddItems(null), "BulkAddItems_NullData");
                AssertLogger.IsTrue(ex.ParamName == "data" || ex.Message.Contains("data"),
                    "Expected parameter name 'data' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk add items null data validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test015_JobStatus_Should_Throw_ArgumentNullException_For_Null_JobId()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusNullJobIdValidation");
            try
            {
                var ex = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().JobStatus(null), "JobStatus_NullJobId");
                AssertLogger.IsTrue(ex.ParamName == "jobId" || ex.Message.Contains("jobId"),
                    "Expected parameter name 'jobId' in ArgumentNullException", "ParameterName");
            }
            catch (Exception ex)
            {
                FailWithError("Job status null jobId validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test016_BulkOperations_Should_Fail_When_Not_Logged_In()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsNotLoggedInValidation");
            try
            {
                // Create unauthenticated client
                var unauthenticatedClient = new ContentstackClient();
                StackResponse response = StackResponse.getStack(_client.serializer);
                var unauthenticatedStack = unauthenticatedClient.Stack(response.Stack.APIKey);

                var publishDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry> { new BulkPublishEntry { Uid = "test", ContentType = "test", Version = 1, Locale = "en-us" } },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test" }
                };

                // Test bulk publish
                var publishEx = AssertLogger.ThrowsException<InvalidOperationException>(() =>
                    unauthenticatedStack.BulkOperation().Publish(publishDetails), "BulkPublish_NotLoggedIn");
                AssertLogger.IsTrue(publishEx.Message.IndexOf("not logged in", StringComparison.OrdinalIgnoreCase) >= 0,
                    "Expected 'not logged in' message", "NotLoggedInMessage");

                // Test bulk unpublish
                var unpublishEx = AssertLogger.ThrowsException<InvalidOperationException>(() =>
                    unauthenticatedStack.BulkOperation().Unpublish(publishDetails), "BulkUnpublish_NotLoggedIn");
                AssertLogger.IsTrue(unpublishEx.Message.IndexOf("not logged in", StringComparison.OrdinalIgnoreCase) >= 0,
                    "Expected 'not logged in' message", "NotLoggedInMessage");

                // Test bulk delete
                var deleteDetails = new BulkDeleteDetails
                {
                    Entries = new List<BulkDeleteEntry> { new BulkDeleteEntry { Uid = "test", ContentType = "test", Locale = "en-us" } }
                };
                var deleteEx = AssertLogger.ThrowsException<InvalidOperationException>(() =>
                    unauthenticatedStack.BulkOperation().Delete(deleteDetails), "BulkDelete_NotLoggedIn");
                AssertLogger.IsTrue(deleteEx.Message.IndexOf("not logged in", StringComparison.OrdinalIgnoreCase) >= 0,
                    "Expected 'not logged in' message", "NotLoggedInMessage");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations not logged in validation", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test017_BulkOperations_Should_Fail_With_Invalid_Auth_Token()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsInvalidAuthToken");
            try
            {
                // Create client with invalid auth token
                var invalidClient = new ContentstackClient();
                // Note: LoginAsync requires ICredentials, not string
                // invalidClient.LoginAsync("invalid_authtoken_12345").Wait();
                
                StackResponse response = StackResponse.getStack(_client.serializer);
                var invalidStack = invalidClient.Stack(response.Stack.APIKey);

                var publishDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry> { new BulkPublishEntry { Uid = "test", ContentType = "test", Version = 1, Locale = "en-us" } },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test" }
                };

                var ex = AssertLogger.ThrowsException<InvalidOperationException>(() =>
                    invalidStack.BulkOperation().Publish(publishDetails), "BulkPublish_InvalidAuthToken");
                AssertLogger.IsTrue(ex.Message.Contains("not logged in"), 
                    "Expected 'not logged in' message", "LoggedInMessage");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations invalid auth token", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test018_BulkOperations_Should_Fail_With_Empty_API_Key()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsEmptyApiKey");
            try
            {
                // Create stack with empty API key
                var emptyKeyStack = _client.Stack("");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry> { new BulkPublishEntry { Uid = "test", ContentType = "test", Version = 1, Locale = "en-us" } },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test" }
                };

                var ex = AssertLogger.ThrowsException<InvalidOperationException>(() =>
                    emptyKeyStack.BulkOperation().Publish(publishDetails), "BulkPublish_EmptyApiKey");
                AssertLogger.IsTrue(ex.Message.Contains("API Key"), 
                    "Expected API Key related message", "ApiKeyMessage");
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations empty API key", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test019_BulkOperations_Should_Fail_With_Invalid_Stack_API_Key()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsInvalidStackApiKey");
            try
            {
                // Create stack with invalid API key
                var invalidStack = _client.Stack("invalid_stack_api_key_12345");

                var publishDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry> { new BulkPublishEntry { Uid = "test", ContentType = "test", Version = 1, Locale = "en-us" } },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test" }
                };

                try
                {
                    invalidStack.BulkOperation().Publish(publishDetails);
                    AssertLogger.Fail("Expected exception for invalid stack API key", "BulkPublish_InvalidStackKey_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertBulkValidationError(ex, "BulkPublish_InvalidStackApiKey");
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 404, 400, 422, or 412 for invalid stack API key, got {(int)ex.StatusCode}", "InvalidStackKeyStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations invalid stack API key", ex);
            }
        }

        // ==================== HTTP ERROR RESPONSE TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public void Test020_BulkPublish_Should_Handle_400_Bad_Request_For_Invalid_Payload()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublish400BadRequest");
            try
            {
                var invalidDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "", // Empty UID should cause validation error
                            ContentType = "", // Empty content type should cause validation error
                            Version = 0, // Invalid version
                            Locale = "" // Empty locale should cause validation error
                        }
                    },
                    Locales = new List<string>(), // Empty locales
                    Environments = new List<string>() // Empty environments
                };

                try
                {
                    _stack.BulkOperation().Publish(invalidDetails);
                    AssertLogger.Fail("Expected 400 Bad Request for invalid payload", "BulkPublish_InvalidPayload_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for invalid payload, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidPayloadStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish 400 bad request test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test021_BulkDelete_Should_Handle_400_Bad_Request_For_Malformed_Data()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkDelete400BadRequest");
            try
            {
                var malformedDetails = new BulkDeleteDetails
                {
                    Entries = new List<BulkDeleteEntry>
                    {
                        new BulkDeleteEntry
                        {
                            Uid = "invalid@#$%^&*()uid", // Malformed UID with special characters
                            ContentType = "invalid content type with spaces",
                            Locale = "invalid_locale_format"
                        }
                    }
                };

                try
                {
                    _stack.BulkOperation().Delete(malformedDetails);
                    AssertLogger.Fail("Expected 400 Bad Request for malformed data", "BulkDelete_MalformedData_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, 404, or 412 for malformed data, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "MalformedDataStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk delete 400 bad request test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test022_BulkPublish_Should_Handle_404_For_Invalid_Content_Type()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublish404InvalidContentType");
            try
            {
                var invalidDetails = CreateInvalidBulkPublishDetails();
                invalidDetails.Entries[0].ContentType = "absolutely_non_existent_content_type_" + Guid.NewGuid();

                try
                {
                    _stack.BulkOperation().Publish(invalidDetails);
                    AssertLogger.Fail("Expected 404 Not Found for invalid content type", "BulkPublish_InvalidContentType_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed || ex.StatusCode == HttpStatusCode.Unauthorized,
                        $"Expected 404, 400, 422, 412, or 401 for invalid content type, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidContentTypeStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish 404 invalid content type test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test023_BulkPublish_Should_Handle_404_For_Invalid_Environment()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublish404InvalidEnvironment");
            try
            {
                // Fetch existing entries first to make the test more realistic
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var invalidDetails = new BulkPublishDetails
                    {
                        Entries = new List<BulkPublishEntry>
                        {
                            new BulkPublishEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Version = availableEntries[0].Version,
                                Locale = "en-us"
                            }
                        },
                        Locales = new List<string> { "en-us" },
                        Environments = new List<string> { "absolutely_non_existent_environment_" + Guid.NewGuid() }
                    };

                    try
                    {
                        _stack.BulkOperation().Publish(invalidDetails);
                        AssertLogger.Fail("Expected 404 Not Found for invalid environment", "BulkPublish_InvalidEnvironment_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.Unauthorized || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                            $"Expected 404, 400, 422, 401, or 412 for invalid environment, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "InvalidEnvironmentStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test023] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish 404 invalid environment test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test024_BulkWorkflow_Should_Handle_404_For_Invalid_Workflow_Stage()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflow404InvalidWorkflowStage");
            try
            {
                // Fetch existing entries first
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var invalidBody = new BulkWorkflowUpdateBody
                    {
                        Entries = new List<BulkWorkflowEntry>
                        {
                            new BulkWorkflowEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Locale = "en-us"
                            }
                        },
                        Workflow = new BulkWorkflowStage
                        {
                            Uid = "absolutely_non_existent_workflow_stage_" + Guid.NewGuid(),
                            Comment = "Test invalid workflow stage",
                            Notify = false
                        }
                    };

                    try
                    {
                        _stack.BulkOperation().Update(invalidBody);
                        AssertLogger.Fail("Expected 404 Not Found for invalid workflow stage", "BulkWorkflow_InvalidStage_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                            $"Expected 404, 400, 422, or 412 for invalid workflow stage, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "InvalidWorkflowStageStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test024] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow 404 invalid workflow stage test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test025_BulkPublish_Should_Handle_422_For_Publish_Rule_Violations()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublish422PublishRuleViolations");
            try
            {
                // Ensure we have workflow setup
                if (string.IsNullOrEmpty(_bulkTestWorkflowUid))
                {
                    Console.WriteLine("[Test025] Skipped - Workflow not available for testing publish rule violations");
                    return;
                }

                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0 && !string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                {
                    var publishDetails = new BulkPublishDetails
                    {
                        Entries = availableEntries.Select(e => new BulkPublishEntry
                        {
                            Uid = e.Uid,
                            ContentType = _contentTypeUid,
                            Version = e.Version,
                            Locale = "en-us"
                        }).ToList(),
                        Locales = new List<string> { "en-us" },
                        Environments = new List<string> { _bulkTestEnvironmentUid }
                    };

                    try
                    {
                        // Try to publish without skipWorkflowStage=true to trigger publish rule violations
                        _stack.BulkOperation().Publish(publishDetails, skipWorkflowStage: false, approvals: false);
                        Console.WriteLine("[Test025] Publish succeeded - may not have restrictive publish rules configured");
                    }
                    catch (ContentstackErrorException ex) when (ex.StatusCode == HttpStatusCode.UnprocessableEntity)
                    {
                        AssertLogger.AreEqual(422, (int)ex.StatusCode, "Expected 422 Unprocessable Entity for publish rule violations", "PublishRuleViolationStatus");
                        AssertLogger.IsTrue(ex.ErrorCode == 141 || ex.ErrorCode == 0 || ex.ErrorMessage.Contains("publish") || ex.ErrorMessage.Contains("rule") || ex.ErrorMessage.Contains("workflow"),
                            $"Expected publish rule related error code or message, got ErrorCode: {ex.ErrorCode}, Message: {ex.ErrorMessage ?? ex.Message}",
                            "PublishRuleViolationError");
                    }
                }
                else
                {
                    Console.WriteLine("[Test025] Skipped - No entries or environment available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish 422 publish rule violations test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test026_BulkWorkflow_Should_Handle_412_For_Invalid_Stage_Transition()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflow412InvalidStageTransition");
            try
            {
                // Ensure we have workflow setup
                if (string.IsNullOrEmpty(_bulkTestWorkflowStage1Uid))
                {
                    Console.WriteLine("[Test026] Skipped - Workflow stages not available for testing stage transitions");
                    return;
                }

                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var workflowBody = new BulkWorkflowUpdateBody
                    {
                        Entries = new List<BulkWorkflowEntry>
                        {
                            new BulkWorkflowEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Locale = "en-us"
                            }
                        },
                        Workflow = new BulkWorkflowStage
                        {
                            Uid = _bulkTestWorkflowStage1Uid,
                            Comment = "Test invalid stage transition",
                            DueDate = DateTime.Now.AddDays(-1).ToString("ddd MMM dd yyyy"), // Past due date might cause issues
                            Notify = false
                        }
                    };

                    try
                    {
                        _stack.BulkOperation().Update(workflowBody);
                        Console.WriteLine("[Test026] Workflow update succeeded - may not have restrictive stage transition rules");
                    }
                    catch (ContentstackErrorException ex) when (ex.StatusCode == HttpStatusCode.PreconditionFailed)
                    {
                        AssertLogger.AreEqual(412, (int)ex.StatusCode, "Expected 412 Precondition Failed for invalid stage transition", "InvalidStageTransitionStatus");
                        AssertLogger.AreEqual(366, ex.ErrorCode, "Expected ErrorCode 366 for stage update request failed", "StageUpdateErrorCode");
                    }
                }
                else
                {
                    Console.WriteLine("[Test026] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow 412 invalid stage transition test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test027_BulkAddItems_Should_Handle_Invalid_Release_UID()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkAddItemsInvalidReleaseUID");
            try
            {
                var invalidData = new BulkAddItemsData
                {
                    Release = "absolutely_non_existent_release_" + Guid.NewGuid(),
                    Action = "publish",
                    Locale = new List<string> { "en-us" },
                    Reference = false,
                    Items = new List<BulkAddItem>
                    {
                        new BulkAddItem
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid
                        }
                    }
                };

                try
                {
                    _stack.BulkOperation().AddItems(invalidData);
                    AssertLogger.Fail("Expected error for invalid release UID", "BulkAddItems_InvalidReleaseUID_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity,
                        $"Expected 404, 400, or 422 for invalid release UID, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidReleaseUIDStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk add items invalid release UID test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test028_JobStatus_Should_Handle_Invalid_Job_ID()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusInvalidJobID");
            try
            {
                string invalidJobId = "absolutely_non_existent_job_id_" + Guid.NewGuid();

                try
                {
                    _stack.BulkOperation().JobStatus(invalidJobId);
                    AssertLogger.Fail("Expected error for invalid job ID", "JobStatus_InvalidJobID_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected 404 or 400 for invalid job ID, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidJobIDStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Job status invalid job ID test", ex);
            }
        }

        // ==================== BUSINESS LOGIC ERROR TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public async Task Test029_BulkPublish_Should_Handle_Invalid_Entry_UIDs()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishInvalidEntryUIDs");
            try
            {
                var invalidDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "completely_non_existent_entry_" + Guid.NewGuid(),
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        },
                        new BulkPublishEntry
                        {
                            Uid = "another_invalid_entry_" + Guid.NewGuid(),
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "en-us" },
                    Environments = await GetAvailableEnvironments()
                };

                try
                {
                    var response = _stack.BulkOperation().Publish(invalidDetails, skipWorkflowStage: true, approvals: true);
                    // API accepts invalid entry UIDs and processes them asynchronously
                    Console.WriteLine("[Test029] Invalid entry UIDs accepted - API processes them asynchronously and may report errors later in job status");
                    AssertLogger.IsTrue(true, "API accepts invalid entry UIDs for async processing", "BulkPublish_InvalidEntryUIDs_Accepted");
                }
                catch (ContentstackErrorException ex)
                {
                    // If API does return an error, accept various validation error codes
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || 
                        ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed || ex.StatusCode == HttpStatusCode.Unauthorized,
                        $"If API returns error for invalid entry UIDs, expected 404, 400, 422, 412, or 401, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidEntryUIDsStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish invalid entry UIDs test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test030_BulkPublish_Should_Handle_Mismatched_Content_Types()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishMismatchedContentTypes");
            try
            {
                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var mismatchedDetails = new BulkPublishDetails
                    {
                        Entries = new List<BulkPublishEntry>
                        {
                            new BulkPublishEntry
                            {
                                Uid = availableEntries[0].Uid, // Real entry UID
                                ContentType = "wrong_content_type_" + Guid.NewGuid(), // Wrong content type
                                Version = availableEntries[0].Version,
                                Locale = "en-us"
                            }
                        },
                        Locales = new List<string> { "en-us" },
                        Environments = await GetAvailableEnvironments()
                    };

                    try
                    {
                        _stack.BulkOperation().Publish(mismatchedDetails, skipWorkflowStage: true, approvals: true);
                        AssertLogger.Fail("Expected error for mismatched content types", "BulkPublish_MismatchedContentTypes_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotFound,
                            $"Expected 400, 422, or 404 for mismatched content types, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "MismatchedContentTypesStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test030] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish mismatched content types test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test031_BulkPublish_Should_Handle_Invalid_Locale_Combinations()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishInvalidLocaleCombinations");
            try
            {
                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var invalidLocaleDetails = new BulkPublishDetails
                    {
                        Entries = new List<BulkPublishEntry>
                        {
                            new BulkPublishEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Version = availableEntries[0].Version,
                                Locale = "non-existent-locale-xyz"
                            }
                        },
                        Locales = new List<string> { "non-existent-locale-xyz", "another-invalid-locale" },
                        Environments = await GetAvailableEnvironments()
                    };

                    try
                    {
                        _stack.BulkOperation().Publish(invalidLocaleDetails, skipWorkflowStage: true, approvals: true);
                        AssertLogger.Fail("Expected error for invalid locale combinations", "BulkPublish_InvalidLocales_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotFound,
                            $"Expected 400, 422, or 404 for invalid locales, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "InvalidLocalesStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test031] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish invalid locale combinations test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test032_BulkPublish_Should_Handle_Version_Mismatch_Errors()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishVersionMismatch");
            try
            {
                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var versionMismatchDetails = new BulkPublishDetails
                    {
                        Entries = new List<BulkPublishEntry>
                        {
                            new BulkPublishEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Version = 99999, // Very high version that shouldn't exist
                                Locale = "en-us"
                            }
                        },
                        Locales = new List<string> { "en-us" },
                        Environments = await GetAvailableEnvironments()
                    };

                    try
                    {
                        _stack.BulkOperation().Publish(versionMismatchDetails, skipWorkflowStage: true, approvals: true);
                        Console.WriteLine("[Test032] Version mismatch did not cause error - API may be lenient with versions");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.Conflict,
                            $"Expected 400, 422, or 409 for version mismatch, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "VersionMismatchStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test032] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish version mismatch test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test033_BulkDelete_Should_Handle_Already_Deleted_Entries()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkDeleteAlreadyDeletedEntries");
            try
            {
                var deleteDetails = new BulkDeleteDetails
                {
                    Entries = new List<BulkDeleteEntry>
                    {
                        new BulkDeleteEntry
                        {
                            Uid = "already_deleted_entry_" + Guid.NewGuid(),
                            ContentType = _contentTypeUid,
                            Locale = "en-us"
                        },
                        new BulkDeleteEntry
                        {
                            Uid = "another_deleted_entry_" + Guid.NewGuid(),
                            ContentType = _contentTypeUid,
                            Locale = "en-us"
                        }
                    }
                };

                try
                {
                    _stack.BulkOperation().Delete(deleteDetails);
                    AssertLogger.Fail("Expected error for already deleted/non-existent entries", "BulkDelete_AlreadyDeleted_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 404, 400, 422, or 412 for already deleted entries, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "AlreadyDeletedStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk delete already deleted entries test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test034_BulkWorkflow_Should_Handle_Permission_Denied_For_Stage()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowPermissionDenied");
            try
            {
                // This test attempts to assign entries to a workflow stage without proper permissions
                // or using a stage that doesn't allow the current user to assign entries
                
                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    // Use a fake workflow stage UID that might exist but not be accessible
                    var restrictedWorkflowBody = new BulkWorkflowUpdateBody
                    {
                        Entries = new List<BulkWorkflowEntry>
                        {
                            new BulkWorkflowEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Locale = "en-us"
                            }
                        },
                        Workflow = new BulkWorkflowStage
                        {
                            Uid = "restricted_workflow_stage_" + Guid.NewGuid(),
                            Comment = "Test permission denied workflow assignment",
                            Notify = false
                        }
                    };

                    try
                    {
                        _stack.BulkOperation().Update(restrictedWorkflowBody);
                        AssertLogger.Fail("Expected permission denied for restricted workflow stage", "BulkWorkflow_PermissionDenied_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.Forbidden || ex.StatusCode == HttpStatusCode.Unauthorized || 
                            ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                            $"Expected 403, 401, 404, 400, or 412 for permission denied, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "PermissionDeniedStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test034] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow permission denied test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test035_BulkWorkflow_Should_Handle_Entry_Lock_Conflicts()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowEntryLockConflicts");
            try
            {
                // This test simulates trying to update workflow for entries that are locked or in use
                
                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0 && !string.IsNullOrEmpty(_bulkTestWorkflowStage1Uid))
                {
                    // First, try to assign entries to workflow stage 1
                    var firstWorkflowBody = new BulkWorkflowUpdateBody
                    {
                        Entries = new List<BulkWorkflowEntry>
                        {
                            new BulkWorkflowEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Locale = "en-us"
                            }
                        },
                        Workflow = new BulkWorkflowStage
                        {
                            Uid = _bulkTestWorkflowStage1Uid,
                            Comment = "Initial assignment to create potential lock conflict",
                            Notify = false
                        }
                    };

                    try
                    {
                        var firstResponse = _stack.BulkOperation().Update(firstWorkflowBody);
                        if (firstResponse.IsSuccessStatusCode)
                        {
                            // Immediately try to reassign to a different stage - this might cause a lock conflict
                            var conflictWorkflowBody = new BulkWorkflowUpdateBody
                            {
                                Entries = new List<BulkWorkflowEntry>
                                {
                                    new BulkWorkflowEntry
                                    {
                                        Uid = availableEntries[0].Uid,
                                        ContentType = _contentTypeUid,
                                        Locale = "en-us"
                                    }
                                },
                                Workflow = new BulkWorkflowStage
                                {
                                    Uid = _bulkTestWorkflowStage2Uid ?? "different_stage_" + Guid.NewGuid(),
                                    Comment = "Conflicting assignment that might cause lock conflict",
                                    Notify = false
                                }
                            };

                            try
                            {
                                _stack.BulkOperation().Update(conflictWorkflowBody);
                                Console.WriteLine("[Test035] No lock conflict detected - API may allow rapid reassignments");
                            }
                            catch (ContentstackErrorException ex)
                            {
                                AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.Conflict || ex.StatusCode == HttpStatusCode.PreconditionFailed || 
                                    ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity,
                                    $"Expected 409, 412, 400, or 422 for entry lock conflict, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                                    "EntryLockConflictStatus");
                            }
                        }
                    }
                    catch (ContentstackErrorException ex)
                    {
                        // The first assignment itself failed, which is also valid for testing
                        Console.WriteLine($"[Test035] Initial workflow assignment failed: {ex.StatusCode} - {ex.ErrorMessage}");
                    }
                }
                else
                {
                    Console.WriteLine("[Test035] Skipped - No entries or workflow stages available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow entry lock conflicts test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test036_BulkPublish_Should_Handle_Publishing_Rule_Environment_Mismatch()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishPublishingRuleEnvironmentMismatch");
            try
            {
                // This test tries to publish to an environment that doesn't match the publishing rules
                
                if (string.IsNullOrEmpty(_bulkTestWorkflowUid) || string.IsNullOrEmpty(_bulkTestPublishRuleUid))
                {
                    Console.WriteLine("[Test036] Skipped - Workflow and publishing rules not available for testing");
                    return;
                }

                // Fetch existing entries
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    // Try to publish to an environment that's not in the publishing rule
                    var mismatchedEnvironmentDetails = new BulkPublishDetails
                    {
                        Entries = availableEntries.Select(e => new BulkPublishEntry
                        {
                            Uid = e.Uid,
                            ContentType = _contentTypeUid,
                            Version = e.Version,
                            Locale = "en-us"
                        }).ToList(),
                        Locales = new List<string> { "en-us" },
                        Environments = new List<string> { "mismatched_environment_" + Guid.NewGuid() } // Non-rule environment
                    };

                    try
                    {
                        _stack.BulkOperation().Publish(mismatchedEnvironmentDetails, skipWorkflowStage: false, approvals: false);
                        AssertLogger.Fail("Expected error for publishing rule environment mismatch", "BulkPublish_EnvironmentMismatch_NoException");
                    }
                    catch (ContentstackErrorException ex)
                    {
                        AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.BadRequest || 
                            ex.StatusCode == HttpStatusCode.Forbidden || ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.Unauthorized,
                            $"Expected 422, 400, 403, 404, or 401 for environment mismatch, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                            "EnvironmentMismatchStatus");
                    }
                }
                else
                {
                    Console.WriteLine("[Test036] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish publishing rule environment mismatch test", ex);
            }
        }

        // ==================== EDGE CASE & BOUNDARY TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public void Test037_BulkPublish_Should_Handle_Empty_Entries_List()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishEmptyEntriesList");
            try
            {
                var emptyEntriesDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>(), // Empty entries list
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test_env" }
                };

                try
                {
                    _stack.BulkOperation().Publish(emptyEntriesDetails);
                    AssertLogger.Fail("Expected error for empty entries list", "BulkPublish_EmptyEntries_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for empty entries list, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "EmptyEntriesStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish empty entries list test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test038_BulkPublish_Should_Handle_Empty_Environments_List()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishEmptyEnvironmentsList");
            try
            {
                var emptyEnvironmentsDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string>() // Empty environments list
                };

                try
                {
                    _stack.BulkOperation().Publish(emptyEnvironmentsDetails);
                    AssertLogger.Fail("Expected error for empty environments list", "BulkPublish_EmptyEnvironments_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for empty environments list, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "EmptyEnvironmentsStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish empty environments list test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test039_BulkPublish_Should_Handle_Empty_Locales_List()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishEmptyLocalesList");
            try
            {
                var emptyLocalesDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string>(), // Empty locales list
                    Environments = new List<string> { "test_env" }
                };

                try
                {
                    _stack.BulkOperation().Publish(emptyLocalesDetails);
                    Console.WriteLine("[Test039] Empty locales list accepted - API may use default locale");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for empty locales list, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "EmptyLocalesStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish empty locales list test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test040_BulkDelete_Should_Handle_Empty_Delete_List()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkDeleteEmptyDeleteList");
            try
            {
                var emptyDeleteDetails = CreateEmptyBulkDeleteDetails();

                try
                {
                    var response = _stack.BulkOperation().Delete(emptyDeleteDetails);
                    // API accepts empty delete list, so we should not expect an error
                    AssertLogger.IsTrue(true, "API successfully handles empty delete list", "BulkDelete_EmptyList_Accepted");
                }
                catch (ContentstackErrorException ex)
                {
                    // If API does return an error, accept validation error codes
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"If API returns error for empty delete list, expected 400, 422, or 412, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "EmptyDeleteListStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk delete empty delete list test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test041_BulkWorkflow_Should_Handle_Empty_Entries_For_Update()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowEmptyEntriesUpdate");
            try
            {
                var emptyWorkflowBody = new BulkWorkflowUpdateBody
                {
                    Entries = new List<BulkWorkflowEntry>(), // Empty entries list
                    Workflow = new BulkWorkflowStage
                    {
                        Uid = "test_stage",
                        Comment = "Test empty entries workflow update",
                        Notify = false
                    }
                };

                try
                {
                    _stack.BulkOperation().Update(emptyWorkflowBody);
                    AssertLogger.Fail("Expected error for empty entries in workflow update", "BulkWorkflow_EmptyEntries_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for empty entries in workflow update, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "EmptyWorkflowEntriesStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow empty entries update test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test042_BulkPublish_Should_Handle_Invalid_Environment_Locale_Combination()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishInvalidEnvironmentLocaleCombination");
            try
            {
                var invalidCombinationDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "fr-fr" }, // Different locale from entry
                    Environments = new List<string> { "invalid_env_for_locale_" + Guid.NewGuid() }
                };

                try
                {
                    _stack.BulkOperation().Publish(invalidCombinationDetails);
                    AssertLogger.Fail("Expected error for invalid environment-locale combination", "BulkPublish_InvalidEnvLocaleCombination_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.Unauthorized,
                        $"Expected 400, 422, 404, or 401 for invalid environment-locale combination, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidEnvLocaleCombinationStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish invalid environment-locale combination test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test043_BulkAddItems_Should_Handle_Invalid_Release_Action_Combination()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkAddItemsInvalidReleaseActionCombination");
            try
            {
                var invalidActionData = new BulkAddItemsData
                {
                    Release = "test_release",
                    Action = "invalid_action_type", // Invalid action
                    Locale = new List<string> { "en-us" },
                    Reference = false,
                    Items = new List<BulkAddItem>
                    {
                        new BulkAddItem
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid
                        }
                    }
                };

                try
                {
                    _stack.BulkOperation().AddItems(invalidActionData);
                    AssertLogger.Fail("Expected error for invalid release action", "BulkAddItems_InvalidAction_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotFound,
                        $"Expected 400, 422, or 404 for invalid release action, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidReleaseActionStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk add items invalid release action test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test044_BulkWorkflow_Should_Handle_Invalid_Due_Date_Formats()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkWorkflowInvalidDueDateFormats");
            try
            {
                var invalidDueDateBody = CreateInvalidWorkflowUpdateBody();
                invalidDueDateBody.Workflow.DueDate = "invalid_date_format_xyz123";

                try
                {
                    _stack.BulkOperation().Update(invalidDueDateBody);
                    Console.WriteLine("[Test044] Invalid due date format accepted - API may be lenient with date parsing");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, or 412 for invalid due date format, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidDueDateFormatStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk workflow invalid due date formats test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test045_BulkPublish_Should_Handle_Conflicting_Skip_Workflow_And_Approvals()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishConflictingSkipWorkflowApprovals");
            try
            {
                var conflictingDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test_env" }
                };

                try
                {
                    // Try with conflicting parameters: skipWorkflowStage=false but approvals=false
                    // This might create a logical conflict depending on the workflow setup
                    _stack.BulkOperation().Publish(conflictingDetails, skipWorkflowStage: false, approvals: false);
                    Console.WriteLine("[Test045] Conflicting workflow parameters accepted - API may resolve conflicts automatically");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.Conflict || ex.StatusCode == HttpStatusCode.PreconditionFailed || ex.StatusCode == HttpStatusCode.Unauthorized,
                        $"Expected 400, 422, 409, 412, or 401 for conflicting parameters, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "ConflictingParametersStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish conflicting skip workflow and approvals test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test046_BulkOperations_Should_Handle_Maximum_Entry_Limits()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsMaximumEntryLimits");
            try
            {
                // Create a large number of fake entries to test limits
                var largeEntryList = new List<BulkPublishEntry>();
                for (int i = 0; i < 1000; i++) // Try with 1000 entries
                {
                    largeEntryList.Add(new BulkPublishEntry
                    {
                        Uid = $"test_entry_{i}_{Guid.NewGuid()}",
                        ContentType = _contentTypeUid,
                        Version = 1,
                        Locale = "en-us"
                    });
                }

                var largeBulkDetails = new BulkPublishDetails
                {
                    Entries = largeEntryList,
                    Locales = new List<string> { "en-us" },
                    Environments = await GetAvailableEnvironments()
                };

                try
                {
                    _stack.BulkOperation().Publish(largeBulkDetails, skipWorkflowStage: true, approvals: true);
                    Console.WriteLine("[Test046] Large entry list accepted - API may have high limits or process asynchronously");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.RequestEntityTooLarge || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, 413, or 412 for maximum entry limits, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "MaximumEntryLimitsStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations maximum entry limits test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test047_BulkPublish_Should_Handle_Too_Many_Environments()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishTooManyEnvironments");
            try
            {
                // Create a large number of fake environments
                var manyEnvironments = new List<string>();
                for (int i = 0; i < 100; i++) // Try with 100 environments
                {
                    manyEnvironments.Add($"test_env_{i}_{Guid.NewGuid()}");
                }

                var manyEnvDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "en-us" },
                    Environments = manyEnvironments
                };

                try
                {
                    _stack.BulkOperation().Publish(manyEnvDetails);
                    Console.WriteLine("[Test047] Many environments accepted - API may have high limits");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.RequestEntityTooLarge || ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.PreconditionFailed,
                        $"Expected 400, 422, 413, 404, or 412 for too many environments, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "TooManyEnvironmentsStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish too many environments test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test048_BulkPublish_Should_Handle_Unsupported_API_Version()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkPublishUnsupportedAPIVersion");
            try
            {
                var testDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid,
                            Version = 1,
                            Locale = "en-us"
                        }
                    },
                    Locales = new List<string> { "en-us" },
                    Environments = new List<string> { "test_env" }
                };

                try
                {
                    // Try with an unsupported API version
                    _stack.BulkOperation().Publish(testDetails, skipWorkflowStage: true, approvals: true, apiVersion: "99.99");
                    Console.WriteLine("[Test048] Unsupported API version accepted - API may be backward compatible");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.NotAcceptable || ex.StatusCode == HttpStatusCode.Unauthorized,
                        $"Expected 400, 422, 406, or 401 for unsupported API version, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "UnsupportedAPIVersionStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk publish unsupported API version test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test049_BulkAddItems_Should_Handle_Invalid_Bulk_Version()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkAddItemsInvalidBulkVersion");
            try
            {
                var testData = new BulkAddItemsData
                {
                    Items = new List<BulkAddItem>
                    {
                        new BulkAddItem
                        {
                            Uid = "test_entry",
                            ContentType = _contentTypeUid
                        }
                    }
                };

                try
                {
                    // Try with an invalid bulk version
                    _stack.BulkOperation().AddItems(testData, "invalid_version_99.99");
                    Console.WriteLine("[Test049] Invalid bulk version accepted - API may ignore unsupported versions");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.NotAcceptable || ex.StatusCode == HttpStatusCode.NotFound,
                        $"Expected 400, 422, 406, or 404 for invalid bulk version, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidBulkVersionStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk add items invalid bulk version test", ex);
            }
        }

        // ==================== JOB STATUS & ASYNC OPERATION ERROR TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public async Task Test050_JobStatus_Should_Handle_Invalid_Job_ID()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusInvalidJobId");
            try
            {
                string invalidJobId = "completely_invalid_job_id_" + Guid.NewGuid();

                try
                {
                    await _stack.BulkOperation().JobStatusAsync(invalidJobId);
                    AssertLogger.Fail("Expected error for invalid job ID in async call", "JobStatusAsync_InvalidJobID_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected 404 or 400 for invalid job ID, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidJobIDAsyncStatus");
                }

                // Also test synchronous version
                try
                {
                    _stack.BulkOperation().JobStatus(invalidJobId);
                    AssertLogger.Fail("Expected error for invalid job ID in sync call", "JobStatusSync_InvalidJobID_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected 404 or 400 for invalid job ID, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "InvalidJobIDSyncStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Job status invalid job ID test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test051_JobStatus_Should_Handle_Expired_Job_ID()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusExpiredJobId");
            try
            {
                // Use a job ID format that might exist but be very old/expired
                string expiredJobId = "expired_job_from_2020_" + Guid.NewGuid();

                try
                {
                    await _stack.BulkOperation().JobStatusAsync(expiredJobId);
                    AssertLogger.Fail("Expected error for expired job ID", "JobStatus_ExpiredJobID_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.Gone || 
                        ex.StatusCode == HttpStatusCode.BadRequest,
                        $"Expected 404, 410, or 400 for expired job ID, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "ExpiredJobIDStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Job status expired job ID test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test052_JobStatus_Should_Handle_Version_Mismatch()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusVersionMismatch");
            try
            {
                string testJobId = "test_job_" + Guid.NewGuid();

                try
                {
                    // Try with mismatched bulk version
                    await _stack.BulkOperation().JobStatusAsync(testJobId, "mismatched_version_99.99");
                    AssertLogger.Fail("Expected error for version mismatch in job status", "JobStatus_VersionMismatch_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.NotFound || ex.StatusCode == HttpStatusCode.BadRequest || 
                        ex.StatusCode == HttpStatusCode.UnprocessableEntity || ex.StatusCode == HttpStatusCode.NotAcceptable,
                        $"Expected 404, 400, 422, or 406 for version mismatch, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "VersionMismatchStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Job status version mismatch test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test053_BulkOperations_Should_Handle_Job_Creation_Failures()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsJobCreationFailures");
            try
            {
                // Try to create a bulk operation that might fail to create a job
                var problematicData = new BulkAddItemsData
                {
                    Release = "non_existent_release_" + Guid.NewGuid(),
                    Action = "publish",
                    Locale = new List<string> { "invalid-locale-xyz" },
                    Reference = false,
                    Items = new List<BulkAddItem>
                    {
                        new BulkAddItem
                        {
                            Uid = "non_existent_entry_" + Guid.NewGuid(),
                            ContentType = "non_existent_content_type_" + Guid.NewGuid()
                        }
                    }
                };

                try
                {
                    var response = await _stack.BulkOperation().AddItemsAsync(problematicData);
                    if (response.IsSuccessStatusCode)
                    {
                        var responseJson = response.OpenJsonObjectResponse();
                        if (responseJson["job_id"] != null)
                        {
                            string jobId = responseJson["job_id"].ToString();
                            
                            // Wait a bit for the job to process
                            await Task.Delay(3000);
                            
                            // Check if job shows failure status
                            try
                            {
                                var jobStatusResponse = await _stack.BulkOperation().JobStatusAsync(jobId);
                                var jobJson = jobStatusResponse.OpenJsonObjectResponse();
                                
                                // Look for failure indicators in job status
                                if (jobJson["status"]?.ToString() == "failed" || 
                                    jobJson["error"] != null ||
                                    jobJson["errors"] != null)
                                {
                                    Console.WriteLine("[Test053] Job created but failed as expected");
                                }
                                else
                                {
                                    Console.WriteLine("[Test053] Job completed successfully despite problematic data");
                                }
                            }
                            catch (ContentstackErrorException ex)
                            {
                                Console.WriteLine($"[Test053] Job status check failed: {ex.StatusCode} - {ex.ErrorMessage}");
                            }
                        }
                    }
                }
                catch (ContentstackErrorException ex)
                {
                    // This is expected for problematic data
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.NotFound,
                        $"Expected 400, 422, or 404 for job creation failure, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "JobCreationFailureStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations job creation failures test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test054_BulkOperations_Should_Handle_Async_Timeout_Scenarios()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsAsyncTimeoutScenarios");
            try
            {
                // This test creates a large operation that might timeout
                var largeOperationData = new BulkAddItemsData
                {
                    Items = new List<BulkAddItem>()
                };

                // Create a large number of items to potentially cause timeout
                for (int i = 0; i < 500; i++)
                {
                    largeOperationData.Items.Add(new BulkAddItem
                    {
                        Uid = $"large_test_entry_{i}_{Guid.NewGuid()}",
                        ContentType = _contentTypeUid
                    });
                }

                try
                {
                    // Use a shorter timeout to test timeout handling
                    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
                    var task = _stack.BulkOperation().AddItemsAsync(largeOperationData);
                    
                    try
                    {
                        await task.WaitAsync(cts.Token);
                        Console.WriteLine("[Test054] Large operation completed within timeout");
                    }
                    catch (TaskCanceledException)
                    {
                        Console.WriteLine("[Test054] Task was cancelled due to timeout");
                        AssertLogger.IsTrue(true, "Task cancellation handled correctly", "TaskCancellationHandled");
                    }
                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("[Test054] Operation timed out as expected");
                        AssertLogger.IsTrue(true, "Timeout handled correctly", "TimeoutHandled");
                    }
                }
                catch (ContentstackErrorException ex)
                {
                    // Large operations might fail due to limits
                    Console.WriteLine($"[Test054] Large operation failed: {ex.StatusCode} - {ex.ErrorMessage}");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations async timeout scenarios test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test055_BulkOperations_Should_Handle_Concurrent_Job_Requests()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsConcurrentJobRequests");
            try
            {
                // This test creates multiple concurrent bulk operations to test job handling
                var tasks = new List<Task<ContentstackResponse>>();
                
                for (int i = 0; i < 3; i++)
                {
                    var concurrentData = new BulkAddItemsData
                    {
                        Items = new List<BulkAddItem>
                        {
                            new BulkAddItem
                            {
                                Uid = $"concurrent_entry_{i}_{Guid.NewGuid()}",
                                ContentType = _contentTypeUid
                            }
                        }
                    };
                    
                    tasks.Add(_stack.BulkOperation().AddItemsAsync(concurrentData));
                }

                try
                {
                    var results = await Task.WhenAll(tasks);
                    
                    // Check if all jobs were created successfully or failed appropriately
                    for (int i = 0; i < results.Length; i++)
                    {
                        var result = results[i];
                        if (result.IsSuccessStatusCode)
                        {
                            var resultJson = result.OpenJsonObjectResponse();
                            if (resultJson["job_id"] != null)
                            {
                                Console.WriteLine($"[Test055] Concurrent job {i + 1} created successfully: {resultJson["job_id"]}");
                            }
                        }
                        else
                        {
                            Console.WriteLine($"[Test055] Concurrent job {i + 1} failed: {result.StatusCode}");
                        }
                    }
                }
                catch (ContentstackErrorException ex)
                {
                    AssertLogger.IsTrue(ex.StatusCode == HttpStatusCode.TooManyRequests || ex.StatusCode == HttpStatusCode.ServiceUnavailable ||
                        ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity || 
                        ex.StatusCode == HttpStatusCode.NotFound,
                        $"Expected 429, 503, 400, 422, or 404 for concurrent requests, got {(int)ex.StatusCode} ({ex.StatusCode}). Message: {ex.ErrorMessage ?? ex.Message}",
                        "ConcurrentRequestsStatus");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations concurrent job requests test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test056_BulkOperations_Should_Handle_Job_Status_Polling_Errors()
        {
            TestOutputLogger.LogContext("TestScenario", "BulkOperationsJobStatusPollingErrors");
            try
            {
                // First create a valid bulk operation to get a job ID
                List<EntryInfo> availableEntries = await FetchExistingEntries();
                if (availableEntries.Count == 0)
                {
                    await EnsureBulkTestContentTypeAndEntriesAsync();
                    availableEntries = await FetchExistingEntries();
                }

                if (availableEntries.Count > 0)
                {
                    var workflowBody = new BulkWorkflowUpdateBody
                    {
                        Entries = new List<BulkWorkflowEntry>
                        {
                            new BulkWorkflowEntry
                            {
                                Uid = availableEntries[0].Uid,
                                ContentType = _contentTypeUid,
                                Locale = "en-us"
                            }
                        },
                        Workflow = new BulkWorkflowStage
                        {
                            Uid = !string.IsNullOrEmpty(_bulkTestWorkflowStage1Uid) ? _bulkTestWorkflowStage1Uid : "test_stage",
                            Comment = "Test job status polling",
                            Notify = false
                        }
                    };

                    try
                    {
                        var response = await _stack.BulkOperation().UpdateAsync(workflowBody);
                        if (response.IsSuccessStatusCode)
                        {
                            var responseJson = response.OpenJsonObjectResponse();
                            if (responseJson["job_id"] != null)
                            {
                                string jobId = responseJson["job_id"].ToString();
                                
                                // Test rapid polling which might cause rate limiting
                                for (int i = 0; i < 5; i++)
                                {
                                    try
                                    {
                                        await _stack.BulkOperation().JobStatusAsync(jobId);
                                        await Task.Delay(100); // Very short delay
                                    }
                                    catch (ContentstackErrorException ex) when (ex.StatusCode == HttpStatusCode.TooManyRequests)
                                    {
                                        AssertLogger.AreEqual(429, (int)ex.StatusCode, "Expected 429 for rate limiting", "RateLimitingStatus");
                                        Console.WriteLine("[Test056] Rate limiting detected during rapid polling");
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    catch (ContentstackErrorException ex)
                    {
                        Console.WriteLine($"[Test056] Bulk operation failed: {ex.StatusCode} - {ex.ErrorMessage}");
                    }
                }
                else
                {
                    Console.WriteLine("[Test056] Skipped - No entries available for testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Bulk operations job status polling errors test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test057_JobStatus_Should_Handle_Null_And_Empty_Parameters()
        {
            TestOutputLogger.LogContext("TestScenario", "JobStatusNullAndEmptyParameters");
            try
            {
                // Test null job ID (already covered in Test015, but good to have here for completeness)
                var nullEx = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().JobStatus(null), "JobStatus_NullJobId");

                // Test empty job ID
                var emptyEx = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().JobStatus(""), "JobStatus_EmptyJobId");

                // Test whitespace job ID
                var whitespaceEx = AssertLogger.ThrowsException<ArgumentNullException>(() =>
                    _stack.BulkOperation().JobStatus("   "), "JobStatus_WhitespaceJobId");

                AssertLogger.IsNotNull(nullEx, "NullJobIdException");
                AssertLogger.IsNotNull(emptyEx, "EmptyJobIdException");
                AssertLogger.IsNotNull(whitespaceEx, "WhitespaceJobIdException");
            }
            catch (Exception ex)
            {
                FailWithError("Job status null and empty parameters test", ex);
            }
        }

        // ==================== ERROR RESPONSE VALIDATION TESTS ====================

        [TestMethod]
        [DoNotParallelize]
        public void Test058_Error_Responses_Should_Include_Proper_Error_Codes()
        {
            TestOutputLogger.LogContext("TestScenario", "ErrorResponsesProperErrorCodes");
            try
            {
                var invalidDetails = CreateInvalidBulkPublishDetails();

                try
                {
                    _stack.BulkOperation().Publish(invalidDetails);
                    AssertLogger.Fail("Expected error for invalid details", "ErrorResponse_InvalidDetails_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    // Validate that the error response has proper structure
                    AssertLogger.IsNotNull(ex.StatusCode, "Error response should include HTTP status code", "HttpStatusCode");
                    AssertLogger.IsTrue((int)ex.StatusCode >= 400, "HTTP status code should be 400 or higher for errors", "ErrorStatusCode");

                    // Validate ErrorCode property
                    AssertLogger.IsTrue(ex.ErrorCode >= 0, 
                        "ErrorCode should be non-negative (0 is acceptable for some errors)", "ErrorCodeValue");

                    // Log the error details for verification
                    TestOutputLogger.LogContext("HttpStatusCode", ((int)ex.StatusCode).ToString());
                    TestOutputLogger.LogContext("ErrorCode", ex.ErrorCode.ToString());
                    TestOutputLogger.LogContext("ErrorMessage", ex.ErrorMessage ?? "null");
                    TestOutputLogger.LogContext("Message", ex.Message ?? "null");

                    Console.WriteLine($"[Test058] Error response structure validated - Status: {ex.StatusCode}, ErrorCode: {ex.ErrorCode}");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Error responses proper error codes test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test059_Error_Responses_Should_Include_Descriptive_Messages()
        {
            TestOutputLogger.LogContext("TestScenario", "ErrorResponsesDescriptiveMessages");
            try
            {
                var emptyDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>(),
                    Locales = new List<string>(),
                    Environments = new List<string>()
                };

                try
                {
                    _stack.BulkOperation().Publish(emptyDetails);
                    AssertLogger.Fail("Expected error for empty details", "ErrorResponse_EmptyDetails_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    // Validate that error messages are descriptive and not empty
                    AssertLogger.IsTrue(!string.IsNullOrWhiteSpace(ex.Message), 
                        "Error message should not be null or empty", "ErrorMessageNotEmpty");

                    // Check if ErrorMessage property is also populated (API-specific message)
                    if (!string.IsNullOrWhiteSpace(ex.ErrorMessage))
                    {
                        AssertLogger.IsTrue(ex.ErrorMessage.Length > 5, 
                            "ErrorMessage should be descriptive (more than 5 characters)", "ErrorMessageDescriptive");
                    }

                    // Check that the message contains relevant keywords for bulk operations
                    string combinedMessage = (ex.ErrorMessage ?? "") + " " + (ex.Message ?? "");
                    bool hasRelevantKeywords = combinedMessage.Contains("bulk", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("publish", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("entries", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("invalid", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("required", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("empty", StringComparison.OrdinalIgnoreCase) ||
                                             combinedMessage.Contains("missing", StringComparison.OrdinalIgnoreCase);

                    if (hasRelevantKeywords)
                    {
                        Console.WriteLine($"[Test059] Error message contains relevant keywords: '{combinedMessage}'");
                    }

                    TestOutputLogger.LogContext("ErrorMessage", ex.ErrorMessage ?? "null");
                    TestOutputLogger.LogContext("Message", ex.Message ?? "null");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Error responses descriptive messages test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test060_Error_Responses_Should_Include_Field_Level_Validation_Details()
        {
            TestOutputLogger.LogContext("TestScenario", "ErrorResponsesFieldLevelValidationDetails");
            try
            {
                // Create details with multiple types of validation errors
                var multiErrorDetails = new BulkPublishDetails
                {
                    Entries = new List<BulkPublishEntry>
                    {
                        new BulkPublishEntry
                        {
                            Uid = "", // Empty UID
                            ContentType = "", // Empty content type
                            Version = -1, // Invalid version
                            Locale = "" // Empty locale
                        },
                        new BulkPublishEntry
                        {
                            Uid = "invalid@#$%entry", // Invalid characters
                            ContentType = "invalid content type with spaces",
                            Version = 0, // Zero version
                            Locale = "invalid-locale-format-xyz"
                        }
                    },
                    Locales = new List<string> { "", "invalid-locale" }, // Mix of empty and invalid
                    Environments = new List<string> { "", "invalid@env" } // Mix of empty and invalid
                };

                try
                {
                    _stack.BulkOperation().Publish(multiErrorDetails);
                    AssertLogger.Fail("Expected validation errors for multiple field issues", "FieldValidation_MultipleErrors_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    // API prioritizes environment validation over field validation, so 401 is acceptable
                    if (ex.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        AssertLogger.IsTrue(true, "API returned 401 (environment validation priority) instead of field validation details", "EnvironmentValidationPriority");
                        return;
                    }
                    
                    // For other status codes, check if the error response includes field-level details
                    AssertLogger.IsNotNull(ex.Errors, "Error response should include Errors collection for field validation", "ErrorsCollection");

                    if (ex.Errors != null && ex.Errors.Count > 0)
                    {
                        Console.WriteLine($"[Test060] Field-level validation errors found: {ex.Errors.Count} errors");
                        
                        foreach (var error in ex.Errors)
                        {
                            TestOutputLogger.LogContext("FieldError", error.ToString());
                            
                            // Validate that field errors contain useful information
                            if (!error.Equals(default(KeyValuePair<string, object>)))
                            {
                                string errorStr = error.ToString();
                                AssertLogger.IsTrue(!string.IsNullOrWhiteSpace(errorStr),
                                    "Individual field error should not be empty", "FieldErrorNotEmpty");
                            }
                        }
                    }
                    else
                    {
                        // Even without Errors collection, the main message should be descriptive
                        Console.WriteLine($"[Test060] No field-level errors collection, but main error message: '{ex.ErrorMessage ?? ex.Message}'");
                    }

                    // Log all available error information
                    TestOutputLogger.LogContext("StatusCode", ((int)ex.StatusCode).ToString());
                    TestOutputLogger.LogContext("ErrorCode", ex.ErrorCode.ToString());
                    TestOutputLogger.LogContext("ErrorMessage", ex.ErrorMessage ?? "null");
                    TestOutputLogger.LogContext("ErrorsCount", ex.Errors?.Count.ToString() ?? "0");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Error responses field level validation details test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public void Test061_ContentstackErrorException_Should_Have_Complete_Error_Information()
        {
            TestOutputLogger.LogContext("TestScenario", "ContentstackErrorExceptionCompleteInfo");
            try
            {
                var invalidWorkflowBody = CreateInvalidWorkflowUpdateBody();

                try
                {
                    _stack.BulkOperation().Update(invalidWorkflowBody);
                    AssertLogger.Fail("Expected error for invalid workflow body", "ErrorInfo_InvalidWorkflow_NoException");
                }
                catch (ContentstackErrorException ex)
                {
                    // Validate all properties of ContentstackErrorException are properly set
                    AssertLogger.IsNotNull(ex.StatusCode, "StatusCode should be set", "StatusCodeSet");
                    AssertLogger.IsTrue(ex.ErrorCode >= 0, "ErrorCode should be non-negative", "ErrorCodeNonNegative");
                    
                    // Message should always be set (either ErrorMessage or base Exception.Message)
                    AssertLogger.IsTrue(!string.IsNullOrWhiteSpace(ex.Message), 
                        "Exception Message should not be null or empty", "ExceptionMessageSet");

                    // Check if IsNetworkError is properly set (should be false for validation errors)
                    if (ex.StatusCode == HttpStatusCode.BadRequest || ex.StatusCode == HttpStatusCode.UnprocessableEntity)
                    {
                        AssertLogger.IsFalse(ex.IsNetworkError, 
                            "IsNetworkError should be false for validation errors", "IsNetworkErrorFalse");
                    }

                    // Validate exception type hierarchy
                    AssertLogger.IsTrue(ex is Exception, "ContentstackErrorException should inherit from Exception", "ExceptionInheritance");

                    // Log comprehensive error information
                    TestOutputLogger.LogContext("ExceptionType", ex.GetType().Name);
                    TestOutputLogger.LogContext("StatusCode", ex.StatusCode.ToString());
                    TestOutputLogger.LogContext("ErrorCode", ex.ErrorCode.ToString());
                    TestOutputLogger.LogContext("ErrorMessage", ex.ErrorMessage ?? "null");
                    TestOutputLogger.LogContext("Message", ex.Message ?? "null");
                    TestOutputLogger.LogContext("IsNetworkError", ex.IsNetworkError.ToString());
                    TestOutputLogger.LogContext("ErrorsCount", ex.Errors?.Count.ToString() ?? "null");

                    Console.WriteLine($"[Test061] ContentstackErrorException validation complete - Type: {ex.GetType().Name}");
                }
            }
            catch (Exception ex)
            {
                FailWithError("ContentstackErrorException complete error information test", ex);
            }
        }

        [TestMethod]
        [DoNotParallelize]
        public async Task Test062_Error_Responses_Should_Be_Consistent_Across_Operations()
        {
            TestOutputLogger.LogContext("TestScenario", "ErrorResponsesConsistentAcrossOperations");
            try
            {
                var testErrors = new List<(string Operation, ContentstackErrorException Exception)>();

                // Test consistent error structure across different bulk operations

                // 1. Test Bulk Publish
                try
                {
                    _stack.BulkOperation().Publish(CreateInvalidBulkPublishDetails());
                }
                catch (ContentstackErrorException ex)
                {
                    testErrors.Add(("BulkPublish", ex));
                }

                // 2. Test Bulk Delete
                try
                {
                    _stack.BulkOperation().Delete(new BulkDeleteDetails
                    {
                        Entries = new List<BulkDeleteEntry>
                        {
                            new BulkDeleteEntry { Uid = "", ContentType = "", Locale = "" }
                        }
                    });
                }
                catch (ContentstackErrorException ex)
                {
                    testErrors.Add(("BulkDelete", ex));
                }

                // 3. Test Bulk Workflow Update
                try
                {
                    _stack.BulkOperation().Update(CreateInvalidWorkflowUpdateBody());
                }
                catch (ContentstackErrorException ex)
                {
                    testErrors.Add(("BulkWorkflowUpdate", ex));
                }

                // 4. Test Bulk Add Items
                try
                {
                    _stack.BulkOperation().AddItems(new BulkAddItemsData
                    {
                        Items = new List<BulkAddItem>
                        {
                            new BulkAddItem { Uid = "", ContentType = "" }
                        }
                    });
                }
                catch (ContentstackErrorException ex)
                {
                    testErrors.Add(("BulkAddItems", ex));
                }

                // 5. Test Job Status
                try
                {
                    await _stack.BulkOperation().JobStatusAsync("");
                }
                catch (ArgumentNullException)
                {
                    // Expected for empty job ID
                }
                catch (ContentstackErrorException ex)
                {
                    testErrors.Add(("JobStatus", ex));
                }

                // Analyze consistency across error responses
                if (testErrors.Count >= 2)
                {
                    var firstError = testErrors[0].Exception;
                    
                    foreach (var (operation, exception) in testErrors.Skip(1))
                    {
                        // All errors should have consistent structure
                        AssertLogger.IsNotNull(exception.StatusCode, 
                            $"{operation} should have StatusCode like {testErrors[0].Operation}", "ConsistentStatusCode");
                        AssertLogger.IsTrue(exception.ErrorCode >= 0, 
                            $"{operation} should have non-negative ErrorCode like {testErrors[0].Operation}", "ConsistentErrorCode");
                        AssertLogger.IsTrue(!string.IsNullOrWhiteSpace(exception.Message), 
                            $"{operation} should have Message like {testErrors[0].Operation}", "ConsistentMessage");
                    }

                    Console.WriteLine($"[Test062] Validated error consistency across {testErrors.Count} operations");
                    
                    // Log all error information for comparison
                    foreach (var (operation, exception) in testErrors)
                    {
                        TestOutputLogger.LogContext($"{operation}_StatusCode", exception.StatusCode.ToString());
                        TestOutputLogger.LogContext($"{operation}_ErrorCode", exception.ErrorCode.ToString());
                        TestOutputLogger.LogContext($"{operation}_HasErrorMessage", (!string.IsNullOrWhiteSpace(exception.ErrorMessage)).ToString());
                        TestOutputLogger.LogContext($"{operation}_HasErrors", (exception.Errors?.Count > 0).ToString());
                    }
                }
                else
                {
                    Console.WriteLine($"[Test062] Only {testErrors.Count} errors captured for consistency testing");
                }
            }
            catch (Exception ex)
            {
                FailWithError("Error responses consistent across operations test", ex);
            }
        }

        private async Task CheckBulkJobStatus(string jobId, string bulkVersion = null)
        {
            try
            {
                ContentstackResponse statusResponse = await _stack.BulkOperation().JobStatusAsync(jobId, bulkVersion);
                var statusJson = statusResponse.OpenJsonObjectResponse();

                AssertLogger.IsNotNull(statusResponse, "jobStatusResponse");
                AssertLogger.IsTrue(statusResponse.IsSuccessStatusCode, "jobStatusSuccess");
            }
            catch (Exception)
            {
                // Failed to check job status
            }
        }

        private async Task CreateTestEnvironment()
        {
            try
            {
                // Create test environment
                var environmentModel = new EnvironmentModel
                {
                    Name = "bulk_test_env",
                    Urls = new List<LocalesUrl>
                    {
                        new LocalesUrl
                        {
                            Url = "https://bulk-test-environment.example.com",
                            Locale = "en-us"
                        }
                    }
                };

                ContentstackResponse response = _stack.Environment().Create(environmentModel);
                var responseJson = response.OpenJsonObjectResponse();

                if (response.IsSuccessStatusCode && responseJson["environment"] != null)
                {
                    _testEnvironmentUid = responseJson["environment"]["uid"].ToString();
                }
            }
            catch (Exception)
            {
                // Don't fail the test if environment creation fails
            }
        }

        private async Task CreateTestRelease()
        {
            try
            {
                var releaseModel = new ReleaseModel
                {
                    Name = "bulk_test_release",
                    Description = "Release for testing bulk operations",
                    Locked = false,
                    Archived = false
                };
                ContentstackResponse response = _stack.Release().Create(releaseModel);
                var responseJson = response.OpenJsonObjectResponse();
                if (response.IsSuccessStatusCode && responseJson["release"] != null)
                    _testReleaseUid = responseJson["release"]["uid"].ToString();
            }
            catch (Exception) { }
            await Task.CompletedTask;
        }

        private async Task<List<string>> GetAvailableEnvironments()
        {
            try
            {
                // First try to use our test environment
                if (!string.IsNullOrEmpty(_testEnvironmentUid))
                {
                    try
                    {
                        ContentstackResponse fetchResponse = _stack.Environment(_testEnvironmentUid).Fetch();
                        if (fetchResponse.IsSuccessStatusCode)
                        {
                            return new List<string> { _testEnvironmentUid };
                        }
                    }
                    catch
                    {
                        // Test environment doesn't exist, fall back to available environments
                    }
                }

                // Try to get available environments
                try
                {
                    ContentstackResponse response = _stack.Environment().Query().Find();
                    var responseJson = response.OpenJsonObjectResponse();

                    if (response.IsSuccessStatusCode && responseJson["environments"] != null)
                    {
                        var environments = responseJson["environments"]?.AsArray();
                        if (environments != null && environments.Count > 0)
                        {
                            var environmentUids = new List<string>();
                            foreach (var env in environments)
                            {
                                if (env["uid"] != null)
                                {
                                    environmentUids.Add(env["uid"].ToString());
                                }
                            }
                            return environmentUids;
                        }
                    }
                }
                catch (Exception)
                {
                    // Failed to get environments
                }

                // Fallback to empty list if no environments found
                return new List<string>();
            }
            catch (Exception)
            {
                return new List<string>();
            }
        }

        /// <summary>
        /// Ensures bulk_test_content_type exists and has at least one entry so bulk tests can run in any order.
        /// </summary>
        private async Task EnsureBulkTestContentTypeAndEntriesAsync()
        {
            try
            {
                bool contentTypeExists = false;
                try
                {
                    ContentstackResponse ctResponse = _stack.ContentType(_contentTypeUid).Fetch();
                    contentTypeExists = ctResponse.IsSuccessStatusCode;
                }
                catch
                {
                    // Content type not found
                }

                if (!contentTypeExists)
                {
                    await CreateTestEnvironment();
                    await CreateTestRelease();
                    var contentModelling = new ContentModelling
                    {
                        Title = "bulk_test_content_type",
                        Uid = _contentTypeUid,
                        Schema = new List<Field>
                        {
                            new TextboxField
                            {
                                DisplayName = "Title",
                                Uid = "title",
                                DataType = "text",
                                Mandatory = true,
                                Unique = false,
                                Multiple = false
                            }
                        }
                    };
                    _stack.ContentType().Create(contentModelling);
                }

                // Ensure at least one entry exists
                List<EntryInfo> existing = await FetchExistingEntries();
                if (existing == null || existing.Count == 0)
                {
                    var entry = new SimpleEntry { Title = "Bulk test entry" };
                    ContentstackResponse createResponse = _stack.ContentType(_contentTypeUid).Entry().Create(entry);
                    var responseJson = createResponse.OpenJsonObjectResponse();
                    if (createResponse.IsSuccessStatusCode && responseJson["entry"] != null && responseJson["entry"]["uid"] != null)
                    {
                        _createdEntries.Add(new EntryInfo
                        {
                            Uid = responseJson["entry"]["uid"].ToString(),
                            Title = responseJson["entry"]["title"]?.ToString() ?? "Bulk test entry",
                            Version = responseJson["entry"]["_version"] != null ? (int)responseJson["entry"]["_version"] : 1
                        });
                    }
                }
            }
            catch (Exception)
            {
                // Caller will handle if entries are still missing
            }
        }

        /// <summary>
        /// Returns available environment UIDs for the given stack (synchronous).
        /// </summary>
        private static List<string> GetAvailableEnvironments(Stack stack)
        {
            try
            {
                ContentstackResponse response = stack.Environment().Query().Find();
                var responseJson = response.OpenJsonObjectResponse();
                if (response.IsSuccessStatusCode && responseJson["environments"] != null)
                {
                    var environments = responseJson["environments"]?.AsArray();
                    if (environments != null && environments.Count > 0)
                    {
                        var uids = new List<string>();
                        foreach (var env in environments)
                        {
                            if (env["uid"] != null)
                                uids.Add(env["uid"].ToString());
                        }
                        return uids;
                    }
                }
            }
            catch { }
            return new List<string>();
        }

        /// <summary>
        /// Returns available environment UIDs for the given stack (used by workflow setup).
        /// </summary>
        private static async Task<List<string>> GetAvailableEnvironmentsAsync(Stack stack)
        {
            try
            {
                ContentstackResponse response = stack.Environment().Query().Find();
                var responseJson = response.OpenJsonObjectResponse();
                if (response.IsSuccessStatusCode && responseJson["environments"] != null)
                {
                    var environments = responseJson["environments"]?.AsArray();
                    if (environments != null && environments.Count > 0)
                    {
                        var uids = new List<string>();
                        foreach (var env in environments)
                        {
                            if (env["uid"] != null)
                                uids.Add(env["uid"].ToString());
                        }
                        return uids;
                    }
                }
            }
            catch { }
            return new List<string>();
        }

        /// <summary>
        /// Ensures an environment exists for workflow/publish rule tests: lists existing envs and uses the first, or creates "bulk_test_env" if none exist. Sets _bulkTestEnvironmentUid. Synchronous.
        /// </summary>
        private static void EnsureBulkTestEnvironment(Stack stack)
        {
            try
            {
                List<string> envs = GetAvailableEnvironments(stack);
                if (envs != null && envs.Count > 0)
                {
                    _bulkTestEnvironmentUid = envs[0];
                    return;
                }

                var environmentModel = new EnvironmentModel
                {
                    Name = "bulk_test_env",
                    Urls = new List<LocalesUrl>
                    {
                        new LocalesUrl
                        {
                            Url = "https://bulk-test-environment.example.com",
                            Locale = "en-us"
                        }
                    }
                };

                ContentstackResponse response = stack.Environment().Create(environmentModel);
                var responseJson = response.OpenJsonObjectResponse();
                if (response.IsSuccessStatusCode && responseJson["environment"]?["uid"] != null)
                    _bulkTestEnvironmentUid = responseJson["environment"]["uid"].ToString();
            }
            catch { /* Leave _bulkTestEnvironmentUid null */ }
        }

        /// <summary>
        /// Ensures an environment exists for workflow/publish rule tests: lists existing envs and uses the first, or creates "bulk_test_env" if none exist. Sets _bulkTestEnvironmentUid.
        /// </summary>
        private static async Task EnsureBulkTestEnvironmentAsync(Stack stack)
        {
            try
            {
                List<string> envs = await GetAvailableEnvironmentsAsync(stack);
                if (envs != null && envs.Count > 0)
                {
                    _bulkTestEnvironmentUid = envs[0];
                    return;
                }

                var environmentModel = new EnvironmentModel
                {
                    Name = "bulk_test_env",
                    Urls = new List<LocalesUrl>
                    {
                        new LocalesUrl
                        {
                            Url = "https://bulk-test-environment.example.com",
                            Locale = "en-us"
                        }
                    }
                };

                ContentstackResponse response = stack.Environment().Create(environmentModel);
                var responseJson = response.OpenJsonObjectResponse();
                if (response.IsSuccessStatusCode && responseJson["environment"]?["uid"] != null)
                    _bulkTestEnvironmentUid = responseJson["environment"]["uid"].ToString();
            }
            catch { /* Leave _bulkTestEnvironmentUid null */ }
        }

        /// <summary>
        /// Finds or creates a workflow named "workflow_test" with 2 stages (New stage 1, New stage 2) and a publishing rule.
        /// Uses same payload as Test000a / final curl. Called once from ClassInitialize.
        /// </summary>
        private static async Task EnsureBulkTestWorkflowAndPublishingRuleAsync(Stack stack)
        {
            if (string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                await EnsureBulkTestEnvironmentAsync(stack);

            const string workflowName = "workflow_test";

            // Try to find an existing workflow with the same name
            try
            {
                ContentstackResponse listResponse = stack.Workflow().FindAll();
                if (listResponse.IsSuccessStatusCode)
                {
                    var listJson = listResponse.OpenJsonObjectResponse();
                    var existing = listJson["workflows"]?.AsArray() ?? listJson["workflow"]?.AsArray();
                    if (existing != null)
                    {
                        foreach (var wf in existing)
                        {
                            if (wf["name"]?.ToString() == workflowName && wf["uid"] != null)
                            {
                                _bulkTestWorkflowUid = wf["uid"].ToString();
                                var existingStages = wf["workflow_stages"]?.AsArray();
                                if (existingStages != null && existingStages.Count >= 2)
                                {
                                    _bulkTestWorkflowStage1Uid = existingStages[0]["uid"]?.ToString();
                                    _bulkTestWorkflowStage2Uid = existingStages[1]["uid"]?.ToString();
                                    _bulkTestWorkflowStageUid = _bulkTestWorkflowStage2Uid;
                                }
                                break;
                            }
                        }
                    }
                }
            }
            catch { /* If listing fails, proceed to create */ }

            if (string.IsNullOrEmpty(_bulkTestWorkflowUid))
            {
                var sysAcl = new Dictionary<string, object>
                {
                    ["roles"] = new Dictionary<string, object> { ["uids"] = new List<string>() },
                    ["users"] = new Dictionary<string, object> { ["uids"] = new List<string> { "$all" } },
                    ["others"] = new Dictionary<string, object>()
                };

                var workflowModel = new WorkflowModel
                {
                    Name = workflowName,
                    Enabled = true,
                    Branches = new List<string> { "main" },
                    ContentTypes = new List<string> { "$all" },
                    AdminUsers = new Dictionary<string, object> { ["users"] = new List<object>() },
                    WorkflowStages = new List<WorkflowStage>
                    {
                        new WorkflowStage
                        {
                            Name = "New stage 1",
                            Color = "#fe5cfb",
                            SystemACL = sysAcl,
                            NextAvailableStages = new List<string> { "$all" },
                            AllStages = true,
                            AllUsers = true,
                            SpecificStages = false,
                            SpecificUsers = false,
                            EntryLock = "$none"
                        },
                        new WorkflowStage
                        {
                            Name = "New stage 2",
                            Color = "#3688bf",
                            SystemACL = new Dictionary<string, object>
                            {
                                ["roles"] = new Dictionary<string, object> { ["uids"] = new List<string>() },
                                ["users"] = new Dictionary<string, object> { ["uids"] = new List<string> { "$all" } },
                                ["others"] = new Dictionary<string, object>()
                            },
                            NextAvailableStages = new List<string> { "$all" },
                            AllStages = true,
                            AllUsers = true,
                            SpecificStages = false,
                            SpecificUsers = false,
                            EntryLock = "$none"
                        }
                    }
                };

                ContentstackResponse response = stack.Workflow().Create(workflowModel);
                if (response.IsSuccessStatusCode)
                {
                    var responseJson = response.OpenJsonObjectResponse();
                    var workflowObj = responseJson["workflow"];
                    if (workflowObj?["uid"] != null)
                    {
                        _bulkTestWorkflowUid = workflowObj["uid"].ToString();
                        var stages = workflowObj["workflow_stages"]?.AsArray();
                        if (stages != null && stages.Count >= 2)
                        {
                            _bulkTestWorkflowStage1Uid = stages[0]["uid"]?.ToString();
                            _bulkTestWorkflowStage2Uid = stages[1]["uid"]?.ToString();
                            _bulkTestWorkflowStageUid = _bulkTestWorkflowStage2Uid;
                        }
                    }
                }
            }

            if (string.IsNullOrEmpty(_bulkTestWorkflowUid) || string.IsNullOrEmpty(_bulkTestEnvironmentUid))
                return;

            // Try to find an existing matching publish rule
            try
            {
                ContentstackResponse listResponse = stack.Workflow().PublishRule().FindAll();
                if (listResponse.IsSuccessStatusCode)
                {
                    var listJson = listResponse.OpenJsonObjectResponse();
                    var rules = listJson["publishing_rules"]?.AsArray() ?? listJson["publishing_rule"]?.AsArray();
                    if (rules != null)
                    {
                        foreach (var rule in rules)
                        {
                            if (rule["workflow"]?.ToString() == _bulkTestWorkflowUid
                                && rule["workflow_stage"]?.ToString() == _bulkTestWorkflowStage2Uid
                                && rule["environment"]?.ToString() == _bulkTestEnvironmentUid
                                && rule["uid"] != null)
                            {
                                _bulkTestPublishRuleUid = rule["uid"].ToString();
                                return;
                            }
                        }
                    }
                }
            }
            catch { /* If listing fails, proceed to create */ }

            if (!string.IsNullOrEmpty(_bulkTestWorkflowStage2Uid))
            {
                var publishRuleModel = new PublishRuleModel
                {
                    WorkflowUid = _bulkTestWorkflowUid,
                    WorkflowStageUid = _bulkTestWorkflowStage2Uid,
                    Environment = _bulkTestEnvironmentUid,
                    Branches = new List<string> { "main" },
                    ContentTypes = new List<string> { "$all" },
                    Locales = new List<string> { "en-us" },
                    Actions = new List<string>(),
                    Approvers = new Approvals { Users = new List<string>(), Roles = new List<string>() },
                    DisableApproval = false
                };

                ContentstackResponse response = stack.Workflow().PublishRule().Create(publishRuleModel);
                if (response.IsSuccessStatusCode)
                {
                    var responseJson = response.OpenJsonObjectResponse();
                    var ruleObj = responseJson["publishing_rule"];
                    if (ruleObj?["uid"] != null)
                        _bulkTestPublishRuleUid = ruleObj["uid"].ToString();
                }
            }
        }

        /// <summary>
        /// Deletes the publishing rule and workflow created for bulk tests. Called once from ClassCleanup.
        /// </summary>
        private static void CleanupBulkTestWorkflowAndPublishingRule(Stack stack)
        {
            if (!string.IsNullOrEmpty(_bulkTestPublishRuleUid))
            {
                try { stack.Workflow().PublishRule(_bulkTestPublishRuleUid).Delete(); } catch { }
                _bulkTestPublishRuleUid = null;
            }
            if (!string.IsNullOrEmpty(_bulkTestWorkflowUid))
            {
                try { stack.Workflow(_bulkTestWorkflowUid).Delete(); } catch { }
                _bulkTestWorkflowUid = null;
            }
            _bulkTestWorkflowStageUid = null;
            _bulkTestWorkflowStage1Uid = null;
            _bulkTestWorkflowStage2Uid = null;
        }

        /// <summary>
        /// Assigns entries to workflow stages: first half to Stage 1, second half to Stage 2, so you can verify allotment in the UI.
        /// </summary>
        private async Task AssignEntriesToWorkflowStagesAsync(List<EntryInfo> entries)
        {
            if (entries == null || entries.Count == 0 || string.IsNullOrEmpty(_bulkTestWorkflowStage1Uid) || string.IsNullOrEmpty(_bulkTestWorkflowStage2Uid))
                return;
            int mid = (entries.Count + 1) / 2;
            var stage1Entries = entries.Take(mid).ToList();
            var stage2Entries = entries.Skip(mid).ToList();

            foreach (var stageUid in new[] { _bulkTestWorkflowStage1Uid, _bulkTestWorkflowStage2Uid })
            {
                var list = stageUid == _bulkTestWorkflowStage1Uid ? stage1Entries : stage2Entries;
                if (list.Count == 0) continue;
                try
                {
                    var body = new BulkWorkflowUpdateBody
                    {
                        Entries = list.Select(e => new BulkWorkflowEntry { Uid = e.Uid, ContentType = _contentTypeUid, Locale = "en-us" }).ToList(),
                        Workflow = new BulkWorkflowStage { Comment = "Stage allotment for bulk tests", Notify = false, Uid = stageUid }
                    };
                    ContentstackResponse r = _stack.BulkOperation().Update(body);
                    if (r.IsSuccessStatusCode)
                    {
                        var j = r.OpenJsonObjectResponse();
                        if (j?["job_id"] != null) { await Task.Delay(2000); await CheckBulkJobStatus(j["job_id"].ToString()); }
                    }
                }
                catch (ContentstackErrorException ex) when (ex.StatusCode == (HttpStatusCode)412 && ex.ErrorCode == 366) { /* stage update not allowed */ }
            }
        }

        private async Task<List<EntryInfo>> FetchExistingEntries()
        {
            try
            {
                // Query entries from the content type
                ContentstackResponse response = _stack.ContentType(_contentTypeUid).Entry().Query().Find();
                var responseJson = response.OpenJsonObjectResponse();

                if (response.IsSuccessStatusCode && responseJson["entries"] != null)
                {
                    var entries = responseJson["entries"]?.AsArray();
                    if (entries != null && entries.Count > 0)
                    {
                        var entryList = new List<EntryInfo>();
                        foreach (var entry in entries)
                        {
                            if (entry["uid"] != null && entry["title"] != null)
                            {
                                entryList.Add(new EntryInfo
                                {
                                    Uid = entry["uid"].ToString(),
                                    Title = entry["title"].ToString(),
                                    Version = entry["_version"] != null ? (int)entry["_version"] : 1
                                });
                            }
                        }
                        return entryList;
                    }
                }

                return new List<EntryInfo>();
            }
            catch (Exception)
            {
                return new List<EntryInfo>();
            }
        }

        private async Task<List<string>> GetAvailableReleases()
        {
            // Stack.Release() not yet migrated — commented out
            //try
            //{
            //    if (!string.IsNullOrEmpty(_testReleaseUid))
            //    {
            //        try
            //        {
            //            ContentstackResponse fetchResponse = _stack.Release(_testReleaseUid).Fetch();
            //            if (fetchResponse.IsSuccessStatusCode)
            //                return new List<string> { _testReleaseUid };
            //        }
            //        catch { }
            //    }
            //    ContentstackResponse response = _stack.Release().Query().Find();
            //    var responseJson = response.OpenJsonObjectResponse();
            //    if (response.IsSuccessStatusCode && responseJson["releases"] != null)
            //    {
            //        var releases = responseJson["releases"]?.AsArray();
            //        if (releases != null && releases.Count > 0)
            //        {
            //            var releaseUids = new List<string>();
            //            foreach (var release in releases)
            //                if (release["uid"] != null)
            //                    releaseUids.Add(release["uid"].ToString());
            //            return releaseUids;
            //        }
            //    }
            //}
            //catch (Exception e) { }
            return new List<string>();
        }

        private async Task<string> FetchAvailableRelease()
        {
            // Stack.Release() not yet migrated — commented out
            //try
            //{
            //    if (!string.IsNullOrEmpty(_testReleaseUid))
            //    {
            //        try
            //        {
            //            ContentstackResponse fetchResponse = _stack.Release(_testReleaseUid).Fetch();
            //            if (fetchResponse.IsSuccessStatusCode)
            //                return _testReleaseUid;
            //        }
            //        catch { }
            //    }
            //    ContentstackResponse response = _stack.Release().Query().Find();
            //    var responseJson = response.OpenJsonObjectResponse();
            //    if (response.IsSuccessStatusCode && responseJson["releases"] != null)
            //    {
            //        var releases = responseJson["releases"]?.AsArray();
            //        if (releases != null && releases.Count > 0 && releases[0]["uid"] != null)
            //            return releases[0]["uid"].ToString();
            //    }
            //}
            //catch (Exception e) { }
            return null;
        }

        public class SimpleEntry : IEntry
        {
            [JsonPropertyName("title")]
            public string Title { get; set; }

            [JsonPropertyName("_variant")]
            public object Variant { get; set; }
        }

        public class EntryInfo
        {
            public string Uid { get; set; }
            public string Title { get; set; }
            public int Version { get; set; }
        }
    }
}