Untitled

using Allure.Commons;
using System;
using TechTalk.SpecFlow;
using SAPAutomation.utils;

namespace SAPAutomation.steps
{
    [Binding]
    public class Hooks
    {
        private readonly ScenarioContext _scenarioContext;
        private readonly FeatureContext _featureContext;
        private readonly SapHelper _sapHelper = new SapHelper();

        private const string TestUuidKey = "AllureTestUuid";
        private const string FeatureContainerKey = "AllureFeatureContainer";

        public Hooks(ScenarioContext scenarioContext, FeatureContext featureContext)
        {
            _scenarioContext = scenarioContext;
            _featureContext = featureContext;
        }

        [BeforeTestRun]
        public static void BeforeTestRun()
        {
            Console.WriteLine("[DEBUG] Running BeforeTestRun Hook.");
            AllureLifecycle.Instance.CleanupResultDirectory(); // Clean previous Allure results
        }

        [BeforeFeature]
        public static void BeforeFeature(FeatureContext featureContext)
        {
            Console.WriteLine($"[DEBUG] Running BeforeFeature Hook: {featureContext.FeatureInfo.Title}");

            if (!featureContext.ContainsKey("Allure.Net.Commons.AllureContext"))
            {
                string containerId = Guid.NewGuid().ToString();
                featureContext["Allure.Net.Commons.AllureContext"] = containerId;

                var container = new TestResultContainer
                {
                    uuid = containerId,
                    name = featureContext.FeatureInfo.Title
                };

                AllureLifecycle.Instance.StartTestContainer(container);
                Console.WriteLine($"[DEBUG] Created Allure Test Container: {containerId}");
            }
        }

        [BeforeScenario]
        public void BeforeScenario()
        {
            Console.WriteLine($"[DEBUG] Running BeforeScenario Hook: {_scenarioContext.ScenarioInfo.Title}");

            if (!_featureContext.TryGetValue("Allure.Net.Commons.AllureContext", out string featureContainerId))
            {
                Console.WriteLine("[WARNING] AllureContext missing! Initializing...");
                featureContainerId = Guid.NewGuid().ToString();
                _featureContext["Allure.Net.Commons.AllureContext"] = featureContainerId;
            }

            string testUuid = Guid.NewGuid().ToString();
            _scenarioContext[TestUuidKey] = testUuid;

            var testResult = new TestResult
            {
                uuid = testUuid,
                name = _scenarioContext.ScenarioInfo.Title,
                start = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
            };

            AllureLifecycle.Instance.StartTestCase(testResult);
            AllureLifecycle.Instance.UpdateTestContainer(featureContainerId, container =>
            {
                container.children.Add(testUuid);
            });
        }

        [AfterScenario]
        public void AfterScenario()
        {
            Console.WriteLine($"[DEBUG] Finishing Test: {_scenarioContext.ScenarioInfo.Title}");

            if (_scenarioContext.TryGetValue(TestUuidKey, out string testUuid))
            {
                if (_scenarioContext.TestError != null)
                {
                    AllureLifecycle.Instance.UpdateTestCase(testUuid, tc =>
                    {
                        tc.status = Status.failed;
                        tc.statusDetails = new StatusDetails { message = _scenarioContext.TestError.Message };
                    });
                }
                else
                {
                    AllureLifecycle.Instance.UpdateTestCase(testUuid, tc =>
                    {
                        tc.status = Status.passed;
                    });
                }

                AllureLifecycle.Instance.StopTestCase(testUuid);
                AllureLifecycle.Instance.WriteTestCase(testUuid);
            }
            else
            {
                Console.WriteLine("[Allure] ERROR: No Test UUID found in ScenarioContext.");
            }

            _sapHelper.CloseSAP();
        }

        [AfterFeature]
        public static void AfterFeature(FeatureContext featureContext)
        {
            if (featureContext.TryGetValue("Allure.Net.Commons.AllureContext", out string containerId))
            {
                AllureLifecycle.Instance.StopTestContainer(containerId);
                AllureLifecycle.Instance.WriteTestContainer(containerId);
                Console.WriteLine($"[DEBUG] Closed container for feature: {featureContext.FeatureInfo.Title}");
            }
            else
            {
                Console.WriteLine("[Allure] ERROR: No container context found in FeatureContext.");
            }
        }
    }
}