import unittest
from unittest.mock import patch

import chatgpt_signup


class PasskeyEnrollmentTests(unittest.TestCase):
    def test_detects_passkey_enrollment_url(self):
        self.assertTrue(
            chatgpt_signup._is_passkey_enrollment_url(
                "https://auth.openai.com/create-account-enroll-passkey"
            )
        )

    def test_does_not_treat_about_you_as_passkey_enrollment(self):
        self.assertFalse(
            chatgpt_signup._is_passkey_enrollment_url(
                "https://auth.openai.com/about-you"
            )
        )

    def test_passkey_handler_clicks_skip_button(self):
        class _FakeLocator:
            def __init__(self, page, selector):
                self.page = page
                self.selector = selector

            def count(self):
                return 1 if "Skip for now" in self.selector else 0

            def nth(self, _idx):
                return self

            def is_visible(self):
                return True

            def is_enabled(self):
                return True

            def click(self, **_kwargs):
                self.page.clicked.append(self.selector)
                self.page.url = "https://chatgpt.com/"

        class _FakePage:
            def __init__(self):
                self.url = "https://auth.openai.com/create-account-enroll-passkey"
                self.clicked = []

            def locator(self, selector):
                return _FakeLocator(self, selector)

        page = _FakePage()

        handled = chatgpt_signup._handle_passkey_enrollment_if_present(
            page,
            log=lambda *_: None,
            timeout_sec=1,
        )

        self.assertTrue(handled)
        self.assertTrue(page.clicked)
        self.assertEqual(page.url, "https://chatgpt.com/")


class SignupEntrypointTests(unittest.TestCase):
    def test_does_not_generate_credentials_when_entry_page_cannot_open(self):
        class _FakePage:
            def goto(self, *_args, **_kwargs):
                raise RuntimeError("net::ERR_EMPTY_RESPONSE")

        with patch.object(chatgpt_signup, "build_a4sky_email", return_value="n@example.com") as build_email:
            with self.assertRaises(RuntimeError):
                chatgpt_signup.signup_chatgpt(
                    _FakePage(),
                    helper_url="http://mail.example",
                    log=lambda *_: None,
                )

        self.assertEqual(build_email.call_count, 0)


class SsoWorkspaceChoiceTests(unittest.TestCase):
    def test_signup_sso_clicks_workspace_choice_before_keycloak_register(self):
        class _FakePage:
            def __init__(self):
                self.url = ""

            def goto(self, *_args, **_kwargs):
                self.url = "https://chatgpt.com/"

            def wait_for_timeout(self, *_args, **_kwargs):
                pass

            def wait_for_load_state(self, *_args, **_kwargs):
                pass

        page = _FakePage()
        workspace_clicks = []

        def fill_sso_email(fake_page, *_args, **_kwargs):
            fake_page.url = "https://auth.openai.com/sso"

        def click_workspace(fake_page, *_args, **_kwargs):
            workspace_clicks.append(fake_page.url)
            fake_page.url = "https://sso.claudeai.life/realms/openai/login-actions/authenticate"
            return True

        def click_register(fake_page, *_args, **_kwargs):
            fake_page.url = "https://sso.claudeai.life/realms/openai/login-actions/registration"
            return True

        with patch.object(chatgpt_signup, "_build_sso_email", return_value="n@example.com"):
            with patch.object(chatgpt_signup, "_rand_name", return_value=("First", "Last")):
                with patch.object(chatgpt_signup, "_find_visible", return_value=(object(), "input")):
                    with patch.object(chatgpt_signup, "_fill_signup_email", side_effect=fill_sso_email):
                        with patch.object(chatgpt_signup, "_wait_for_sso_or_keycloak", return_value=True):
                            with patch.object(chatgpt_signup, "_click_sso_workspace_option", side_effect=click_workspace, create=True):
                                with patch.object(chatgpt_signup, "_click_keycloak_register", side_effect=click_register):
                                    with patch.object(chatgpt_signup, "_wait_until", side_effect=lambda predicate, _timeout: bool(predicate())):
                                        with patch.object(chatgpt_signup, "_fill_keycloak_registration"):
                                            with patch.object(chatgpt_signup, "_handle_interstitial_confirm", return_value=False):
                                                with patch.object(chatgpt_signup, "_handle_passkey_enrollment_if_present", return_value=False):
                                                    with patch.object(chatgpt_signup, "_fetch_session", return_value={"accessToken": "tok"}):
                                                        chatgpt_signup.signup_chatgpt_sso(page, log=lambda *_: None)

        self.assertEqual(workspace_clicks, ["https://auth.openai.com/sso"])

    def test_click_sso_workspace_option_clicks_workspace_button(self):
        class _FakeLocator:
            def __init__(self, page, selector):
                self.page = page
                self.selector = selector

            def count(self):
                return 1 if "Workspace" in self.selector else 0

            def nth(self, _idx):
                return self

            def is_visible(self):
                return True

            def is_enabled(self):
                return True

            def click(self, **_kwargs):
                self.page.clicked.append(self.selector)
                self.page.url = "https://sso.claudeai.life/realms/openai/login-actions/authenticate"

        class _FakePage:
            def __init__(self):
                self.url = "https://auth.openai.com/sso"
                self.clicked = []

            def locator(self, selector):
                return _FakeLocator(self, selector)

            def wait_for_timeout(self, *_args, **_kwargs):
                pass

        page = _FakePage()
        click_workspace = getattr(chatgpt_signup, "_click_sso_workspace_option", lambda *_args, **_kwargs: False)

        clicked = click_workspace(page, log=lambda *_: None, timeout_sec=1)

        self.assertTrue(clicked)
        self.assertTrue(page.clicked)
        self.assertIn("Workspace", page.clicked[0])


class SsoConsentTests(unittest.TestCase):
    def test_handle_consent_page_clicks_approve_sign_in(self):
        class _FakeLocator:
            def __init__(self, page, selector):
                self.page = page
                self.selector = selector

            def count(self):
                return 1 if "Approve sign-in" in self.selector else 0

            def nth(self, _idx):
                return self

            def is_visible(self):
                return True

            def is_enabled(self):
                return True

            def click(self, **_kwargs):
                self.page.clicked.append(self.selector)
                self.page.url = "https://chatgpt.com/"

        class _FakePage:
            def __init__(self):
                self.url = "https://external.auth.openai.com/sso/signin-consent?token=abc"
                self.clicked = []

            def locator(self, selector):
                return _FakeLocator(self, selector)

            def wait_for_timeout(self, *_args, **_kwargs):
                pass

        page = _FakePage()

        with patch.object(chatgpt_signup, "_wait_until", side_effect=lambda predicate, _timeout: bool(predicate())):
            approved = chatgpt_signup._handle_interstitial_confirm(page, log=lambda *_: None, timeout_sec=1)

        self.assertTrue(approved)
        self.assertTrue(page.clicked)
        self.assertIn("Approve sign-in", page.clicked[0])


if __name__ == "__main__":
    unittest.main()