from typing import List, Optional, Tuple, Type, overload

import pytest
from transformers import (AutoConfig, AutoModelForVision2Seq, AutoTokenizer,
                          BatchEncoding)

from aphrodite.common.sequence import SampleLogprobs
from aphrodite.multimodal.utils import rescale_image_size

from ....conftest import (IMAGE_ASSETS, AphroditeRunner, HfRunner,
                          PromptImageInput, _ImageAssets)
from ...utils import check_logprobs_close

_LIMIT_IMAGE_PER_PROMPT = 3

HF_IMAGE_PROMPTS = IMAGE_ASSETS.prompts(
    {
        "stop_sign": "<|image|><|begin_of_text|>The meaning of the image is",
        "cherry_blossom": "<|image|><|begin_of_text|>The city is",
    }
)

text_only_prompts = [
    "The color of the sky is blue but sometimes it can also be",
]

models = [
    "meta-llama/Llama-3.2-11B-Vision-Instruct",
]


def aphrodite_to_hf_output(
    aphrodite_output: Tuple[List[int], str, Optional[SampleLogprobs]],
    model: str,
):
    """Sanitize aphrodite output to be comparable with hf output."""
    output_ids, output_str, out_logprobs = aphrodite_output

    config = AutoConfig.from_pretrained(model)
    image_token_id = config.image_token_index

    tokenizer = AutoTokenizer.from_pretrained(model)
    eos_token_id = tokenizer.eos_token_id

    hf_output_ids = [
        token_id
        for idx, token_id in enumerate(output_ids)
        if token_id != image_token_id or output_ids[idx - 1] != image_token_id
    ]

    hf_output_str = output_str
    if hf_output_ids[-1] == eos_token_id:
        hf_output_str = hf_output_str + tokenizer.decode(eos_token_id)

    return hf_output_ids, hf_output_str, out_logprobs


def _get_inputs(
    image_assets: _ImageAssets,
    *,
    size_factors: Optional[List[float]] = None,
    sizes: Optional[List[Tuple[int, int]]] = None,
) -> List[Tuple[List[str], PromptImageInput]]:
    images = [asset.pil_image for asset in image_assets]

    if size_factors is not None:
        inputs_per_image = [
            (
                [prompt for _ in size_factors],
                [rescale_image_size(image, factor) for factor in size_factors],
            )
            for image, prompt in zip(images, HF_IMAGE_PROMPTS)
        ]
    elif sizes is not None:
        inputs_per_image = [
            (
                [
                    prompt if size is not None else text_only_prompts[0]
                    for size in sizes
                ],
                [
                    image.resize(size) if size is not None else None
                    for size in sizes
                ],
            )
            for image, prompt in zip(images, HF_IMAGE_PROMPTS)
        ]
        if len(sizes) == 0:
            inputs_per_image.append(
                (text_only_prompts, [None] * len(text_only_prompts))
            )
    else:
        raise ValueError("You must provide either `size_factors` or `sizes`")

    return inputs_per_image


@overload
def run_test(
    hf_runner: Type[HfRunner],
    aphrodite_runner: Type[AphroditeRunner],
    image_assets: _ImageAssets,
    model: str,
    *,
    size_factors: List[float],
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tensor_parallel_size: int,
    distributed_executor_backend: Optional[str] = None,
):
    ...


@overload
def run_test(
    hf_runner: Type[HfRunner],
    aphrodite_runner: Type[AphroditeRunner],
    image_assets: _ImageAssets,
    model: str,
    *,
    sizes: List[Tuple[int, int]],
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tensor_parallel_size: int,
    distributed_executor_backend: Optional[str] = None,
):
    ...


def run_test(
    hf_runner: Type[HfRunner],
    aphrodite_runner: Type[AphroditeRunner],
    image_assets: _ImageAssets,
    model: str,
    *,
    size_factors: Optional[List[float]] = None,
    sizes: Optional[List[Tuple[int, int]]] = None,
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tensor_parallel_size: int,
    distributed_executor_backend: Optional[str] = None,
):
    _run_test(
        hf_runner,
        aphrodite_runner,
        _get_inputs(image_assets, size_factors=size_factors, sizes=sizes),
        model,
        dtype=dtype,
        max_tokens=max_tokens,
        num_logprobs=num_logprobs,
        tensor_parallel_size=tensor_parallel_size,
        distributed_executor_backend=distributed_executor_backend,
    )


def _run_test(
    hf_runner: Type[HfRunner],
    aphrodite_runner: Type[AphroditeRunner],
    inputs: List[Tuple[List[str], PromptImageInput]],
    model: str,
    *,
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tensor_parallel_size: int,
    distributed_executor_backend: Optional[str] = None,
):
    """Inference result should be the same between hf and aphrodite.

    All the image fixtures for the test are from IMAGE_ASSETS.
    For huggingface runner, we provide the PIL images as input.
    For aphrodite runner, we provide MultiModalDataDict objects
    and corresponding MultiModalConfig as input.
    Note, the text input is also adjusted to abide by aphrodite contract.
    The text output is sanitized to be able to compare with hf.
    """
    # NOTE: take care of the order. run Aphrodite first, and then run HF.
    # Aphrodite needs a fresh new process without cuda initialization.
    # if we run HF first, the cuda initialization will be done and it
    # will hurt multiprocessing backend with fork method (the default method).

    # max_model_len should be greater than image_feature_size
    with aphrodite_runner(
        model,
        dtype=dtype,
        max_model_len=4096,
        max_num_seqs=2,
        tensor_parallel_size=tensor_parallel_size,
        distributed_executor_backend=distributed_executor_backend,
        enforce_eager=True,
        limit_mm_per_prompt={"image": _LIMIT_IMAGE_PER_PROMPT},
    ) as aphrodite_model:
        aphrodite_outputs_per_image = [
            aphrodite_model.generate_greedy_logprobs(
                prompts, max_tokens, num_logprobs=num_logprobs, images=images
            )
            for prompts, images in inputs
        ]

    def process(hf_inputs: BatchEncoding):
        return hf_inputs

    with hf_runner(
        model,
        dtype=dtype,
        model_kwargs={"device_map": "auto"},
        postprocess_inputs=process,
        auto_cls=AutoModelForVision2Seq,
    ) as hf_model:
        hf_outputs_per_image = [
            hf_model.generate_greedy_logprobs_limit(
                prompts, max_tokens, num_logprobs=num_logprobs, images=images
            )
            for prompts, images in inputs
        ]

    for hf_outputs, aphrodite_outputs in zip(
        hf_outputs_per_image, aphrodite_outputs_per_image
    ):
        check_logprobs_close(
            outputs_0_lst=hf_outputs,
            outputs_1_lst=[
                aphrodite_to_hf_output(aphrodite_output, model)
                for aphrodite_output in aphrodite_outputs
            ],
            name_0="hf",
            name_1="aphrodite",
        )


@pytest.mark.parametrize("model", models)
@pytest.mark.parametrize(
    "sizes",
    [
        # Text only
        [],
        # Single-size
        [(512, 512)],
        # Single-size, batched
        [(512, 512), (512, 512), (512, 512)],
        # Multi-size, batched
        [
            (512, 512),
            (1024, 512),
            (1536, 512),
            (2048, 512),
            (512, 1024),
            (1024, 1024),
            (512, 1536),
            (512, 2028),
        ],
        # Multi-size, batched, including text only
        [
            (512, 512),
            (1024, 512),
            (1536, 512),
            (2048, 512),
            (512, 1024),
            (1024, 1024),
            (512, 1536),
            (512, 2028),
            None,
        ],
        # mllama has 8 possible aspect ratios, carefully set the sizes
        # to cover all of them
    ],
)
@pytest.mark.parametrize("dtype", ["bfloat16"])
@pytest.mark.parametrize("max_tokens", [128])
@pytest.mark.parametrize("num_logprobs", [5])
def test_models_single_leading_image(
    hf_runner,
    aphrodite_runner,
    image_assets,
    model,
    sizes,
    dtype,
    max_tokens,
    num_logprobs,
) -> None:
    run_test(
        hf_runner,
        aphrodite_runner,
        image_assets,
        model,
        sizes=sizes,
        dtype=dtype,
        max_tokens=max_tokens,
        num_logprobs=num_logprobs,
        tensor_parallel_size=1,
    )


@pytest.mark.parametrize("model", models)
@pytest.mark.parametrize("dtype", ["bfloat16"])
@pytest.mark.parametrize("max_tokens", [128])
@pytest.mark.parametrize("num_logprobs", [5])
def test_models_multi_leading_images(
    hf_runner,
    aphrodite_runner,
    image_assets,
    model,
    dtype,
    max_tokens,
    num_logprobs,
) -> None:
    stop_sign = image_assets[0].pil_image
    cherry_blossom = image_assets[1].pil_image

    inputs = [
        (
            [
                "<|image|><|image|><|begin_of_text|>Describe 2 images.",  # noqa: E501
                "<|image|><|image|><|begin_of_text|>Describe 2 images.",  # noqa: E501
                "<|image|><|image|><|image|><|begin_of_text|>Describe 3 images.",  # noqa: E501
            ],
            [
                [stop_sign, cherry_blossom],
                # Images with different sizes.
                [
                    stop_sign.resize((512, 512)),
                    stop_sign,
                ],
                [
                    stop_sign,
                    stop_sign.resize((512, 1536)),
                    cherry_blossom.resize((512, 1024)),
                ],
            ],
        )
    ]

    _run_test(
        hf_runner,
        aphrodite_runner,
        inputs,
        model,
        dtype=dtype,
        max_tokens=max_tokens,
        num_logprobs=num_logprobs,
        tensor_parallel_size=1,
    )


@pytest.mark.parametrize("model", models)
@pytest.mark.parametrize("dtype", ["bfloat16"])
@pytest.mark.parametrize("max_tokens", [128])
@pytest.mark.parametrize("num_logprobs", [5])
def test_models_interleaved_images(
    hf_runner,
    aphrodite_runner,
    image_assets,
    model,
    dtype,
    max_tokens,
    num_logprobs,
) -> None:
    stop_sign = image_assets[0].pil_image
    cherry_blossom = image_assets[1].pil_image

    inputs = [
        (
            [
                "<|begin_of_text|>The content of the image <|image|> is",  # noqa: E501
                "<|begin_of_text|>Between the first image <|image|> and the second image<|image|>, "  # noqa: E501
                "which is a stop sign and which is a cherry blossom?",  # noqa: E501
            ],
            [
                [stop_sign],
                [stop_sign, cherry_blossom],
            ],
        )
    ]

    _run_test(
        hf_runner,
        aphrodite_runner,
        inputs,
        model,
        dtype=dtype,
        max_tokens=max_tokens,
        num_logprobs=num_logprobs,
        tensor_parallel_size=1,
    )
