from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException, Request

from app.core.map_index_reader import MapIndexReader
from app.core.elastic_query_builder import ElasticQueryBuilder
from app.core.field_processor import FieldProcessor
from app.core.response_helper import ResponseHelper
from app.routes.v1.models import (
    SearchRequest,
    InsertRequest,
    UpdateByQueryRequest,
    DeleteByQueryRequest,
)


router = APIRouter(tags=["elasticsearch"])


def get_elastic_helper(request: Request):
    helper = getattr(request.app.state, "elastic_helper", None)
    if helper is None:
        raise RuntimeError("Elasticsearch helper not initialized")
    return helper


# New enhanced endpoints
@router.get("/indices/{type_name}/schema")
async def get_schema(type_name: str, request: Request):
    """Get complete schema information for a type."""
    reader = MapIndexReader(type_name)
    try:
        return {
            "success": True,
            "result": {
                "index_info": reader.get_index_info(),
                "query_config": reader.get_query_config(),
                "fields": {field: reader.get_field_metadata(field) for field in reader.list_fields()}
            }
        }
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(status_code=400, detail=str(exc))


@router.get("/indices/{type_name}/fields")
async def get_fields(type_name: str, request: Request):
    """Get field information for a type."""
    reader = MapIndexReader(type_name)
    try:
        return {
            "success": True,
            "result": {
                "all_fields": reader.list_fields(),
                "searchable_fields": reader.get_searchable_fields(),
                "sortable_fields": reader.get_sortable_fields(),
                "exportable_fields": [f for f in reader.list_fields() if reader.get_export_state(f)],
                "array_fields": reader.get_array_fields(),
                "object_fields": reader.get_object_fields(),
                "date_fields": reader.get_date_fields(),
                "numeric_fields": reader.get_numeric_fields(),
                "boolean_fields": reader.get_boolean_fields(),
                "vector_fields": reader.get_vector_fields()
            }
        }
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(status_code=400, detail=str(exc))


@router.get("/indices/{type_name}/fields/{field_name}")
async def get_field_info(type_name: str, field_name: str, request: Request):
    """Get detailed information for a specific field."""
    reader = MapIndexReader(type_name)
    try:
        field_meta = reader.get_field_meta(field_name)
        return {
            "success": True,
            "result": {
                "field_name": field_name,
                "metadata": reader.get_field_metadata(field_name),
                # "label": reader.get_field_label(field_name),
                "validation": reader.validate_field_configuration(field_name),
                "join_processes": reader.get_join_processes(field_name),
                "processed_fields": reader.get_processed_fields(field_name)
            }
        }
    except KeyError:
        raise HTTPException(status_code=404, detail=f"Field '{field_name}' not found")
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(status_code=400, detail=str(exc))


@router.post("/indices/{type_name}/validate")
async def validate_document(type_name: str, document: dict, request: Request):
    """Validate a document against the schema."""
    reader = MapIndexReader(type_name)
    field_processor = FieldProcessor(reader)
    
    try:
        validation_result = field_processor.validate_document(document)
        return {
            "success": True,
            "result": validation_result
        }
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(status_code=400, detail=str(exc))


# @router.post("/indices/{type_name}/process")
# async def process_document(type_name: str, document: dict, request: Request):
#     """Process a document based on field configurations."""
#     reader = MapIndexReader(type_name)
#     field_processor = FieldProcessor(reader)
    
#     try:
#         processed_doc = field_processor.process_joinning_document(document)
#         return {
#             "success": True,
#             "result": processed_doc
#         }
#     except Exception as exc:  # noqa: BLE001
#         raise HTTPException(status_code=400, detail=str(exc))


@router.get("/indices/{type_name}/advanced-tags")
async def get_advanced_tags(type_name: str, request: Request):
    """Get advanced search tags configuration."""
    reader = MapIndexReader(type_name)
    try:
        return {
            "success": True,
            "result": {
                "tags": reader.get_search_advance_tags(),
                "tag_names": reader.list_advanced_tags(),
                "collapse_fields": reader.get_collapse_fields()
            }
        }
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(status_code=400, detail=str(exc))


# @router.get("/indices/{type_name}/labels")
# async def get_field_labels(type_name: str, request: Request):
#     """Get field labels mapping."""
#     reader = MapIndexReader(type_name)
#     try:
#         labels = {}
#         for field in reader.list_fields():
#             label = reader.get_field_label(field)
#             if label:
#                 labels[field] = label
        
#         return {
#             "success": True,
#             "result": labels
#         }
#     except Exception as exc:  # noqa: BLE001
#         raise HTTPException(status_code=400, detail=str(exc))