"""
Field type definitions for the search engine configuration system.

This module defines all supported field types, analyzers, and their
corresponding Elasticsearch mapping configurations.
"""

from enum import Enum
from typing import Dict, Any, Optional
from dataclasses import dataclass


class FieldType(Enum):
    """Supported field types in the search engine."""
    TEXT = "text"
    KEYWORD = "keyword"
    TEXT_EMBEDDING = "text_embedding"
    IMAGE_EMBEDDING = "image_embedding"
    INT = "int"
    LONG = "long"
    FLOAT = "float"
    DOUBLE = "double"
    DATE = "date"
    BOOLEAN = "boolean"
    JSON = "json"


class AnalyzerType(Enum):
    """Supported analyzer types for text fields."""
    # E-commerce general analysis - Chinese
    CHINESE_ECOMMERCE = "index_ansj"
    CHINESE_ECOMMERCE_QUERY = "query_ansj"

    # Standard language analyzers
    ENGLISH = "english"
    ARABIC = "arabic"
    SPANISH = "spanish"
    RUSSIAN = "russian"
    JAPANESE = "japanese"

    # Standard analyzers
    STANDARD = "standard"
    KEYWORD = "keyword"


class SimilarityType(Enum):
    """Supported similarity algorithms for text fields."""
    BM25 = "BM25"
    BM25_CUSTOM = "BM25_custom"  # Modified BM25 with b=0.0, k1=0.0


@dataclass
class FieldConfig:
    """Configuration for a single field."""
    name: str
    field_type: FieldType
    analyzer: Optional[AnalyzerType] = None
    search_analyzer: Optional[AnalyzerType] = None
    required: bool = False
    multi_language: bool = False  # If true, field has language variants
    languages: Optional[list] = None  # ['zh', 'en', 'ru']
    boost: float = 1.0
    store: bool = False
    index: bool = True
    return_in_source: bool = True  # Whether to include this field in search result _source

    # For embedding fields
    embedding_dims: int = 1024
    embedding_similarity: str = "dot_product"  # dot_product, cosine, l2_norm

    # For nested fields (like image embeddings)
    nested: bool = False
    nested_properties: Optional[Dict[str, Any]] = None

    # Hybrid Keyword Text (HKText) support
    keyword_subfield: bool = False
    keyword_ignore_above: int = 256
    keyword_normalizer: Optional[str] = None  # For keyword subfield normalizer (e.g., "lowercase")


def get_es_mapping_for_field(field_config: FieldConfig) -> Dict[str, Any]:
    """
    Generate Elasticsearch mapping configuration for a field.

    Args:
        field_config: Field configuration object

    Returns:
        Dictionary containing ES mapping for the field
    """
    mapping = {}

    if field_config.field_type == FieldType.TEXT:
        mapping = {
            "type": "text",
            "store": field_config.store,
            "index": field_config.index
        }

        if field_config.analyzer:
            if field_config.analyzer == AnalyzerType.CHINESE_ECOMMERCE:
                mapping["analyzer"] = "index_ansj"
                mapping["search_analyzer"] = "query_ansj"
            elif field_config.analyzer == AnalyzerType.CHINESE_ECOMMERCE_QUERY:
                # If search_analyzer is explicitly set to CHINESE_ECOMMERCE_QUERY
                mapping["analyzer"] = "index_ansj"
                mapping["search_analyzer"] = "query_ansj"
            else:
                mapping["analyzer"] = field_config.analyzer.value

        if field_config.search_analyzer:
            if field_config.search_analyzer == AnalyzerType.CHINESE_ECOMMERCE_QUERY:
                mapping["search_analyzer"] = "query_ansj"
            else:
                mapping["search_analyzer"] = field_config.search_analyzer.value

        if field_config.keyword_subfield:
            mapping.setdefault("fields", {})
            keyword_field = {
                "type": "keyword",
                "ignore_above": field_config.keyword_ignore_above
            }
            if field_config.keyword_normalizer:
                keyword_field["normalizer"] = field_config.keyword_normalizer
            mapping["fields"]["keyword"] = keyword_field

    elif field_config.field_type == FieldType.KEYWORD:
        mapping = {
            "type": "keyword",
            "store": field_config.store,
            "index": field_config.index
        }

    elif field_config.field_type == FieldType.TEXT_EMBEDDING:
        mapping = {
            "type": "dense_vector",
            "dims": field_config.embedding_dims,
            "index": True,
            "similarity": field_config.embedding_similarity
        }

    elif field_config.field_type == FieldType.IMAGE_EMBEDDING:
        if field_config.nested:
            mapping = {
                "type": "nested",
                "properties": {
                    "vector": {
                        "type": "dense_vector",
                        "dims": field_config.embedding_dims,
                        "index": True,
                        "similarity": field_config.embedding_similarity
                    },
                    "url": {
                        "type": "text"
                    }
                }
            }
        else:
            # Simple vector field
            mapping = {
                "type": "dense_vector",
                "dims": field_config.embedding_dims,
                "index": True,
                "similarity": field_config.embedding_similarity
            }

    elif field_config.field_type in [FieldType.INT, FieldType.LONG]:
        mapping = {
            "type": "long",
            "store": field_config.store,
            "index": field_config.index
        }

    elif field_config.field_type in [FieldType.FLOAT, FieldType.DOUBLE]:
        mapping = {
            "type": "float",
            "store": field_config.store,
            "index": field_config.index
        }

    elif field_config.field_type == FieldType.DATE:
        mapping = {
            "type": "date",
            "store": field_config.store,
            "index": field_config.index
        }

    elif field_config.field_type == FieldType.BOOLEAN:
        mapping = {
            "type": "boolean",
            "store": field_config.store,
            "index": field_config.index
        }

    elif field_config.field_type == FieldType.JSON:
        if field_config.nested and field_config.nested_properties:
            # Nested type with properties (e.g., variants)
            mapping = {
                "type": "nested",
                "properties": {}
            }
            # Generate mappings for nested properties
            for prop_name, prop_config in field_config.nested_properties.items():
                prop_type = prop_config.get("type", "keyword")
                prop_mapping = {"type": prop_type}
                
                # Add analyzer for text fields
                if prop_type == "text" and "analyzer" in prop_config:
                    analyzer_str = prop_config["analyzer"]
                    # Convert chinese_ecommerce to index_ansj/query_ansj
                    if analyzer_str == "chinese_ecommerce":
                        prop_mapping["analyzer"] = "index_ansj"
                        prop_mapping["search_analyzer"] = "query_ansj"
                    else:
                        prop_mapping["analyzer"] = analyzer_str
                
                # Add other properties
                if "index" in prop_config:
                    prop_mapping["index"] = prop_config["index"]
                if "store" in prop_config:
                    prop_mapping["store"] = prop_config["store"]
                
                mapping["properties"][prop_name] = prop_mapping
        else:
            # Simple object type
            mapping = {
                "type": "object",
                "enabled": True
            }

    return mapping


def get_default_analyzers() -> Dict[str, Any]:
    """
    Get default analyzer definitions for the index.

    Returns:
        Dictionary of analyzer configurations
    """
    return {
        "analysis": {
            "analyzer": {
                "index_ansj": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": ["lowercase", "asciifolding"]
                },
                "query_ansj": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": ["lowercase", "asciifolding"]
                },
                "hanlp_index": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": ["lowercase", "asciifolding"]
                },
                "hanlp_standard": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": ["lowercase", "asciifolding"]
                }
            },
            "normalizer": {
                "lowercase": {
                    "type": "custom",
                    "filter": ["lowercase"]
                }
            }
        }
    }


def get_default_similarity() -> Dict[str, Any]:
    """
    Get default similarity configuration (modified BM25).

    Returns:
        Dictionary of similarity configurations
    """
    return {
        "similarity": {
            "default": {
                "type": "BM25",
                "b": 0.0,
                "k1": 0.0
            }
        }
    }


# Mapping of field type strings to FieldType enum
FIELD_TYPE_MAP = {
    "text": FieldType.TEXT,
    "TEXT": FieldType.TEXT,
    "HKText": FieldType.TEXT,
    "hktext": FieldType.TEXT,
    "HKTEXT": FieldType.TEXT,
    "keyword": FieldType.KEYWORD,
    "KEYWORD": FieldType.KEYWORD,
    "LITERAL": FieldType.KEYWORD,
    "text_embedding": FieldType.TEXT_EMBEDDING,
    "TEXT_EMBEDDING": FieldType.TEXT_EMBEDDING,
    "EMBEDDING": FieldType.TEXT_EMBEDDING,
    "image_embedding": FieldType.IMAGE_EMBEDDING,
    "IMAGE_EMBEDDING": FieldType.IMAGE_EMBEDDING,
    "int": FieldType.INT,
    "INT": FieldType.INT,
    "long": FieldType.LONG,
    "LONG": FieldType.LONG,
    "float": FieldType.FLOAT,
    "FLOAT": FieldType.FLOAT,
    "double": FieldType.DOUBLE,
    "DOUBLE": FieldType.DOUBLE,
    "date": FieldType.DATE,
    "DATE": FieldType.DATE,
    "boolean": FieldType.BOOLEAN,
    "BOOLEAN": FieldType.BOOLEAN,
    "json": FieldType.JSON,
    "JSON": FieldType.JSON,
}


# Mapping of analyzer strings to AnalyzerType enum
ANALYZER_MAP = {
    "chinese": AnalyzerType.CHINESE_ECOMMERCE,
    "chinese_ecommerce": AnalyzerType.CHINESE_ECOMMERCE,
    "index_ansj": AnalyzerType.CHINESE_ECOMMERCE,
    "hanlp_index": AnalyzerType.CHINESE_ECOMMERCE,  # Alias for index_ansj
    "hanlp_standard": AnalyzerType.CHINESE_ECOMMERCE_QUERY,  # Alias for query_ansj
    "query_ansj": AnalyzerType.CHINESE_ECOMMERCE_QUERY,
    "english": AnalyzerType.ENGLISH,
    "arabic": AnalyzerType.ARABIC,
    "spanish": AnalyzerType.SPANISH,
    "russian": AnalyzerType.RUSSIAN,
    "japanese": AnalyzerType.JAPANESE,
    "standard": AnalyzerType.STANDARD,
    "keyword": AnalyzerType.KEYWORD,
}