import os
from typing import Dict, Optional, List
import logging

from fastapi import FastAPI
from starlette.requests import Request
from starlette.responses import StreamingResponse, JSONResponse

from ray import serve

from vllm.engine.arg_utils import AsyncEngineArgs
from vllm.engine.async_llm_engine import AsyncLLMEngine
from vllm.entrypoints.openai.cli_args import make_arg_parser
from vllm.entrypoints.openai.protocol import (
    ChatCompletionRequest,
    ChatCompletionResponse,
    ErrorResponse,
)
from vllm.entrypoints.openai.serving_chat import OpenAIServingChat, BaseModelPath
from vllm.entrypoints.openai.serving_engine import LoRAModulePath
from vllm.utils import FlexibleArgumentParser

logger = logging.getLogger("ray.serve")

app = FastAPI()

@serve.deployment(name="VLLMDeployment")
@serve.ingress(app)
class VLLMDeployment:
    def __init__(
        self,
        engine_client: AsyncLLMEngine,
        model_config: Dict,
        base_model_paths: List[BaseModelPath],
        response_role: str,
        lora_modules: Optional[List[LoRAModulePath]] = None,
        prompt_adapters: Optional[List[str]] = None,
        request_logger: Optional[logging.Logger] = None,
        chat_template: Optional[str] = None,
        chat_template_content_format: str = "json",
        return_tokens_as_token_ids: bool = False,
        enable_auto_tools: bool = False,
        tool_parser: Optional[str] = None,
        enable_prompt_tokens_details: bool = False,
    ):
        logger.info(f"Starting with engine client: {engine_client}")
        self.openai_serving_chat = None
        self.engine_client = engine_client
        self.model_config = model_config
        self.base_model_paths = base_model_paths
        self.response_role = response_role
        self.lora_modules = lora_modules
        self.prompt_adapters = prompt_adapters
        self.request_logger = request_logger
        self.chat_template = chat_template
        self.chat_template_content_format = chat_template_content_format
        self.return_tokens_as_token_ids = return_tokens_as_token_ids
        self.enable_auto_tools = enable_auto_tools
        self.tool_parser = tool_parser
        self.enable_prompt_tokens_details = enable_prompt_tokens_details

    @app.post("/v1/chat/completions")
    async def create_chat_completion(
        self, request: ChatCompletionRequest, raw_request: Request
    ):
        """OpenAI-compatible HTTP endpoint.

        API reference:
            - https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
        """
        if not self.openai_serving_chat:
            model_config = await self.engine_client.get_model_config()
            self.openai_serving_chat = OpenAIServingChat(
                self.engine_client,
                model_config,
                self.base_model_paths,
                self.response_role,
                lora_modules=self.lora_modules,
                prompt_adapters=self.prompt_adapters,
                request_logger=self.request_logger,
                chat_template=self.chat_template,
                chat_template_content_format=self.chat_template_content_format,
                return_tokens_as_token_ids=self.return_tokens_as_token_ids,
                enable_auto_tools=self.enable_auto_tools,
                tool_parser=self.tool_parser,
                enable_prompt_tokens_details=self.enable_prompt_tokens_details,
            )
        logger.info(f"Request: {request}")
        generator = await self.openai_serving_chat.create_chat_completion(
            request, raw_request
        )
        if isinstance(generator, ErrorResponse):
            return JSONResponse(
                content=generator.model_dump(), status_code=generator.code
            )
        if request.stream:
            return StreamingResponse(content=generator, media_type="text/event-stream")
        else:
            assert isinstance(generator, ChatCompletionResponse)
            return JSONResponse(content=generator.model_dump())

def parse_vllm_args(cli_args: Dict[str, str]):
    """Parses vLLM args based on CLI inputs.

    Currently uses argparse because vLLM doesn't expose Python models for all of the
    config options we want to support.
    """
    parser = FlexibleArgumentParser(description="vLLM CLI")
    parser = make_arg_parser(parser)
    arg_strings = []
    for key, value in cli_args.items():
        arg_strings.extend([f"--{key}", str(value)])
    logger.info(arg_strings)
    parsed_args = parser.parse_args(args=arg_strings)
    return parsed_args

def build_app(cli_args: Dict[str, str], base_model_paths: List[BaseModelPath]) -> serve.Application:
    """Builds the Serve app based on CLI arguments.

    See https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html#command-line-arguments-for-the-server
    for the complete set of arguments.

    Supported engine arguments: https://docs.vllm.ai/en/latest/models/engine_args.html.
    """
    parsed_args = parse_vllm_args(cli_args)
    engine_args = AsyncEngineArgs.from_cli_args(parsed_args)
    engine_args.worker_use_ray = True

    model_config = {}  # Load your model config here

    return VLLMDeployment.bind(
        AsyncLLMEngine.from_engine_args(engine_args),
        model_config,
        base_model_paths,
        parsed_args.response_role,
        lora_modules=parsed_args.lora_modules,
        prompt_adapters=parsed_args.prompt_adapters,
        request_logger=logging.getLogger("request"),
        chat_template=parsed_args.chat_template,
        chat_template_content_format=parsed_args.chat_template_content_format,
        return_tokens_as_token_ids=parsed_args.return_tokens_as_token_ids,
        enable_auto_tools=parsed_args.enable_auto_tools,
        tool_parser=parsed_args.tool_call_parser,
        enable_prompt_tokens_details=parsed_args.enable_prompt_tokens_details,
    )

def convert_paths_to_base_model_paths(path_str: str) -> List[BaseModelPath]:
    """Chuyển đổi chuỗi các đường dẫn thành danh sách các đối tượng BaseModelPath."""
    paths = path_str.split(',')
    base_model_paths = [BaseModelPath(name=f"model{i+1}", model_path=path) for i, path in enumerate(paths)]
    return base_model_paths

# Sử dụng build_app để tạox model
model_paths_str = "path/to/your/model1,path/to/your/model2"
base_model_paths = convert_paths_to_base_model_paths(model_paths_str)

model = build_app(
    {
        "model": os.environ['MODEL_ID'],
        "tensor-parallel-size": os.environ['TENSOR_PARALLELISM'],
        "pipeline-parallel-size": os.environ['PIPELINE_PARALLELISM']
    },
    base_model_paths
)