from fastapi.param_functions import Query
from fastapi import APIRouter, Depends
from sqlalchemy.orm.session import Session
from src.core.database import get_session
from src.apps.base.schemas.responses import BaseResponse,SuccessResponse
from src.apps.auth.utils.auth import get_current_user
from src.apps.users.schemas.user_common import UserSchema
from src.apps.site_masters.schemas.site_master_requests import SiteMasterCreateRequestSchema
from src.apps.site_masters import services


router = APIRouter()


@router.get("/", name="Fetch All Master Data", response_model=BaseResponse)
async def get_master_entries(
    db: Session = Depends(get_session),
    keys: str = Query(
        default="",
        description="Specific master data to be fetched by its key as a comma separated list. Eg: ?keys=country,state",
    ),
    search: str = Query(
        default=None,
        description="Additional related fields that are requested. Could be any of ...",
    ),
    # current_user: UserSchema = Depends(get_current_user),
) -> BaseResponse:
    """
    Call this API to list all available master data of requesting user

    Query Param 'keys' is a comma separated string of master data ids. Eg: ?keys=business_profile,job_type

    On successfull execution the API would return '200 OK' JSON response of the following format
    ```
    {
        "data": {
            "business_locale": [
                {
                    "value": "en_US",
                    "key": "business_locale",
                    "group": "Locale",
                    "parent_id": null,
                    "id": 13,
                    "label": "United States",
                    "display_order": 0
                }
            ],
            "business_region": [
                {
                    "value": "US",
                    "key": "business_region",
                    "group": "Locale",
                    "parent_id": null,
                    "id": 17,
                    "label": "United States",
                    "display_order": 0
                }
            ]
        },
        "status_code": 200,
        "success": true,
        "message": "Request handled successfully"
    }
    ```
    """
    response = await services.list_master_entries(
        db=db, keys=keys, search=search
    )
    print("---fetch data----", response)
    return BaseResponse(data=response, message="Site Master Data")


@router.post("/", name="Create Master Data Entry", response_model=BaseResponse)
async def create_master_data_entry(
    payload: SiteMasterCreateRequestSchema,
    db: Session = Depends(get_session),
    current_user: UserSchema = Depends(get_current_user),
) -> BaseResponse:
    """
    Call this API to create a master data entry

    On successfull execution the API would return '200 OK' JSON response of the following format
    ```
    {
        "data": {
            "original_name": "avt.png",
            "name": "avt_211028_163403.png",
            "path": "/uploads/avt_211028_163403.png",
            "file_type": "document",
            "mime": "image/png",
            "cdn_id": null,
            "id": 15,
            "created_at": "2021-10-28T16:34:03.005096+00:00",
            "full_url": "http://localhost/uploads/avt_211028_163403.png",
            "created_by": {...}
        },
        "status_code": 200,
        "success": true,
        "message": "Request handled successfully"
    }
    ```
    """
    response = await services.create_master_entry(
        db=db, payload=payload, created_by=current_user
    )
    return SuccessResponse(data=response, message="Data created successfully")


@router.post("/seed", name="Populate Default Site Master Data", response_model=SuccessResponse)
async def seed_default_master_data(
    db: Session = Depends(get_session),
    current_user: UserSchema = Depends(get_current_user),
    force: bool = Query(
        default=False,
        description="Force population even if data already exists. If false, only populates if table is empty or incomplete."
    )
) -> SuccessResponse:
    """
    Call this API to populate the SiteMaster table with default data from seeder
    
    This endpoint will:
    - Check existing data in the SiteMaster table
    - Insert default data from the seeder if missing
    - Provide detailed feedback about the operation
    
    Query Parameters:
    - force: If true, attempts to insert all default data regardless of existing records.
             If false (default), only populates if table has insufficient data.
    
    On successful execution, the API returns a '200 OK' JSON response:
    ```json
    {
        "data": {
            "success": true,
            "message": "Site master data population completed",
            "records_inserted": 50,
            "records_skipped": 10,
            "records_with_errors": 0,
            "total_processed": 60,
            "database_total_before": 10,
            "database_total_after": 60,
            "inserted_items": [
                "country -> US",
                "country -> CA",
                "..."
            ],
            "skipped_items": [
                "locale -> en_US",
                "..."
            ],
            "error_items": []
        },
        "status_code": 200,
        "success": true,
        "message": "Site master data seeding completed successfully"
    }
    ```
    
    Access Control:
    - Requires authentication
    - Only authenticated users can run this seeder
    """
    # Check if user has permission (you might want to add admin-only check here)
    # For now, any authenticated user can run the seeder
    
    if force:
        # Force populate - try to insert all default data
        result = services.populate_default_site_master_data(db)
    else:
        # Smart populate - only if table needs more data
        result = services.seed_site_master_data_if_empty(db)
    
    if result.get("success", False):
        return SuccessResponse(
            data=result, 
            message="Site master data seeding completed successfully"
        )
    else:
        return SuccessResponse(
            data=result,
            message=f"Site master data seeding failed: {result.get('message', 'Unknown error')}"
        )