import re
import json
from config import FALLBACK_AMOUNT_REGEX, CURRENCY_SYMBOLS # Import regex and symbols

def parse_entities(entities, full_text: str):
    """
    Extracts amount, currency, and item description from NER entities and full text.

    Args:
        entities: List of dictionaries from the NER pipeline.
        full_text: The original input text string.

    Returns:
        A tuple: (amount, currency, item)
    """
    amount, currency, item = None, None, None
    potential_amounts = []

    # 1. Use the FALLBACK_AMOUNT_REGEX on the full text first - it's often more reliable
    #    Regex groups:
    #    1: Symbol/Code before number ($, EUR, etc.)
    #    2: Number when symbol/code is before
    #    3: Number when symbol/code is after
    #    4: Symbol/Code after number (rs, dollars, etc.)
    #    5: Standalone number
    for match in FALLBACK_AMOUNT_REGEX.finditer(full_text):
        num_str = None
        curr_symbol = None
        curr_code = None

        if match.group(1) and match.group(2): # Symbol/Code before
            curr_symbol = match.group(1)
            num_str = match.group(2)
        elif match.group(3) and match.group(4): # Symbol/Code after
            num_str = match.group(3)
            curr_code = match.group(4)
        elif match.group(5) and not match.group(1) and not match.group(4): # Standalone number
             num_str = match.group(5)

        if num_str:
            try:
                value = float(num_str.replace(",", ""))
                # Basic validation: avoid huge numbers unless they have decimals (might be IDs)
                if value < 1_000_000 or '.' in num_str:
                    potential_amounts.append({
                        "value": value,
                        "currency_symbol": curr_symbol,
                        "currency_code": curr_code,
                        "match_obj": match # Store match object for position info later if needed
                    })
            except ValueError:
                continue # Ignore invalid numbers like "1,2,3"

    # 2. Determine Amount and Currency from regex matches
    if potential_amounts:
        # Prioritize matches that included a currency symbol/code
        currency_matches = [p for p in potential_amounts if p["currency_symbol"] or p["currency_code"]]
        if currency_matches:
            # Often the largest value with currency is the main one
            best_match = max(currency_matches, key=lambda x: x["value"])
            amount = best_match["value"]
            # Determine currency from symbol/code
            symbol = best_match["currency_symbol"]
            code = best_match["currency_code"]
            if symbol:
                if "₹" in symbol: currency = "INR"
                elif "$" in symbol: currency = "USD"
                elif "€" in symbol: currency = "EUR"
                elif "£" in symbol: currency = "GBP"
            elif code:
                code_lower = code.lower()
                if code_lower in ["inr", "rs", "rupees"]: currency = "INR"
                elif code_lower in ["usd", "dollars"]: currency = "USD"
                elif code_lower in ["eur", "euros"]: currency = "EUR"
                elif code_lower in ["gbp", "pounds"]: currency = "GBP"
        else:
            # If no currency found, take the largest standalone number as amount
            best_match = max(potential_amounts, key=lambda x: x["value"])
            amount = best_match["value"]
            currency = None # Explicitly None if not found

    # 3. Extract Item using NER entities (excluding amounts/currency)
    item_parts = []
    if entities:
        # Get text segments identified as potential amounts by the regex
        amount_texts = set()
        for p in potential_amounts:
            amount_texts.add(p["match_obj"].group(0)) # Add the full matched string

        for entity in entities:
            entity_group = entity.get("entity_group", "")
            word = entity.get("word", "")

            # Skip if the entity word is part of a detected amount or is just a currency symbol
            if word in amount_texts or word in CURRENCY_SYMBOLS:
                continue

            # Skip if it's classified as MONEY by NER (already handled by regex)
            # Allow CARDINAL if it wasn't part of a regex match (e.g., quantity "2 coffees")
            if "MONEY" in entity_group:
                 continue

            # Include relevant entity types for item description
            if entity_group in ["MISC", "ORG", "PRODUCT", "EVENT", "WORK_OF_ART", "LOC", "PER", "CARDINAL", "QUANTITY"]:
                 # Clean up sub-word tokens like ##ing
                 cleaned_word = word.replace(" ##", "").strip()
                 if cleaned_word:
                    item_parts.append(cleaned_word)

    if item_parts:
        item = " ".join(item_parts).strip()
        # Further clean-up (optional): remove leading/trailing punctuation if desired
        item = re.sub(r"^[^\w]+|[^\w]+$", "", item)


    # 4. Final checks and return
    # If amount is found but currency is None, consider a default (optional, decided against for now)
    # if amount is not None and currency is None:
    #     currency = "INR" # Or keep as None

    print(f"Utils: Parsed-> Amount: {amount}, Currency: {currency}, Item: {item}")
    return amount, currency, item

# ... (keep parse_gemini_response as is) ...
def parse_gemini_response(response_text):
    """
    Parses a structured string response from Gemini (expected JSON-like).
    Example expected format:
    "{ \"type\": \"expense\", \"category\": \"Food\", \"amount\": 5.50, \"currency\": \"USD\", \"item\": \"coffee\" }"
    """
    try:
        # Clean the response text if it's wrapped in markdown code blocks
        response_text = re.sub(r"^```json\s*|\s*```$", "", response_text.strip())
        data = json.loads(response_text)
        return data
    except json.JSONDecodeError:
        print(f"Warning: Could not parse Gemini response: {response_text}")
        return None
    except Exception as e:
        print(f"Error parsing Gemini response: {e}")
        return None