from mcp.server.fastmcp import FastMCP

# MCP server instance
mcp = FastMCP(
    name="stock-mcp",
)

# ===== Tools =====
@mcp.tool("change_hello_to_hi", description="Change Hello to Hi.")
def change_hello_to_hi(args: dict[str, Any]) -> dict[str, Any]:
    text = args.get("text", "")
    return {"output": text.replace("Hello", "Hi")}

# mcp_simple_stdio/mcp_server.py

# ===== Tools =====
@mcp.tool("get_stock_price", description="Look up stock data from Yahoo Finance.")
def get_stock_price(args: dict[str, Any]) -> dict[str, Any]:
    try:
        ticker_symbol = args.get("ticker")
        if not ticker_symbol:
            return {"success": False, "error": "ticker is required"}

        info: dict[str, Any] = yf.Ticker(ticker_symbol).info  # type: ignore

        current_price = info.get("currentPrice")
        previous_close = info.get("previousClose")
        company_name = info.get("longName", ticker_symbol)

        if current_price is not None and previous_close is not None:
            change = current_price - previous_close
            change_percent = (change / previous_close) * 100 if previous_close else 0.0
            change_str = f"{change:.2f} ({change_percent:.2f}%)"
        else:
            change_str = None

        return {
            "success": True,
            "company_name": company_name,
            "ticker": ticker_symbol,
            "current_price": current_price,
            "previous_close": previous_close,
            "change": change_str,
        }
    except Exception as e:
        return {"success": False, "error": str(e)}

# mcp_simple_stdio/mcp_client.py
async def main() -> None:
    """Run the server over stdio and execute a basic interaction demo."""
    server_params = StdioServerParameters(
        command="python",
        args=["./mcp_simple_stdio/mcp_server.py"],
        env=dict(os.environ),
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            result = await session.call_tool(
                "get_stock_price",
                {"args": {"ticker": "005930.KS"}},
            )
            print(result.content)

async def main() -> None:
    """Run the server over stdio and execute a basic interaction demo."""
    server_params = StdioServerParameters(
        command="python",
        args=["./mcp_simple_stdio/mcp_server.py"],
        env=dict(os.environ),
    )

    client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            QUESTION = "How much is the stock price of Samsung Electronics?"

            tools = await session.list_tools()

            PROMPT_MESSAGE = f"""
            You can call tools to get Answer for this question: {QUESTION},
            tools: {tools},
            What you should do is call tools to get Answer for this question. 
            Choose Only One Tool to call. Just Return the Tool Name.
            If you don't know the answer, return 'None'
            """

            print("PROMPT_MESSAGE: ", PROMPT_MESSAGE)
            response = client.chat.completions.create(
                model=settings.OPENAI_MODEL,
                messages=[
                    {
                        "role": "user",
                        "content": PROMPT_MESSAGE,
                    }
                ],
            )
            print("GPT Response: ", response.choices[0].message.content)

            if response.choices[0].message.content != "None":
                result = await session.call_tool(
                    response.choices[0].message.content,
                    {"args": {"ticker": "005930.KS"}},
                )
                print(result.content)

# ===== Resources =====
@mcp.resource("file://help.md", description="Server usage guide and available tools")
def help_resource() -> str:
    return (
        "# stock-mcp Help\n\n"
        "- get_stock_price(ticker): Look up a Yahoo Finance ticker (e.g., 005930.KS)\n"
        "- prompts:\n"
        "  - extract-stock-code: Message template for extracting a 6-digit stock code\n"
        "  - stock-answer: Message template for composing a stock response\n"
        "\n(Invoke the LLM from the client.)\n"
    )

async def main() -> None:
    """Run the server over stdio and execute a basic interaction demo."""
    server_params = StdioServerParameters(
        command="python",
        args=["./mcp_simple_stdio/mcp_server.py"],
        env=dict(os.environ),
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            resources = await session.list_resources()
            print("\n[Resources]")
            for r in resources.resources:
                print(f"- {r.uri}: {getattr(r, 'description', '')}")

            for r in resources.resources:
                read_result = await session.read_resource(r.uri)
                print(read_result.contents)      

@mcp.prompt(
    "extract-stock-code",
    description="Prompt that extracts a 6-digit Korean stock code from the question",
)
def extract_stock_code_prompt(user_input: str) -> dict[str, Any]:
    return {
        "role": "user",
        "content": (
            "Return only the 6-digit stock code mentioned in the question below."
            " For example, '005930'.\n"
            f"Question: {user_input}"
        ),
    }

async def main() -> None:
    """Run the server over stdio and execute a basic interaction demo."""
    server_params = StdioServerParameters(
        command="python",
        args=["./mcp_simple_stdio/mcp_server.py"],
        env=dict(os.environ),
    )

    client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # extract-stock-code 프롬프트 사용 예시
            prompt_result = await session.get_prompt(
                "extract-stock-code",
                {"user_input": "How much is the stock price of Samsung Electronics?"},
            )
            for msg in getattr(prompt_result, "messages", []) or []:
                print(msg.content)

            response = client.chat.completions.create(
                model=settings.OPENAI_MODEL,
                messages=[
                    {
                        "role": "user",
                        "content": msg.content.text,
                    }
                ],
            )

            print("GPT Response: ", response.choices[0].message.content)

async def main():
    async with MCPServerStdio(
        params={
            "command": "uv",
            "args": ["run", "-m", "openai_agent_sdk.mcp_server"],
        },
    ) as server:
        agent = Agent(
            name="test",
            instructions="test",
            model=settings.OPENAI_MODEL,
            mcp_servers=[server],
        )

        result = await Runner.run(agent, "삼성전자 주가 얼마야?")
        print(result)