from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from app.api.store_formate import service
from app.database.main.mysql import get_db
from app.dependency.authantication import JWTPayloadSchema, get_current_student
from app.models.main.store_formate import TblStoreFormat
from .schemas import StoreFormateCreate, StoreFormateResponse, StoreFormateUpdate, StoreFormateCreate11
from fastapi.responses import JSONResponse, StreamingResponse
import io
import pandas as pd
from fpdf import FPDF

store_formate_router = APIRouter()

@store_formate_router.post("/store-formate",response_model_exclude_none=True)
async def create_store_formate(request: StoreFormateCreate,db:Session=Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student),):
    return await service.StoreFormateService(db,token).create_store_formate(request)

@store_formate_router.post("/store-formates", response_model_exclude_none=True)
def create_store_formate111(request: StoreFormateCreate11,db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student),):
    service_instance = service.StoreFormateService(db, token)
    return service_instance.create_store_format3(request)

@store_formate_router.put("/store-formate/update", response_model_exclude_none=True)
async def update_store_format(request: StoreFormateUpdate, db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StoreFormateService(db,token).update_store_formate(request)

@store_formate_router.get("/store-formate/{store_id}", response_model=StoreFormateResponse, response_model_exclude_none=True)
async def get_store_formate(store_id: int, db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StoreFormateService(db, token).get_store_formate(store_id)

@store_formate_router.delete("/store-formate/delete/{store_id}",response_model_exclude_none=True)
async def delete_store(store_id: int,db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StoreFormateService(db, token).delete_store_formate(store_id)


def df_to_pdf_bytes(df: pd.DataFrame) -> bytes:
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=10)
    
    col_width = pdf.w / (len(df.columns) + 1)
    row_height = pdf.font_size * 1.5

    # Header
    for col_name in df.columns:
        pdf.cell(col_width, row_height, col_name, border=1)
    pdf.ln(row_height)

    # Rows
    for _, row in df.iterrows():
        for item in row:
            pdf.cell(col_width, row_height, str(item), border=1)
        pdf.ln(row_height)

    return pdf.output(dest='S').encode('latin1') # type: ignore


@store_formate_router.post("/store-formate/download")
async def download_store_formate_by_group(
    group_id: int = Query(..., description="Group ID to filter data"),
    db: Session = Depends(get_db),
    token: JWTPayloadSchema = Depends(get_current_student),
):
    # Filter records by group_id
    all_records = db.query(TblStoreFormat).filter(TblStoreFormat.group_id == group_id).all()

    if not all_records:
        return JSONResponse(content={"status": "0", "message": f"No store format records found for group_id {group_id}."})

    # Convert to DataFrame
    data = [record.as_dict() for record in all_records]
    df = pd.DataFrame(data)

    # Convert to PDF
    pdf_bytes = df_to_pdf_bytes(df)
    pdf_stream = io.BytesIO(pdf_bytes)
    pdf_stream.seek(0)

    # Return PDF as downloadable file
    return StreamingResponse(
        pdf_stream,
        media_type="application/pdf",
        headers={"Content-Disposition": f"attachment; filename=store_format_group_{group_id}.pdf"}
    )


@store_formate_router.post("/store-formate/download-html")
async def download_store_formate_html(
    group_id: int = Query(..., description="Group ID to filter store format data"),
    db: Session = Depends(get_db),
    token: JWTPayloadSchema = Depends(get_current_student),
):
    records = db.query(TblStoreFormat).filter(TblStoreFormat.group_id == group_id).all()

    if not records:
        return JSONResponse(content={"status": "0", "message": f"No records found for group_id {group_id}."})

    data = [record.as_dict() for record in records]
    df = pd.DataFrame(data)
    html_content = df.to_html(index=False)  

    html_page = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <title>Store Format Report</title>
        <style>
            table {{ border-collapse: collapse; width: 100%; }}
            th, td {{ border: 1px solid #dddddd; text-align: left; padding: 8px; }}
            th {{ background-color: #f2f2f2; }}
        </style>
    </head>
    <body>
        <h2>Store Format Report (Group ID: {group_id})</h2>
        {html_content}
    </body>
    </html>
    """

    stream = io.StringIO(html_page)
    stream.seek(0)

    return StreamingResponse(
        stream,
        media_type="application/octet-stream",
        headers={"Content-Disposition": f"attachment; filename=store_format_group_{group_id}.html"}
    )