using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Reflection;

using Microsoft.VisualStudio.TestTools.UnitTesting;

​

public class RegistrationSystem

{

    private static bool _enableLinkInvitation;

    private static bool _requireConfirmation;

    private static Uri _invitationLink;

    private static Dictionary<string, User> _registeredUsers = new();

    private static List<User> _rejectedUsers = new();

    public static Uri SetLinkInvitationSetting(bool enableLinkInvitation, bool requireConfirmation)

    {

        _enableLinkInvitation = enableLinkInvitation;

        _requireConfirmation = requireConfirmation;

        if (enableLinkInvitation)

        {

            _invitationLink = new Uri("https://example.com/invite/xyz123");

            return _invitationLink;

        }

        else

        {

            return null;

        }

    }

​

    public class Account

    {

        public static Uri GetRegistrationConfirmUri(User user)

        {

            // In a real system, this would involve generating a unique, secure token.

            return new Uri($"https://example.com/confirm/{user.Email}");

        }

    }

​

    public static void JoinPortalNewUser(User user, Uri confirmUri, bool expectConfirmationPage)

    {

        if (!_registeredUsers.ContainsKey(user.Email))

        {

            _registeredUsers.Add(user.Email, user);

        }

​

        // Simulate opening the confirmation URI.

        //Console.WriteLine($"Opening confirmation URI: {confirmUri}");

        Debug.WriteLine($"Opening confirmation URI: {confirmUri}");

        if (expectConfirmationPage)

        {

            // Simulate checking for a confirmation page.

            //Console.WriteLine("Confirmation page displayed.");

            Debug.WriteLine("Confirmation page displayed.");

        }

    }

​

    public static void RejectUsrInvitationWithAssertAuthImpossabilityCommonPart(User user)

    {

        RejectUserInvitCommon(user);

        //Assert.IsFalse(LoginPage.Login(user.Email, user.Password));

        if (_registeredUsers.ContainsKey(user.Email) && !_rejectedUsers.Contains(user))

        {

            throw new Exception("User should not be able to authenticate");

        }

    }

​

    public static void RejectUserInvitCommon(User user)

    {

        _rejectedUsers.Add(user);

        _registeredUsers.Remove(user.Email);

    }

​

    public static string getTextForRegCompletePage()

    {

        return "Registration Complete!";

    }

​

        public static void Main()

    {

        Console.WriteLine("🔍 Discovering and Running Tests...\n");

​

        int totalPassed = 0, totalFailed = 0;

​

        // Get all classes in the assembly with the [TestClass] attribute

        var testClasses = Assembly.GetExecutingAssembly()

            .GetTypes()

            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);

​

        foreach (var testClass in testClasses)

        {

            Console.WriteLine($"📌 Running tests in: {testClass.Name}");

            (int passed, int failed) = RunTests(testClass);

            totalPassed += passed;

            totalFailed += failed;

            Console.WriteLine();

        }

​

        Console.WriteLine("\n📊 FINAL SUMMARY:");

        Console.WriteLine($"✅ Total Passed: {totalPassed}");

        Console.WriteLine($"❌ Total Failed: {totalFailed}");

        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");

​

        Console.WriteLine("\n✅ Test execution completed.");

    }

​

    private static (int passed, int failed) RunTests(Type testClassType)

    {

        object testInstance = Activator.CreateInstance(testClassType);

        MethodInfo[] testMethods = testClassType

            .GetMethods(BindingFlags.Instance | BindingFlags.Public)

            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)

            .ToArray();

​

        int passed = 0, failed = 0;

​

        foreach (var method in testMethods)

        {

            try

            {

                method.Invoke(testInstance, null);

                Console.WriteLine($"  ✅ {method.Name} PASSED");

                passed++;

            }

            catch (TargetInvocationException ex)

            {

                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");

                failed++;

            }

            catch (Exception ex)

            {

                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");

                failed++;

            }

        }

​

        return (passed, failed);

    }

​

}

​

public class User

{

    public string Email { get; set; }

    public string Password { get; set; }

}

​

//Simulate

public static class registrationPageNoAuth

{

    public static void Register(User user, Uri invitationLink, bool mustBeSuccess)

    {

        if (RegistrationSystem.SetLinkInvitationSetting(true, true) == null && invitationLink != null)

        {

            throw new Exception("Cannot register by the link while it is disbled");

        }

    //RegistrationSystem._registeredUsers.Add(user.Email, user);

    }

​

    public static void Goto()

    {

    }

​

    public static string GetText()

    {

        return "";

    }

}

​

public static class LoginPage

{

    public static bool Login(string email, string password)

    {

        return false;

    }

}

​

public static class JoinToPortalPage

{

    public static void Open(Uri confirmUri)

    {

    }

​

    public static void OpenConfirmPage()

    {

    }

}