from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

# You can do the following if you have set the necessary environment variables or created a .env file
chat_completion_service = AzureChatCompletion(service_id="my-service-id")

# Initialize the kernel
kernel = Kernel()

# Add the chat completion service created above to the kernel
kernel.add_service(chat_completion_service)

from typing import Annotated

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.core_plugins import TimePlugin
from semantic_kernel.functions import KernelArguments
from semantic_kernel.functions.kernel_function_decorator import kernel_function


class LocationPlugin:
    """A demo plugin for getting the location of a place."""

    # 関数で AI に実行させたい処理を記載
    @kernel_function(name="get_current_location", description="Get the current location of the user")
    def get_current_location(self) -> Annotated[str, "The current location"]:
        """Get the current location of the user."""
        return "NEW YORK, USA"

# カーネルを作成し、AI サービスとプラグインを追加
kernel = Kernel()
kernel.add_service(
    AzureChatCompletion(
        service_id="default",
    )
)
kernel.add_plugin(
    LocationPlugin(),
    plugin_name="LocationPlugin",
)
# デフォルトで用意されているプラグインを使用する方法もあります。こちらでは TimePlugin を使用
kernel.add_plugin(TimePlugin(), plugin_name="Time")

# 関数の実行設定を構成
# excluded_plugins に指定したプラグインは実行されません
req_settings = AzureChatPromptExecutionSettings(service_id="default", tool_choice="auto")
req_settings.function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"excluded_plugins": ["Time"]})

# カーネルに送信する構成を準備
arguments = KernelArguments(settings=req_settings)

# カーネルからプロンプトを実行します。適宜必要な関数が実行されます
answer = await kernel.invoke_prompt("What is the current location?", arguments=arguments)
print(f"AI:> {answer}")
#print(answer.__str__) # answer.__str__ で実行結果の詳細が確認できます
answer = await kernel.invoke_prompt("What time is it?", arguments=arguments)
print(f"AI:> {answer}")
#print(answer.__str__) # answer.__str__ で実行結果の詳細が確認できます

# 1 ) Kernel を初期化し、Embedding など必要なサービスを追加します
kernel = Kernel()
embedder = AzureTextEmbedding(service_id="embedding")
kernel.add_service(embedder)

# 2 ) データモデルを定義します(Collectionクラスを使う場合)
@vectorstoremodel
@dataclass
class DataModel:
    vector: Annotated[
        list[float] | None,
        VectorStoreRecordVectorField(
            embedding_settings={"embedding": OpenAIEmbeddingPromptExecutionSettings()},
            index_kind=INDEX_KIND,
            dimensions=1536,
            distance_function=DISTANCE_FUNCTION,
            property_type="float",
        ),
    ] = None
    id: Annotated[str, VectorStoreRecordKeyField()] = field(default_factory=lambda: str(uuid4()))
    content: Annotated[
        str,
        VectorStoreRecordDataField(
            has_embedding=True,
            embedding_property_name="vector",
            property_type="str",
            is_full_text_searchable=True,
        ),
    ] = "content1"


# 3 ) メモリ(ベクターストア)コネクタを作成します
## semantic_kernel.connectors.memory から接続したいベクターストアをインポートします。以下例ではメモリ上に作成したベクターストアと接続しています
from semantic_kernel.connectors.memory.in_memory import InMemoryVectorCollection

async with InMemoryVectorCollection[str, DataModel](
    collection_name="test",
    data_model_type=DataModel,
) as record_collection:
    await record_collection.delete_collection()
    await record_collection.create_collection_if_not_exists()

    # 情報の追加
    records_with_embedding = await add_vector_to_records(kernel, records, data_model_type=DataModel)

    # 情報の検索
    search_results = await record_collection.vectorized_search(
            vector=(await embedder.generate_raw_embeddings([query]))[0],
            options=options,
        )

    #　情報の削除
    await record_collection.delete_collection()

# 1 ) AI サービスや Embedding など必要なサービスをカーネルに登録
kernel = Kernel()
service_id = "chat"
kernel.add_service(OpenAIChatCompletion(service_id=service_id))
embeddings = OpenAITextEmbedding(service_id="embedding", ai_model_id="text-embedding-3-small")
kernel.add_service(embeddings)

# 2 ) データモデルを定義します
@vectorstoremodel
class HotelSampleClass(BaseModel):
    ...

# 3 ) メモリ(ベクターストア)コネクタを作成します
collection = AzureAISearchCollection[str, HotelSampleClass](
    collection_name=COLLECTION_NAME, data_model_type=HotelSampleClass
)

# 4 ) コネクタをプラグインとして Kernel に登録します
text_search = collection.create_text_search_from_vector_text_search()
plugin = kernel.add_functions(
    plugin_name="azure_ai_search",
    functions=[
        text_search.create_search(
            # This second function is a more detailed one, that uses a `hotel_id` to get details about a hotel.
            # we set the top to 1, so that only 1 record is returned.
            function_name="get_details",
            description="Get details about a hotel, by ID, use the overview function to get the ID.",
            options=VectorSearchOptions(
                top=1,
            ),
            parameters=[
                KernelParameterMetadata(
                    name="hotel_id",
                    description="The hotel ID to get details for.",
                    type="str",
                    is_required=True,
                    type_object=str,
                ),
                KernelParameterMetadata(
                    name="hotel_name",
                    description="The name of the hotel.",
                    type="str",
                    type_object=str,
                    is_required=True,
                ),
            ],
        ),

# Define agent
agent = ChatCompletionAgent(...)

# Define agent
agent = ChatCompletionAgent(...)

# Generate the agent response
response = await agent.get_response(messages="user input")
# response is an `AgentResponseItem[ChatMessageContent]` object

# Generate another response, continuing the conversation thread from the first response.
response2 = await agent.get_response(messages="user input", thread=response.thread)

# Create and configure the kernel.
kernel = Kernel()

# The filter is used for demonstration purposes to show the function invocation.
kernel.add_filter("function_invocation", function_invocation_filter)

billing_agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    name="BillingAgent",
    instructions=(
        "You specialize in handling customer questions related to billing issues. "
        "This includes clarifying invoice charges, payment methods, billing cycles, "
        "explaining fees, addressing discrepancies in billed amounts, updating payment details, "
        "assisting with subscription changes, and resolving payment failures. "
        "Your goal is to clearly communicate and resolve issues specifically about payments and charges."
    ),
)
refund_agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    name="RefundAgent",
    instructions=(
        "You specialize in addressing customer inquiries regarding refunds. "
        "This includes evaluating eligibility for refunds, explaining refund policies, "
        "processing refund requests, providing status updates on refunds, handling complaints related to refunds, "
        "and guiding customers through the refund claim process. "
        "Your goal is to assist users clearly and empathetically to successfully resolve their refund-related concerns."
    ),
)

triage_agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    kernel=kernel,
    name="TriageAgent",
    instructions=(
        "Your role is to evaluate the user's request and forward it to the appropriate agent based on the nature of "
        "the query. Forward requests about charges, billing cycles, payment methods, fees, or payment issues to the "
        "BillingAgent. Forward requests concerning refunds, refund eligibility, refund policies, or the status of "
        "refunds to the RefundAgent. Your goal is accurate identification of the appropriate specialist to ensure the "
        "user receives targeted assistance."
    ),
    plugins=[billing_agent, refund_agent],
)

thread: ChatHistoryAgentThread = None


async def chat() -> bool:
    """
    Continuously prompt the user for input and show the assistant's response.
    Type 'exit' to exit.
    """
    try:
        user_input = input("User:> ")
    except (KeyboardInterrupt, EOFError):
        print("\n\nExiting chat...")
        return False

    if user_input.lower().strip() == "exit":
        print("\n\nExiting chat...")
        return False

    # ユーザーの入力を元に triage_agent から回答を取得します
    # triage_agent は必要に応じて billing_agent と refund_agent を実行し、情報を収集します
    response = await triage_agent.get_response(
        messages=user_input,
        thread=thread,
    )

    if response:
        print(f"Agent :> {response}")

    return True

async def main() -> None:
    print("Welcome to the chat bot!\n  Type 'exit' to exit.\n  Try to get some billing or refund help.")
    chatting = True
    while chatting:
        chatting = await chat()