from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Request, BackgroundTasks
from fastapi.responses import StreamingResponse
from sqlalchemy.orm import Session
from typing import Dict, Any, List
from db.database import get_db
from services.upload import UploadService
from services.box import BoxService
from services.tcgplayer import TCGPlayerService
from services.data import DataService
from dependencies import get_data_service, get_upload_service, get_tcgplayer_service, get_box_service


import logging
logger = logging.getLogger(__name__)

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

## health check
@router.get("/health", response_model=dict)
async def health_check() -> dict:
    """
    Health check endpoint
    """
    logger.info("Health check")
    return {"status": "ok"}

## test endpoint - logs all detail about request
@router.post("/test", response_model=dict)
async def test_endpoint(request: Request, file:UploadFile = File(...)) -> dict:
    """
    Test endpoint
    """
    content = await file.read()
    # log filename
    logger.info(f"file received: {file.filename}")
    # print first 100 characters of file content
    logger.info(f"file content: {content[:100]}")

    return {"status": "ok"}



@router.post("/upload/manabox", response_model=dict)
async def upload_manabox(
    background_tasks: BackgroundTasks,
    upload_service: UploadService = Depends(get_upload_service),
    data_service: DataService = Depends(get_data_service),
    file: UploadFile = File(...)
) -> dict:
    """
    Upload endpoint for Manabox CSV files
    """
    try:
        logger.info(f"file received: {file.filename}")
        # Read the file content
        content = await file.read()
        filename = file.filename
        if not content:
            logger.error("Empty file content")
            raise HTTPException(status_code=400, detail="Empty file content")
            
        # You might want to validate it's a CSV file
        if not file.filename.endswith('.csv'):
            logger.error("File must be a CSV")
            raise HTTPException(status_code=400, detail="File must be a CSV")

        result = upload_service.process_manabox_upload(content, filename)
        background_tasks.add_task(data_service.bg_set_manabox_tcg_relationship, upload_id=result[1])
        return result[0]
    except Exception as e:
        logger.error(f"Manabox upload failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))



@router.post("/createBox", response_model=dict)
async def create_box(
    upload_id: str,
    box_service: BoxService = Depends(get_box_service)
) -> dict:
    try:
        result = box_service.convert_upload_to_boxes(upload_id)
    except Exception as e:
        logger.error(f"Box creation failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))
    return result

@router.post("/deleteBox", response_model=dict)
async def delete_box(
    box_id: str,
    box_service: BoxService = Depends(get_box_service)
) -> dict:
    try:
        result = box_service.delete_box(box_id)
    except Exception as e:
        logger.error(f"Box deletion failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))
    return result



@router.post("/tcgplayer/add/box/{box_id}", response_model=dict)
async def add_box(box_id: str = None, tcgplayer_service: TCGPlayerService = Depends(get_tcgplayer_service)):
    try:
        csv_content = tcgplayer_service.add_to_tcgplayer(box_id)
        return StreamingResponse(
            iter([csv_content]),
            media_type="text/csv",
            headers={"Content-Disposition": "attachment; filename=add_to_tcgplayer.csv"}
        )
    except Exception as e:
        logger.error(f"Box add failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))

@router.post("/tcgplayer/update/box/{box_id}", response_model=dict)
async def update_box(box_id: int = None):
    """asdf"""
    pass

@router.post("/tcgplayer/updateInventory", response_model=dict)
async def update_inventory(
    background_tasks: BackgroundTasks,
    tcgplayer_service: TCGPlayerService = Depends(get_tcgplayer_service),
    data_service: DataService = Depends(get_data_service)):
    try:
        result = tcgplayer_service.update_inventory('live')
        export_id = result['export_id']
        background_tasks.add_task(data_service.bg_set_tcg_inventory_product_relationship, export_id)
        return result
    except Exception as e:
        logger.error(f"Inventory update failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))
    
@router.post("/tcgplayer/updatePricing", response_model=dict)
async def update_inventory(
    tcgplayer_service: TCGPlayerService = Depends(get_tcgplayer_service),
    group_ids: Dict = None):
    try:
        result = tcgplayer_service.update_pricing(group_ids)
        return result
    except Exception as e:
        logger.error(f"Pricing update failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))
    
@router.post("/tcgplayer/updatePricingAll", response_model=dict)
async def update_inventory(tcgplayer_service: TCGPlayerService = Depends(get_tcgplayer_service)):
    try:
        result = tcgplayer_service.update_pricing_all()
        return result
    except Exception as e:
        logger.error(f"Pricing update failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))

@router.get("/tcgplayer/createLiveInventoryPricingUpdateFile")
async def create_inventory_import(
    tcgplayer_service: TCGPlayerService = Depends(get_tcgplayer_service)
):
    try:
        csv_content = tcgplayer_service.get_live_inventory_pricing_update_csv()
        return StreamingResponse(
            iter([csv_content]),
            media_type="text/csv",
            headers={"Content-Disposition": "attachment; filename=inventory_pricing_update.csv"}
        )
    except Exception as e:
        logger.error(f"Inventory import creation failed: {str(e)}")
        raise HTTPException(status_code=400, detail=str(e))