import json
import os

from azure.core.exceptions import DeserializationError
from botbuilder.core import (
    BotFrameworkAdapter,
    BotFrameworkAdapterSettings,
    TurnContext,
)
from botbuilder.core.teams import TeamsActivityHandler
from botbuilder.schema import Activity, ActivityTypes
from flask import Flask, jsonify, request

# Create a Flask app, which can also store our config.
app = Flask(__name__)

# Extract environment variables that we'll need to authenticate our bot.
try:
    app.config.update(
        TEAMS_BOT_CLIENT_ID=os.environ["TEAMS_BOT_CLIENT_ID"],
        TEAMS_BOT_CLIENT_SECRET=os.environ["TEAMS_BOT_CLIENT_SECRET"],
    )
except KeyError:
    raise LookupError(
        "Environment variables TEAMS_BOT_CLIENT_ID and TEAMS_BOT_CLIENT_SECRET "
        "must be set."
    )

# Create a "handler" that implements various callbacks for events that Teams sends us.
class BotHandler(TeamsActivityHandler):
    """
    Determines what to do for incoming events with per-category methods.

    <https://learn.microsoft.com/en-us/microsoftteams/platform/bots/bot-basics?tabs=python>
    """

    async def on_message_activity(self, turn_context: TurnContext) -> None:
        """Handle “message activity” events."""
        return await turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text=f"**Received:** {turn_context.activity.text}",
            )
        )

bot = BotHandler()

# Create an adapter that will handle authentication and routing of messages to the bot.
bot_adapter = BotFrameworkAdapter(
    BotFrameworkAdapterSettings(
        # Replace these with settings from environment variables in a real app.
        # None values allow requests from the Bot Framework Emulator.
        app_id=app.config["TEAMS_BOT_CLIENT_ID"],
        app_password=app.config["TEAMS_BOT_CLIENT_SECRET"],
    )
)

# Add a route to handle Teams messages.
@app.route("/events", methods=["POST"])
async def handle_event():
    """Respond to an event from Microsoft Teams."""
    try:
        payload = request.json
    except json.JSONDecodeError:
        print(request)
        return jsonify({"error": "Bad request"}), 400

    # React to the activity
    try:
        activity = Activity.deserialize(payload)
    except DeserializationError:
        return jsonify({"error": "Bad request"}), 400

    auth_header = request.headers.get("authorization", "")
    try:
        invoke_response = await bot_adapter.process_activity(
            activity,
            auth_header,
            bot.on_turn,
        )

    except TypeError:
        return jsonify({"error": "Bad request"}), 400
    else:
        if invoke_response:
            return jsonify(invoke_response.body), invoke_response.status
        else:
            return jsonify({}), 204

import asyncio

# ...

async def handle_activity(serialized_activity: dict) -> None:
    """Handle an activity."""
    # Simulate a delay as if we enqueued this job within
    # a busy production workload.
    await asyncio.sleep(3)
    
    print("Handling activity...")

		# Deserialize the activity, and get a reference to the conversation
		# from which the activity originated.
    activity = Activity.deserialize(serialized_activity)
    conversation_reference = activity.get_conversation_reference()

		# "Continue" the conversation by replying with a message.
    await bot_adapter.continue_conversation(
        conversation_reference,
        lambda turn_context: turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text=f"**Received:** {activity.text}",
            )
        ),
        bot_id=app.config["TEAMS_BOT_CLIENT_ID"],
    )

# ...

from threading import Thread

# ...

[class BackgroundWorker(Thread):
    """A very basic background worker implementation using asyncio."""

    _loop: asyncio.AbstractEventLoop

    def __init__(self) -> None:
        super().__init__(daemon=True)
        self._loop = asyncio.new_event_loop()

    def run(self) -> None:
        """Run the background worker."""
        asyncio.set_event_loop(self._loop)
        self._loop.run_forever()

    async def wrap_task(self, task: Coroutine) -> Coroutine:
        """Wrap a coroutine in a try/except block to catch errors.

        Prints the error to the console.
        """
        try:
            await task
        except Exception:
            traceback.print_exc()

    def run_task(self, task: Coroutine) -> None:
        """Run a coroutine in the background."""
        # Start the background worker thread if it's not already running.
        if not self.is_alive():
            self.start()

        # Run the task in the background worker thread's event loop.
        asyncio.run_coroutine_threadsafe(
            coro=self.wrap_task(task),
            loop=self._loop,
        )

# Create a background worker for running tasks asynchronously.
background_worker = BackgroundWorker()](<https://www.notion.so/Aptible-AI-for-PaaS-145509e56b41800da6d9c8311f86be95?pvs=21>)

class BotHandler(TeamsActivityHandler):
    
    # ...
    
    async def on_message_activity(self, turn_context: TurnContext) -> None:
        """Handle “message activity” events."""
        # Generate an immediately reply to let the user know we've
        # seen their message.
        reply = await turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text="One moment please...",
            )
        )

        # Serialize the activity we received so that we can enqueue
        # the job.
        serialized_activity = turn_context.activity.serialize()

        # Handle the activity in the background. You can (and should) use
        # Celery or another background task strategy here instead for real
        # workloads.
        background_worker.run_task(handle_activity(serialized_activity))

        # Return our reply.
        return reply

from openai import AsyncOpenAI

# ...

openai_client = AsyncOpenAI(
    api_key=app.config["OPENAI_API_KEY"],
)

# ...

async def handle_activity(serialized_activity: dict) -> None:
    """Handle an activity."""
    activity = Activity.deserialize(serialized_activity)
    conversation_reference = activity.get_conversation_reference()
    
    completion = client.chat.completions.create(
		  model="gpt-4o-mini",
		  messages=[{"role": "user", "content": activity.text}],
		)

    await bot_adapter.continue_conversation(
        conversation_reference,
        lambda turn_context: turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text=completion.choices[0].message.content,
            )
        ),
        bot_id=app.config["TEAMS_BOT_CLIENT_ID"],
    )

# ...

# ...

# Extract environment variables that we'll need to authenticate our bot.
try:
    app.config.update(
        # ...
        TEAMS_BOT_TENANT_ID=os.environ["TEAMS_BOT_TENANT_ID"],
        # ...
    )
except KeyError:
    raise LookupError(
        "Environment variables TEAMS_BOT_CLIENT_ID, TEAMS_BOT_CLIENT_SECRET, and "
        "OPENAI_API_KEY, TEAMS_BOT_TENANT_ID must be set."
    )
    
# ...

import re
from typing import AsyncIterator, cast
from azure.identity.aio import ClientSecretCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.models.chat_message import ChatMessage

# ...

async def iter_conversation_messages(
    tenant_id: str,
    team_id: str,
    channel_id: str,
    conversation_id: str,
) -> AsyncIterator[ChatMessage]:
    """Yield all messages in a conversation thread."""
    print(tenant_id, team_id, channel_id, conversation_id)

    # Create a Microsoft Graph Client.
    client = GraphServiceClient(
        credentials=ClientSecretCredential(
            client_id=app.config["TEAMS_BOT_CLIENT_ID"],
            client_secret=app.config["TEAMS_BOT_CLIENT_SECRET"],
            tenant_id=tenant_id,
        )
    )

    # Parse the message ID from the conversation ID
    if parsed_conversation_id := re.search(r"messageid=(\\d+)", conversation_id):
        original_message_id = parsed_conversation_id.group(1)
    else:
        raise ValueError(
            f"Could not parse message ID from conversation ID: {conversation_id}"
        )

    channel_messages = (
        client.teams.by_team_id(team_id).channels.by_channel_id(channel_id).messages
    )
    original_message = channel_messages.by_chat_message_id(original_message_id)
    thread_replies = channel_messages.by_chat_message_id(original_message_id).replies

    # Request the maximmum number of replies at a time to minimize requests.
    request_configuration = RequestConfiguration(
        query_parameters=thread_replies.RepliesRequestBuilderGetQueryParameters(
            top=50,
        )
    )

    # Yield all messages in the thread, page by page.
    next_link: str | None = None
    while True:
        # Get the first page or the subsequent pages if there's a next link
        if next_link:
            replies_page = await thread_replies.with_url(next_link).get(
                request_configuration
            )
        else:
            replies_page = await thread_replies.get(request_configuration)

        # Break if there are no results in the page.
        if not replies_page or not replies_page.value:
            break

        # Yield the messages from the current page.
        for message in replies_page.value:
            yield message

        next_link = replies_page.odata_next_link

        # Break when there are no more pages.
        if not next_link:
            break

    # Finally, yield the original message that started the thread.
    yield cast(ChatMessage, await original_message.get())

async def handle_activity(serialized_activity: dict) -> None:
    """Handle an activity."""
    activity = cast(Activity, Activity.deserialize(serialized_activity))
    conversation_reference = cast(
        ConversationReference, activity.get_conversation_reference()
    )

    async def _generate_reply(turn_context: TurnContext) -> str:
        channel_data = activity.channel_data

        # Insert our activity's channel data into the turn context so that we
        # can use it to retrieve the original team context.
        turn_context.activity.channel_data = channel_data
        teams_info = await TeamsInfo.get_team_details(turn_context)

        channel_id = channel_data["channel"]["id"]
        tenant_id = channel_data["tenant"]["id"]
        team_id = teams_info.aad_group_id
        conversation_id = conversation_reference.conversation.id

        # Get all messages in the conversation in OpenAI format, skipping the
        # first message (since it's the most recent "one moment please..."
        # message from the bot), then reversing them so that they're in
        # chronological order (the Microsoft Graph API returns them in reverse).
        openai_messages = reversed(
            [
                {
                    "role": "user" if message.from_.user else "assistant",
                    "content": message.body.content,
                }
                async for message in iter_conversation_messages(
                    tenant_id=tenant_id,
                    team_id=team_id,
                    channel_id=channel_id,
                    conversation_id=conversation_id,
                )
            ][1:]
        )

        # Generate a reply using OpenAI.
        completion = await openai_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=openai_messages,
        )

        await turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text=completion.choices[0].message.content,
            )
        )

    await bot_adapter.continue_conversation(
        conversation_reference,
        _generate_reply,
        bot_id=app.config["TEAMS_BOT_CLIENT_ID"],
    )

import asyncio
import json
import os
import re
import traceback
from collections.abc import Coroutine
from threading import Thread
from typing import AsyncIterator, cast

from azure.core.exceptions import DeserializationError
from azure.identity.aio import ClientSecretCredential
from botbuilder.core import (
    BotFrameworkAdapter,
    BotFrameworkAdapterSettings,
    TurnContext,
)
from botbuilder.core.teams import TeamsActivityHandler, TeamsInfo
from botbuilder.schema import Activity, ActivityTypes, ConversationReference
from flask import Flask, jsonify, request
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.models.chat_message import ChatMessage
from openai import AsyncOpenAI

# Create a Flask app, which can also store our config.
app = Flask(__name__)

# Extract environment variables that we'll need to authenticate our bot.
try:
    app.config.update(
        TEAMS_BOT_CLIENT_ID=os.environ["TEAMS_BOT_CLIENT_ID"],
        TEAMS_BOT_CLIENT_SECRET=os.environ["TEAMS_BOT_CLIENT_SECRET"],
        OPENAI_API_KEY=os.environ["OPENAI_API_KEY"],
    )
except KeyError:
    raise LookupError(
        "Environment variables TEAMS_BOT_CLIENT_ID, TEAMS_BOT_CLIENT_SECRET, and "
        "OPENAI_API_KEY must be set."
    )

openai_client = AsyncOpenAI(api_key=app.config["OPENAI_API_KEY"])

class BackgroundWorker(Thread):
    """A very basic background worker implementation using asyncio."""

    _loop: asyncio.AbstractEventLoop

    def __init__(self):
        super().__init__(daemon=True)
        self._loop = asyncio.new_event_loop()

    def run(self) -> None:
        """Run the background worker."""
        asyncio.set_event_loop(self._loop)
        self._loop.run_forever()

    async def wrap_task(self, task: Coroutine) -> Coroutine:
        """Wrap a coroutine in a try/except block to catch errors.

        Prints the error to the console.
        """
        try:
            await task
        except Exception:
            traceback.print_exc()

    def run_task(self, task: Coroutine) -> None:
        """Run a coroutine in the background."""
        # Start the background worker thread if it's not already running.
        if not self.is_alive():
            self.start()

        # Run the task in the background worker thread's event loop.
        asyncio.run_coroutine_threadsafe(
            coro=self.wrap_task(task),
            loop=self._loop,
        )

background_worker = BackgroundWorker()

async def iter_conversation_messages(
    tenant_id: str,
    team_id: str,
    channel_id: str,
    conversation_id: str,
) -> AsyncIterator[ChatMessage]:
    """Yield all messages in a conversation thread."""
    print(tenant_id, team_id, channel_id, conversation_id)

    # Create a Microsoft Graph Client.
    client = GraphServiceClient(
        credentials=ClientSecretCredential(
            client_id=app.config["TEAMS_BOT_CLIENT_ID"],
            client_secret=app.config["TEAMS_BOT_CLIENT_SECRET"],
            tenant_id=tenant_id,
        )
    )

    # Parse the message ID from the conversation ID
    if parsed_conversation_id := re.search(r"messageid=(\\d+)", conversation_id):
        original_message_id = parsed_conversation_id.group(1)
    else:
        raise ValueError(
            f"Could not parse message ID from conversation ID: {conversation_id}"
        )

    channel_messages = (
        client.teams.by_team_id(team_id).channels.by_channel_id(channel_id).messages
    )
    original_message = channel_messages.by_chat_message_id(original_message_id)
    thread_replies = channel_messages.by_chat_message_id(original_message_id).replies

    # Request the maximmum number of replies at a time to minimize requests.
    request_configuration = RequestConfiguration(
        query_parameters=thread_replies.RepliesRequestBuilderGetQueryParameters(
            top=50,
        )
    )

    # Yield all messages in the thread, page by page.
    next_link: str | None = None
    while True:
        # Get the first page or the subsequent pages if there's a next link
        if next_link:
            replies_page = await thread_replies.with_url(next_link).get(
                request_configuration
            )
        else:
            replies_page = await thread_replies.get(request_configuration)

        # Break if there are no results in the page.
        if not replies_page or not replies_page.value:
            break

        # Yield the messages from the current page.
        for message in replies_page.value:
            yield message

        next_link = replies_page.odata_next_link

        # Break when there are no more pages.
        if not next_link:
            break

    # Finally, yield the original message that started the thread.
    yield cast(ChatMessage, await original_message.get())

async def handle_activity(serialized_activity: dict) -> None:
    """Handle an activity."""
    activity = cast(Activity, Activity.deserialize(serialized_activity))
    conversation_reference = cast(
        ConversationReference, activity.get_conversation_reference()
    )

    async def _generate_reply(turn_context: TurnContext) -> str:
        channel_data = activity.channel_data

        # Insert our activity's channel data into the turn context so that we
        # can use it to retrieve the original team context.
        turn_context.activity.channel_data = channel_data
        teams_info = await TeamsInfo.get_team_details(turn_context)

        channel_id = channel_data["channel"]["id"]
        tenant_id = channel_data["tenant"]["id"]
        team_id = teams_info.aad_group_id
        conversation_id = conversation_reference.conversation.id

        # Get all messages in the conversation in OpenAI format, skipping the
        # first message (since it's the most recent "one moment please..."
        # message from the bot), then reversing them so that they're in
        # chronological order (the Microsoft Graph API returns them in reverse).
        openai_messages = reversed(
            [
                {
                    "role": "user" if message.from_.user else "assistant",
                    "content": message.body.content,
                }
                async for message in iter_conversation_messages(
                    tenant_id=tenant_id,
                    team_id=team_id,
                    channel_id=channel_id,
                    conversation_id=conversation_id,
                )
            ][1:]
        )

        # Generate a reply using OpenAI.
        completion = await openai_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=openai_messages,
        )

        await turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text=completion.choices[0].message.content,
            )
        )

    await bot_adapter.continue_conversation(
        conversation_reference,
        _generate_reply,
        bot_id=app.config["TEAMS_BOT_CLIENT_ID"],
    )

# Create a "handler" that implements various callbacks for events that Teams sends us.
class BotHandler(TeamsActivityHandler):
    """
    Determines what to do for incoming events with per-category methods.

    <https://learn.microsoft.com/en-us/microsoftteams/platform/bots/bot-basics?tabs=python>
    """

    async def on_message_activity(self, turn_context: TurnContext) -> None:
        """Handle "message activity" events."""
        reply = await turn_context.send_activity(
            Activity(
                type=ActivityTypes.message,
                text_format="markdown",
                text="One moment please...",
            )
        )

        serialized_activity = turn_context.activity.serialize()

        background_worker.run_task(handle_activity(serialized_activity))

        return reply

bot = BotHandler()

# Create an adapter that will handle authentication and routing of messages to the bot.
bot_adapter = BotFrameworkAdapter(
    BotFrameworkAdapterSettings(
        # Replace these with settings from environment variables in a real app.
        # None values allow requests from the Bot Framework Emulator.
        app_id=app.config["TEAMS_BOT_CLIENT_ID"],
        app_password=app.config["TEAMS_BOT_CLIENT_SECRET"],
    )
)

# Add a route to handle Teams messages.
@app.route("/events", methods=["POST"])
async def handle_event():
    """Respond to an event from Microsoft Teams."""
    try:
        payload = request.json
    except json.JSONDecodeError:
        print(request)
        return jsonify({"error": "Bad request"}), 400

    # React to the activity
    try:
        activity = Activity.deserialize(payload)
    except DeserializationError:
        return jsonify({"error": "Bad request"}), 400

    auth_header = request.headers.get("authorization", "")
    try:
        invoke_response = await bot_adapter.process_activity(
            activity,
            auth_header,
            bot.on_turn,
        )
    # Note: more more except blocks may be needed, per:
    # <https://github.com/microsoft/botbuilder-python/blob/main/libraries/botbuilder-core/botbuilder/core/integration/aiohttp_channel_service_exception_middleware.py#L19>
    except TypeError:
        return jsonify({"error": "Bad request"}), 400
    else:
        if invoke_response:
            return jsonify(invoke_response.body), invoke_response.status
        else:
            return jsonify({}), 204