class ActivityContext:
    """Context object providing Pyramid integration for Temporal activities.

    This is the main context object passed to pyramid-temporal activities.
    It provides access to the Pyramid environment, registry, and creates
    real Pyramid requests for each activity execution using Pyramid's
    request factory and request extension APIs.

    The request has all the same properties and methods as a web request,
    including any configured via add_request_method (like dbsession, tm, etc.).

    Example:
        @activity.defn
        async def my_activity(context: ActivityContext, user_id: int) -> bool:
            # Real Pyramid request with all configured methods
            session = context.request.dbsession
            user = session.query(User).get(user_id)
            return user is not None
    """

    def __init__(self, env: PyramidEnvironment) -> None:
        """Initialize the activity context.

        Args:
            env: PyramidEnvironment instance
        """
        self._env = env
        self._request: Optional[Request] = None
        self._request_context: Optional[RequestContext] = None

    @property
    def env(self) -> PyramidEnvironment:
        """Get the Pyramid environment."""
        return self._env

    @property
    def registry(self) -> "Registry":
        """Get the Pyramid registry."""
        return self._env.registry

    @property
    def settings(self) -> dict:
        """Get application settings (shortcut to registry.settings)."""
        return self._env.registry.settings

    @property
    def request(self) -> Request:
        """Get the current activity request.

        This is a real Pyramid Request object with all configured
        request methods (dbsession, tm, etc.) available.

        Note: This should only be accessed during activity execution,
        after create_request() has been called by the interceptor.

        Raises:
            RuntimeError: If accessed outside of activity execution
        """
        if self._request is None:
            raise RuntimeError(
                "ActivityContext.request accessed outside of activity execution. "
                "The request is only available during activity execution."
            )
        return self._request

    def create_request(self) -> Request:
        """Create a new Pyramid Request for an activity execution.

        This is called by the interceptor at the start of each activity.
        It uses Pyramid's request factory to create a real request, applies
        request extensions (add_request_method), and sets up threadlocals.

        Returns:
            A real Pyramid Request instance
        """
        registry = self._env.registry
        request_factory = registry.queryUtility(IRequestFactory, default=Request)
        request = request_factory.blank("/")
        request.registry = registry

        if self._env.request is not None:
            request.environ.update(self._env.request.environ)

        self._request_context = RequestContext(request)
        self._request_context.begin()
        apply_request_extensions(request)

        self._request = request

        logger.debug(
            "Created Pyramid Request for activity (request id: %s)",
            id(self._request),
        )
        return self._request

    def close_request(self) -> None:
        """Close the current activity request and clean up resources.

        This is called by the interceptor after activity execution completes.
        It processes finished callbacks and tears down the threadlocal context.
        """
        if self._request is not None:
            try:
                if self._request.finished_callbacks:
                    self._request._process_finished_callbacks()
                self._request_context.end()
                logger.debug("Closed Pyramid Request context")
            except Exception as e:
                logger.warning("Error closing Pyramid Request context: %s", e)
            finally:
                self._request_context = None
                self._request = None

class PyramidActivity:
    """Wrapper for pyramid-temporal activities.

    This class wraps an activity function and provides the ability to
    bind it to an ActivityContext for execution.
    """

    def __init__(
        self,
        fn: Callable[..., Any],
        name: Optional[str] = None,
        no_thread_cancel_default: bool = False,
    ) -> None:
        """Initialize the pyramid activity wrapper.

        Args:
            fn: The original activity function
            name: Optional custom activity name
            no_thread_cancel_default: Thread cancellation setting
        """
        self._fn = fn
        self._name = name or fn.__name__
        self._no_thread_cancel_default = no_thread_cancel_default

        # Copy function metadata for better debugging
        functools.update_wrapper(self, fn)

        # Mark as pyramid-temporal activity
        setattr(self, PYRAMID_ACTIVITY_MARKER, True)

    @property
    def name(self) -> str:
        """Get the activity name."""
        return self._name

    @property
    def fn(self) -> Callable[..., Any]:
        """Get the original function."""
        return self._fn

    def bind(self, context: ActivityContext) -> Callable[..., Any]:
        """Bind this activity to a context, returning a Temporal-compatible activity.

        This creates a wrapper class that injects the context as the first
        argument when the activity is executed.

        Args:
            context: The ActivityContext to bind to

        Returns:
            A bound activity method that can be registered with Temporal Worker
        """
        fn = self._fn
        name = self._name

        class BoundActivity:
            """Bound activity class for Temporal registration."""

            def __init__(self, ctx: ActivityContext) -> None:
                self.context = ctx

            @temporal_activity.defn(name=name)
            async def execute(self, *args: Any, **kwargs: Any) -> Any:
                """Execute the activity with context injection."""
                return await fn(self.context, *args, **kwargs)

        instance = BoundActivity(context)
        return instance.execute

    def __repr__(self) -> str:
        return f"<PyramidActivity '{self._name}'>"

class PyramidEnvironment:
    """Wrapper for Pyramid bootstrap environment.

    This class wraps the output of pyramid.paster.bootstrap, providing
    structured access to the Pyramid application components.

    Attributes:
        registry: The Pyramid registry
        app: The WSGI application
        request: The base request object
        root: The root object (for traversal-based applications)

    Example:
        from pyramid.paster import bootstrap
        from pyramid_temporal import PyramidEnvironment

        # Create from bootstrap output
        env_dict = bootstrap('development.ini')
        env = PyramidEnvironment.from_bootstrap(env_dict)

        # Access components
        settings = env.settings
        registry = env.registry

        # Clean up when done
        env.close()
    """

    def __init__(
        self,
        registry: "Registry",
        app: Optional[Any] = None,
        request: Optional[Any] = None,
        root: Optional[Any] = None,
        closer: Optional[Callable[[], None]] = None,
    ) -> None:
        """Initialize the Pyramid environment.

        Args:
            registry: Pyramid registry instance (required)
            app: WSGI application instance
            request: Base request object from bootstrap
            root: Root object for traversal-based applications
            closer: Cleanup callable from bootstrap
        """
        self._registry = registry
        self._app = app
        self._request = request
        self._root = root
        self._closer = closer

        logger.debug("Created PyramidEnvironment with registry: %s", registry)

    @classmethod
    def from_bootstrap(cls, env: dict) -> "PyramidEnvironment":
        """Create a PyramidEnvironment from bootstrap output.

        This is the preferred way to create a PyramidEnvironment when
        using pyramid.paster.bootstrap.

        Args:
            env: Dictionary returned by pyramid.paster.bootstrap()

        Returns:
            PyramidEnvironment instance

        Example:
            from pyramid.paster import bootstrap
            from pyramid_temporal import PyramidEnvironment

            env = PyramidEnvironment.from_bootstrap(bootstrap('development.ini'))
        """
        return cls(
            registry=env["registry"],
            app=env.get("app"),
            request=env.get("request"),
            root=env.get("root"),
            closer=env.get("closer"),
        )

    @property
    def registry(self) -> "Registry":
        """Get the Pyramid registry."""
        return self._registry

    @property
    def app(self) -> Optional[Any]:
        """Get the WSGI application."""
        return self._app

    @property
    def request(self) -> Optional[Any]:
        """Get the base request object from bootstrap."""
        return self._request

    @property
    def root(self) -> Optional[Any]:
        """Get the root object for traversal-based applications."""
        return self._root

    @property
    def settings(self) -> dict:
        """Get application settings (shortcut to registry.settings)."""
        return self._registry.settings

    def close(self) -> None:
        """Clean up resources.

        This calls the closer function from bootstrap to properly
        clean up the Pyramid application.
        """
        if self._closer is not None:
            logger.debug("Closing PyramidEnvironment")
            self._closer()

    def __repr__(self) -> str:
        """Return string representation."""
        return f"<PyramidEnvironment registry={self._registry}>"

class PyramidTemporalInterceptor(Interceptor):
    """Main interceptor class for pyramid-temporal integration.

    This is the main entry point for integrating pyramid-temporal
    transaction management with Temporal workers.
    """

    def __init__(
        self,
        context: Optional["ActivityContext"] = None,
    ) -> None:
        """Initialize the interceptor.

        Args:
            context: ActivityContext for request/session management
        """
        self._context = context
        logger.info("Initialized PyramidTemporalInterceptor with context: %s", "yes" if context else "no")

    def intercept_activity(self, next_interceptor: ActivityInboundInterceptor) -> ActivityInboundInterceptor:
        """Intercept activity execution to add transaction management.

        Args:
            next_interceptor: The next interceptor in the chain

        Returns:
            Transactional activity interceptor
        """
        return TransactionalActivityInterceptor(
            next_interceptor,
            context=self._context,
        )

class Worker:
    """Pyramid-aware Temporal Worker.

    This worker wraps the standard Temporal Worker and provides automatic
    context binding for pyramid-temporal activities. It also includes
    transaction management via the PyramidTemporalInterceptor.

    Example:
        from pyramid.paster import bootstrap
        from pyramid_temporal import Worker, activity, PyramidEnvironment

        @activity.defn
        async def my_activity(context: ActivityContext, user_id: int) -> bool:
            session = context.request.dbsession
            # ... do work ...
            return True

        # Create environment from bootstrap
        env = PyramidEnvironment.from_bootstrap(bootstrap('development.ini'))

        worker = Worker(
            client,
            env,
            task_queue="my-queue",
            activities=[my_activity],
            workflows=[MyWorkflow],
        )

        # Run the worker
        await worker.run()
    """

    def __init__(
        self,
        client: Client,
        env: PyramidEnvironment,
        *,
        task_queue: str,
        activities: Sequence[Any] = (),
        workflows: Sequence[type] = (),
        interceptors: Sequence["Interceptor"] = (),
        **kwargs: Any,
    ) -> None:
        """Initialize the Pyramid-aware worker.

        Args:
            client: Temporal client instance
            env: PyramidEnvironment instance (from bootstrap)
            task_queue: Name of the task queue to poll
            activities: List of activities (both pyramid-temporal and plain Temporal)
            workflows: List of workflow classes
            interceptors: Additional interceptors to include (pyramid-temporal
                         interceptor is automatically added)
            **kwargs: Additional arguments passed to Temporal Worker
        """
        self._client = client
        self._env = env
        self._task_queue = task_queue
        self._workflows = workflows
        self._extra_kwargs = kwargs

        # Create the activity context
        self._context = ActivityContext(env=env)

        # Bind activities and separate pyramid vs plain
        self._bound_activities = self._bind_activities(activities)

        # Create interceptors list with our interceptor first
        self._interceptors = self._create_interceptors(interceptors)

        # Create the underlying Temporal worker
        self._worker = self._create_worker()

        logger.info(
            "Created Pyramid Worker for task queue '%s' with %d activities and %d workflows",
            task_queue,
            len(self._bound_activities),
            len(workflows),
        )

    def _bind_activities(self, activities: Sequence[Any]) -> list:
        """Bind pyramid-temporal activities to context, pass through others.

        Args:
            activities: List of activities (mixed pyramid and plain)

        Returns:
            List of bound/processed activities
        """
        bound = []
        for act in activities:
            if is_pyramid_activity(act):
                # Bind pyramid-temporal activity to context
                pyramid_act: PyramidActivity = act
                bound_act = pyramid_act.bind(self._context)
                logger.debug("Bound pyramid activity: %s", pyramid_act.name)
                bound.append(bound_act)
            else:
                # Pass through plain Temporal activity
                logger.debug("Passing through plain activity: %s", getattr(act, "__name__", act))
                bound.append(act)
        return bound

    def _create_interceptors(self, extra_interceptors: Sequence["Interceptor"]) -> list["Interceptor"]:
        """Create the interceptors list with pyramid-temporal interceptor.

        Args:
            extra_interceptors: Additional interceptors from user

        Returns:
            List of interceptors with PyramidTemporalInterceptor included
        """
        # Create our interceptor with context reference
        pyramid_interceptor = PyramidTemporalInterceptor(
            context=self._context,
        )

        # Our interceptor first, then user's interceptors
        return [pyramid_interceptor, *extra_interceptors]

    def _create_worker(self) -> TemporalWorker:
        """Create the underlying Temporal worker.

        Returns:
            Configured Temporal Worker instance
        """
        return TemporalWorker(
            self._client,
            task_queue=self._task_queue,
            activities=self._bound_activities,
            workflows=list(self._workflows),
            interceptors=self._interceptors,
            **self._extra_kwargs,
        )

    @property
    def env(self) -> PyramidEnvironment:
        """Get the Pyramid environment."""
        return self._env

    @property
    def context(self) -> ActivityContext:
        """Get the activity context."""
        return self._context

    @property
    def task_queue(self) -> str:
        """Get the task queue name."""
        return self._task_queue

    async def run(self) -> None:
        """Run the worker until shutdown is requested.

        This is the main entry point for running the worker.
        It will poll the task queue and execute activities/workflows.
        """
        logger.info("Starting Pyramid Worker on task queue '%s'", self._task_queue)
        await self._worker.run()

    async def __aenter__(self) -> "Worker":
        """Async context manager entry."""
        await self._worker.__aenter__()
        return self

    async def __aexit__(self, *args: Any) -> None:
        """Async context manager exit."""
        await self._worker.__aexit__(*args)