import pytest
from pydantic import ValidationError


def test_loki_query_range_request_valid():
    from src.models.loki_queries import LokiQueryRangeRequest

    model = LokiQueryRangeRequest(
        query='{app="test"}',
        start="2024-01-01T00:00:00Z",
        end="2024-01-01T01:00:00Z",
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
    )

    assert model.query == '{app="test"}'
    assert model.start == "2024-01-01T00:00:00Z"
    assert model.end == "2024-01-01T01:00:00Z"
    assert model.cluster_id == "cluster-1"
    assert model.env == "prod"
    assert model.deploy_type == "dedicated"
    assert model.limit == 100
    assert model.direction == "backward"


def test_loki_query_range_request_with_all_params():
    from src.models.loki_queries import LokiQueryRangeRequest

    model = LokiQueryRangeRequest(
        query='{app="test"}',
        start="2024-01-01T00:00:00Z",
        end="2024-01-01T01:00:00Z",
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
        limit=500,
        direction="forward",
        step="1m",
    )

    assert model.limit == 500
    assert model.direction == "forward"
    assert model.step == "1m"


def test_loki_query_range_request_invalid_logql():
    from src.models.loki_queries import LokiQueryRangeRequest

    with pytest.raises(ValidationError) as exc_info:
        LokiQueryRangeRequest(
            query="invalid logql",
            start="2024-01-01T00:00:00Z",
            end="2024-01-01T01:00:00Z",
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
        )

    assert "must contain" in str(exc_info.value).lower() or "{}" in str(exc_info.value)


def test_loki_query_range_request_empty_timestamps():
    from src.models.loki_queries import LokiQueryRangeRequest

    with pytest.raises(ValidationError) as exc_info:
        LokiQueryRangeRequest(
            query='{app="test"}',
            start="",
            end="",
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
        )

    assert "empty" in str(exc_info.value).lower() or "required" in str(exc_info.value).lower()


def test_loki_query_range_request_limit_out_of_bounds():
    from src.models.loki_queries import LokiQueryRangeRequest

    with pytest.raises(ValidationError):
        LokiQueryRangeRequest(
            query='{app="test"}',
            start="2024-01-01T00:00:00Z",
            end="2024-01-01T01:00:00Z",
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
            limit=15000,
        )

    with pytest.raises(ValidationError):
        LokiQueryRangeRequest(
            query='{app="test"}',
            start="2024-01-01T00:00:00Z",
            end="2024-01-01T01:00:00Z",
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
            limit=0,
        )


def test_loki_query_instant_request_valid():
    from src.models.loki_queries import LokiQueryInstantRequest

    model = LokiQueryInstantRequest(
        query='{app="test"}',
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
    )

    assert model.query == '{app="test"}'
    assert model.cluster_id == "cluster-1"
    assert model.env == "prod"
    assert model.time is None


def test_loki_query_instant_request_with_time():
    from src.models.loki_queries import LokiQueryInstantRequest

    model = LokiQueryInstantRequest(
        query='{app="test"}',
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
        time="2024-01-01T00:00:00Z",
    )

    assert model.time == "2024-01-01T00:00:00Z"


def test_loki_labels_request_valid():
    from src.models.loki_queries import LokiLabelsRequest

    model = LokiLabelsRequest(
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
    )

    assert model.cluster_id == "cluster-1"
    assert model.env == "prod"
    assert model.deploy_type == "dedicated"
    assert model.start is None
    assert model.end is None
    assert model.query is None


def test_loki_label_values_request_valid():
    from src.models.loki_queries import LokiLabelValuesRequest

    model = LokiLabelValuesRequest(
        label_name="app",
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
    )

    assert model.label_name == "app"
    assert model.cluster_id == "cluster-1"


def test_loki_label_values_request_empty_label_name():
    from src.models.loki_queries import LokiLabelValuesRequest

    with pytest.raises(ValidationError) as exc_info:
        LokiLabelValuesRequest(
            label_name="",
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
        )

    assert "empty" in str(exc_info.value).lower() or "required" in str(exc_info.value).lower()


def test_loki_series_request_valid():
    from src.models.loki_queries import LokiSeriesRequest

    model = LokiSeriesRequest(
        match=['{app="test"}', '{namespace="default"}'],
        cluster_id="cluster-1",
        env="prod",
        deploy_type="dedicated",
    )

    assert model.match == ['{app="test"}', '{namespace="default"}']
    assert model.cluster_id == "cluster-1"


def test_loki_series_request_empty_match():
    from src.models.loki_queries import LokiSeriesRequest

    with pytest.raises(ValidationError) as exc_info:
        LokiSeriesRequest(
            match=[],
            cluster_id="cluster-1",
            env="prod",
            deploy_type="dedicated",
        )

    assert "at least" in str(exc_info.value).lower() or "min" in str(exc_info.value).lower()