"""
Normal testing - Single search (no multisearch)
"""

import typesense

api_key = "<API KEY HERE>"

# Initialize Typesense client
typesense_client = typesense.Client(
    {
        "api_key": api_key,  # Read-only key
        "nodes": [{"host": "lironsp3wdyeqj1up-1.a1.typesense.net", "port": "443", "protocol": "https"}],
        "connection_timeout_seconds": 20,
    }
)

# Query configuration
query = "Marjorie Taylor Greene"
pages_left = 25
group_size = 80
num_words = len(query.split())

# Define query fields based on query type
vector_distance_threshold = 0.18
vector_alpha = 0.55

if num_words >= 3:
    vector_distance_threshold = 0.3

# Main query fields for regular search
main_query_fields = [
    {"field": "computed_title", "infix": "always", "weight": 16},
    {"field": "event_title", "infix": "fallback", "weight": 15},
    {"field": "alt_titles", "infix": "fallback", "weight": 15},
    {"field": "series_title", "infix": "fallback", "weight": 14},
    {"field": "market_titles", "infix": "fallback", "weight": 14},
    {"field": "structured_targets_names", "infix": "fallback", "weight": 14},
    {"field": "series_keywords", "infix": "off", "weight": 4},
    {"field": "series_categories", "infix": "off", "weight": 4},
    {"field": "series_subcategories", "infix": "off", "weight": 4},
    # {"field": "embedding", "infix": "off", "weight": 0},
]

# Only include ticker fields if query has 1 word
if num_words == 1:
    main_query_fields.extend(
        [
            {"field": "series_ticker", "infix": "fallback", "weight": 3},
            {"field": "event_ticker", "infix": "always", "weight": 3},
        ]
    )


# Helper functions to build query strings
def build_query_by_string(fields):
    return ",".join([f["field"] for f in fields])


def build_infix_string(fields):
    return ",".join([f["infix"] for f in fields])


def build_query_by_weights_string(fields):
    return ",".join([str(f["weight"]) for f in fields])


def print_grouped_hits_with_highlights(results, query, target_ticker="KXPRESNOMR", max_groups=10, max_hits_per_group=5):
    """Print formatted grouped search results with highlights for target ticker."""
    if "grouped_hits" not in results:
        return

    for i, group in enumerate(results["grouped_hits"][:max_groups]):
        if not group["hits"]:
            continue

        series_ticker = group["group_key"][0] if group["group_key"] else "N/A"
        series_title = group["hits"][0]["document"].get("series_title", "N/A")
        found = group.get("found", 0)

        print(f"{i + 1}: [{series_ticker}] - {series_title} (found: {found})")

        # Print each event hit in the group
        for hit in group["hits"][:max_hits_per_group]:
            event_title = hit["document"].get("event_title", "N/A")
            event_ticker = hit["document"].get("event_ticker", "N/A")
            text_match = hit.get("text_match", "N/A")
            engagement_score = hit["document"].get("engagement_score", 0)
            vector_distance = hit.get("vector_distance", "N/A")
            typo = hit.get("text_match_info")

            print(
                f"    {typo} {event_title} | {event_ticker} | TM: {text_match} | ES: {engagement_score:.2f} | V: {vector_distance}"
            )
            
            # Print highlights for target ticker
            if event_ticker.startswith(target_ticker):
                print(f"    >>> Query: {query}")
                for highlight in hit.get("highlights", []):
                    if highlight.get("matched_tokens"):
                        print(f"    >>> {highlight.get('field')}: {highlight.get('matched_tokens')}")
        print()


# Build vector query string
vector_query_str = f"embedding:([],distance_threshold: {vector_distance_threshold},alpha: {vector_alpha})"

# Create search parameters
search_params = {
    "q": query,
    "use_cache": True,
    "cache_ttl": 60,  # 1 minute cache
    "query_by": build_query_by_string(main_query_fields),
    "infix": build_infix_string(main_query_fields),
    "query_by_weights": build_query_by_weights_string(main_query_fields),
    "drop_tokens_mode": "both_last_tokens:3",
    "typo_tokens_threshold": 30,
    "min_len_1typo": 5,
    "min_len_2typo": 8,
    # "vector_query": vector_query_str,
    # "filter_by": "",  # All markets (or use "has_open_markets:true" for open markets only)
    "sort_by": "_text_match:desc,engagement_score:desc",
    "group_by": "series_ticker",
    "group_limit": group_size,
    "page": 1,
    "per_page": pages_left,
    "prioritize_exact_match": True,
    "text_match_type": "max_weight",
    "include_fields": "has_open_markets,computed_title,series_title,event_title,market_titles,structured_targets_names,event_ticker,series_ticker,engagement_score,series_categories,series_subcategories,series_keywords,search_time_ms",
    "highlight_fields": "computed_title,event_title,alt_titles,series_title,market_titles,structured_targets_names,series_keywords,series_categories,series_subcategories",
    "enable_overrides": True,
}

# Perform single search
results = typesense_client.collections["events_search_v9"].documents.search(search_params)


print(f"Search found: {results.get('found', 0)} results\n")

# Display grouped hits with highlights for KXPRESNOMR
print_grouped_hits_with_highlights(results, query)