import logging
from typing import List
from fastapi import APIRouter, Depends, HTTPException, status


from app.presentation.api.dependencies import get_search_repository
from app.application.dto import CreateSearchRequestDTO, SearchRequestResponseDTO
from app.application.use_cases import CreateSearchRequestUseCase, DistributeSearchTasksUseCase

from ...schemas.search_schemas import SearchRequestSchema, SearchTaskSchema


logger = logging.getLogger(__name__)

router = APIRouter(prefix="/search", tags=["search"])

@router.post(
    "/requests", 
    response_model=SearchRequestResponseDTO, 
    status_code=status.HTTP_201_CREATED
)
async def create_search_request(
    request: CreateSearchRequestDTO,
    search_repository = Depends(get_search_repository)
):
    """Create a new search request"""
    try:
        # Create use case
        create_use_case = CreateSearchRequestUseCase(search_repository)
        # Execute use case
        result = await create_use_case.execute(request) 
        # Distribute tasks
        search_request = await search_repository.get_search_request(result.id)
        if search_request:
            distribute_use_case = DistributeSearchTasksUseCase(search_repository)
            await distribute_use_case.execute(search_request)
        
        return SearchRequestResponseDTO(**result.dict())
        
    except Exception as e:
        logger.error(f"Error creating search request: {e}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to create search request"
        )

# @router.post("/periodic", response_model=SearchRequestSchema, status_code=status.HTTP_201_CREATED)
# async def schedule_periodic_search(
#     request: CreateSearchRequestSchema,
#     search_repository = Depends(get_search_repository)
# ):
#     """Schedule a periodic search"""
#     try:
#         from ....application.use_cases.schedule_periodic_search import SchedulePeriodicSearchUseCase
        
#         schedule_use_case = SchedulePeriodicSearchUseCase(search_repository)
        
#         search_request = await schedule_use_case.schedule_periodic_search(
#             keywords=request.keywords,
#             platforms=request.platforms,
#             user_id=request.user_id
#         )
        
#         return SearchRequestSchema(
#             id=search_request.id,
#             keywords=search_request.keywords,
#             platforms=search_request.platforms,
#             search_type=search_request.search_type,
#             status=search_request.status,
#             created_at=search_request.created_at,
#             user_id=search_request.user_id,
#             scheduled_at=search_request.scheduled_at
#         )
        
#     except Exception as e:
#         logger.error(f"Error scheduling periodic search: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail="Failed to schedule periodic search"
#         )

# @router.get("/requests/{request_id}/tasks", response_model=List[SearchTaskSchema])
# async def get_search_tasks(
#     request_id: str,
#     search_repository = Depends(get_search_repository)
# ):
#     """Get tasks for a search request"""
#     try:
#         tasks = await search_repository.get_tasks_by_request_id(request_id)
        
#         return [
#             SearchTaskSchema(
#                 id=task.id,
#                 search_request_id=task.search_request_id,
#                 platform=task.platform,
#                 keywords=task.keywords,
#                 status=task.status,
#                 created_at=task.created_at
#             )
#             for task in tasks
#         ]
        
#     except Exception as e:
#         logger.error(f"Error getting search tasks: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail="Failed to get search tasks"
#         )

# @router.get("/requests/{request_id}", response_model=SearchRequestSchema)
# async def get_search_request(
#     request_id: str,
#     search_repository = Depends(get_search_repository)
# ):
#     """Get search request by ID"""
#     try:
#         search_request = await search_repository.get_search_request(request_id)
#         if not search_request:
#             raise HTTPException(
#                 status_code=status.HTTP_404_NOT_FOUND,
#                 detail="Search request not found"
#             )
        
#         return SearchRequestSchema(
#             id=search_request.id,
#             keywords=search_request.keywords,
#             platforms=search_request.platforms,
#             search_type=search_request.search_type,
#             status=search_request.status,
#             created_at=search_request.created_at,
#             user_id=search_request.user_id,
#             scheduled_at=search_request.scheduled_at
#         )
        
#     except HTTPException:
#         raise
#     except Exception as e:
#         logger.error(f"Error getting search request: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail="Failed to get search request"
#         )

# @router.get("/requests", response_model=List[SearchRequestSchema])
# async def get_pending_requests(
#     search_repository = Depends(get_search_repository)
# ):
#     """Get all pending search requests"""
#     try:
#         requests = await search_repository.get_pending_requests()
        
#         return [
#             SearchRequestSchema(
#                 id=req.id,
#                 keywords=req.keywords,
#                 platforms=req.platforms,
#                 search_type=req.search_type,
#                 status=req.status,
#                 created_at=req.created_at,
#                 user_id=req.user_id,
#                 scheduled_at=req.scheduled_at
#             )
#             for req in requests
#         ]
        
#     except Exception as e:
#         logger.error(f"Error getting pending requests: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail="Failed to get pending requests"
#         )
 
# @router.delete("/requests/{request_id}")
# async def cancel_search_request(
#     request_id: str,
#     search_repository = Depends(get_search_repository)
# ):
#     """Cancel a search request"""
#     try:
#         search_request = await search_repository.get_search_request(request_id)
#         if not search_request:
#             raise HTTPException(
#                 status_code=status.HTTP_404_NOT_FOUND,
#                 detail="Search request not found"
#             )
        
#         search_request.status = SearchStatus.FAILED
#         await search_repository.update_search_request(search_request)
        
#         return {"message": "Search request cancelled successfully"}
        
#     except HTTPException:
#         raise
#     except Exception as e:
#         logger.error(f"Error cancelling search request: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail="Failed to cancel search request"
#         )