"""
GAMA INK SERVICE SRL store profile for OCR extraction.

Toner refill and printer supplies store.
"""

import re
from decimal import Decimal, InvalidOperation
from typing import List, Dict, Any

from .base import BaseStoreProfile
from . import ProfileRegistry


@ProfileRegistry.register
class GamaInkProfile(BaseStoreProfile):
    """
    GAMA INK SERVICE SRL - standard TVA profile.

    Key characteristics:
    - Standard TVA format (single rate, any percentage)
    - Service-based (toner refill, printer supplies)
    - CARD payment typical
    """

    CUI_LIST = ["17741882"]
    NAME_PATTERNS = ["GAMA INK", "GAMA", "GAMAINK", "GAMA INK SERVICE"]
    STORE_NAME = "GAMA INK SERVICE SRL"

    # Standard TVA patterns (flexible - accepts any rate)
    TVA_PATTERNS = [
        # "TVA A: XX% = YY,YY" or "TVA-A XX% YY,YY"
        r'TVA\s*[-:]?\s*([A-D])\s*:?\s*(\d{1,2})\s*%\s*[=:]?\s*([\d.,]+)',
        # "A - XX,XX% = YY,YY"
        r'([A-D])\s*[-:]\s*(\d{1,2})[.,]?\d{0,2}\s*%\s*[=:]?\s*([\d.,]+)',
        # "TVA XX% YY,YY" (simple format without code)
        r'TVA\s+(\d{1,2})\s*%\s*([\d.,]+)',
        # "TVA: YY,YY" (amount only, percent inferred)
        r'TVA\s*:?\s*([\d.,]+)\s*(?:LEI|RON)?',
    ]

    def extract_tva_entries(self, text: str) -> List[dict]:
        """
        Extract TVA entries from receipt text.

        Args:
            text: Raw OCR text from receipt

        Returns:
            List of TVA entries with code, percent, and amount
        """
        entries = []
        seen = set()

        # Try coded patterns first (have both code and percent)
        for pattern in self.TVA_PATTERNS[:2]:
            for match in re.finditer(pattern, text, re.IGNORECASE):
                try:
                    code = match.group(1).upper()
                    percent = int(match.group(2))
                    amount = self._parse_decimal(match.group(3))

                    if amount and amount > 0:
                        entry_key = (code, percent)
                        if entry_key not in seen:
                            entries.append({
                                'code': code,
                                'percent': percent,
                                'amount': amount
                            })
                            seen.add(entry_key)
                except (ValueError, InvalidOperation, IndexError):
                    continue

        # Fallback to simple format (percent + amount without code)
        if not entries:
            simple_pattern = self.TVA_PATTERNS[2]
            for match in re.finditer(simple_pattern, text, re.IGNORECASE):
                try:
                    percent = int(match.group(1))
                    amount = self._parse_decimal(match.group(2))

                    if amount and amount > 0:
                        entries.append({
                            'code': 'A',
                            'percent': percent,
                            'amount': amount
                        })
                        break
                except (ValueError, InvalidOperation):
                    continue

        return entries

    def get_validation_hints(self) -> Dict[str, Any]:
        """Return GAMA INK-specific validation hints."""
        return {
            "has_multi_rate_tva": False,
            "card_equals_total": True,
            "has_client_cui": False,
            "has_efactura": False,
            "is_non_vat_payer": False,
        }