from typing import Any, Dict, List, Optional, Tuple

import pydantic
# imports
import pytest  # used for our unit tests
from src.deepgram.core.query_encoder import encode_query

# unit tests

# ---- Basic Test Cases ----

def test_encode_query_none():
    # Should return None for None input
    codeflash_output = encode_query(None) # 601ns -> 640ns (6.09% slower)

def test_encode_query_empty_dict():
    # Should return empty list for empty dict
    codeflash_output = encode_query({}) # 1.11μs -> 1.41μs (21.3% slower)

def test_encode_query_simple_flat_dict():
    # Should encode a flat dict with primitive values
    query = {"a": 1, "b": "foo", "c": True}
    expected = [("a", 1), ("b", "foo"), ("c", True)]
    codeflash_output = sorted(encode_query(query)) # 4.67μs -> 4.13μs (12.8% faster)

def test_encode_query_list_of_primitives():
    # Should encode a list of primitives under a key
    query = {"tags": ["x", "y", "z"]}
    expected = [("tags", "x"), ("tags", "y"), ("tags", "z")]
    codeflash_output = sorted(encode_query(query)) # 4.27μs -> 3.90μs (9.47% faster)

def test_encode_query_nested_dict():
    # Should encode a nested dict
    query = {"outer": {"inner": 42}}
    expected = [("outer[inner]", 42)]
    codeflash_output = encode_query(query) # 4.37μs -> 3.94μs (10.9% faster)

def test_encode_query_list_of_dicts():
    # Should encode a list of dicts under a key
    query = {"items": [{"id": 1}, {"id": 2}]}
    expected = [("items[id]", 1), ("items[id]", 2)]
    codeflash_output = sorted(encode_query(query)) # 7.46μs -> 6.48μs (15.3% faster)

def test_encode_query_mixed_list():
    # Should encode a list with mixed primitives and dicts
    query = {"data": [1, {"a": "b"}, 2]}
    expected = [("data", 1), ("data[a]", "b"), ("data", 2)]
    codeflash_output = sorted(encode_query(query)) # 6.69μs -> 5.98μs (11.9% faster)



def test_encode_query_empty_list():
    # Should handle empty list under a key
    query = {"arr": []}
    expected = []
    codeflash_output = encode_query(query) # 3.28μs -> 2.99μs (9.59% faster)

def test_encode_query_empty_dict_in_list():
    # Should handle empty dict in a list
    query = {"arr": [{}]}
    expected = []
    codeflash_output = encode_query(query) # 4.78μs -> 4.20μs (14.0% faster)

def test_encode_query_nested_empty_dict():
    # Should handle nested empty dict
    query = {"outer": {"inner": {}}}
    expected = []
    codeflash_output = encode_query(query) # 4.40μs -> 4.12μs (6.80% faster)

def test_encode_query_deeply_nested_dict():
    # Should encode a dict nested several layers deep
    query = {"a": {"b": {"c": {"d": 99}}}}
    expected = [("a[b][c][d]", 99)]
    codeflash_output = encode_query(query) # 5.87μs -> 5.49μs (6.93% faster)

def test_encode_query_list_of_lists():
    # Should handle a list of lists under a key
    query = {"matrix": [[1, 2], [3, 4]]}
    expected = [("matrix", 1), ("matrix", 2), ("matrix", 3), ("matrix", 4)]
    codeflash_output = sorted(encode_query(query)) # 3.83μs -> 3.72μs (3.01% faster)

def test_encode_query_none_value():
    # Should encode None value as-is
    query = {"nada": None}
    expected = [("nada", None)]
    codeflash_output = encode_query(query) # 3.10μs -> 2.91μs (6.67% faster)

def test_encode_query_dict_with_bool_and_none():
    # Should encode bool and None values correctly
    query = {"flag": True, "missing": None}
    expected = [("flag", True), ("missing", None)]
    codeflash_output = sorted(encode_query(query)) # 3.98μs -> 3.75μs (5.97% faster)

def test_encode_query_dict_with_int_keys():
    # Should encode dicts with int keys (converted to str)
    query = {1: "one", 2: "two"}
    expected = [("1", "one"), ("2", "two")]
    codeflash_output = sorted(encode_query(query)) # 3.83μs -> 3.50μs (9.30% faster)

def test_encode_query_dict_with_special_chars():
    # Should encode keys with special characters
    query = {"a.b": {"c-d": 5}}
    expected = [("a.b[c-d]", 5)]
    codeflash_output = encode_query(query) # 4.28μs -> 3.99μs (7.24% faster)

def test_encode_query_dict_with_empty_string_key():
    # Should encode dict with empty string key
    query = {"": {"x": 1}}
    expected = [("[x]", 1)]
    # The key will be '[x]' because key_prefix is '' and k is 'x'
    codeflash_output = encode_query(query) # 4.30μs -> 3.97μs (8.35% faster)

def test_encode_query_dict_with_empty_string_value():
    # Should encode dict with empty string value
    query = {"foo": ""}
    expected = [("foo", "")]
    codeflash_output = encode_query(query) # 3.11μs -> 2.92μs (6.22% faster)


def test_encode_query_dict_with_list_of_dicts_and_primitives():
    # Should encode dict with list of dicts and primitives
    query = {"mixed": [{"x": 1}, 2, {"y": 3}]}
    expected = [("mixed[x]", 1), ("mixed", 2), ("mixed[y]", 3)]
    codeflash_output = sorted(encode_query(query)) # 8.20μs -> 7.13μs (15.1% faster)

# ---- Large Scale Test Cases ----

def test_encode_query_large_flat_dict():
    # Should handle a large flat dict
    query = {str(i): i for i in range(1000)}
    expected = [(str(i), i) for i in range(1000)]
    codeflash_output = encode_query(query); result = codeflash_output # 472μs -> 362μs (30.5% faster)

def test_encode_query_large_nested_dict():
    # Should handle a large nested dict
    query = {"outer": {str(i): i for i in range(500)}}
    expected = [("outer[" + str(i) + "]", i) for i in range(500)]
    codeflash_output = encode_query(query); result = codeflash_output # 130μs -> 132μs (1.24% slower)

def test_encode_query_large_list_of_dicts():
    # Should handle a large list of dicts
    query = {"items": [{"id": i} for i in range(500)]}
    expected = [("items[id]", i) for i in range(500)]
    codeflash_output = encode_query(query); result = codeflash_output # 667μs -> 419μs (59.4% faster)

def test_encode_query_large_list_of_primitives():
    # Should handle a large list of primitives
    query = {"nums": list(range(1000))}
    expected = [("nums", i) for i in range(1000)]
    codeflash_output = encode_query(query); result = codeflash_output # 232μs -> 116μs (100% faster)



#------------------------------------------------
from src.deepgram.core.query_encoder import encode_query

def test_encode_query():
    encode_query({'': {}})

def test_encode_query_2():
    encode_query(None)