from fastapi import APIRouter, Depends, status, File, UploadFile, HTTPException, Form
from typing import Optional
from src.marketing.apps.Calendar import controller
from src.utils.db import get_db
from sqlalchemy.orm import Session
from src.marketing.apps.Calendar import schema
import os
import uuid
import shutil
from pathlib import Path
from src.utils.response import APIResponse
from fastapi import Query
from typing import List
from src.apps.auth.controller import get_current_user


router = APIRouter()


#---------------------------------------------------------------------------------------------------------

BASE_URL = os.getenv("BASE_URL", "http://localhost:8000")
# BASE_URL = "http://localhost:8000"

# Adjust path
BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
STATIC_PATH = os.path.join(BASE_DIR, "menu_design", "designer", "static", "marketing", "images")

os.makedirs(STATIC_PATH, exist_ok=True)
#---------------------------------------------------------------------------------------------------------


# Create a new calendar
@router.post("/calendars", response_model=schema.CalendarOut, status_code=status.HTTP_201_CREATED, dependencies=[Depends(get_current_user)])
def create_calendar(
    name: str = Form(...),
    timezone: Optional[str] = Form(None),
    icon: Optional[UploadFile] = File(None, description="Image file for calendar icon (jpg, png, webp etc.)"),
    store_id: Optional[int] = Form(None),
    branch_id: Optional[int] = Form(None),
    user_id: Optional[int] = Form(None),
    db: Session = Depends(get_db)
) -> schema.CalendarOut:
    """
    Create a new calendar with optional image upload.
    """
    icon_url = None

    if icon:
        if icon.content_type not in ["image/png", "image/jpeg", "image/jpg", "image/webp"]:
            raise HTTPException(status_code=400, detail="Unsupported file type")
        if not icon.filename:
            raise HTTPException(status_code=400, detail="Filename is required")

        filename = f"{uuid.uuid4().hex}_{os.path.basename(icon.filename)}"
        file_path = os.path.join(STATIC_PATH, filename)

        try:
            with open(file_path, "wb") as buffer:
                shutil.copyfileobj(icon.file, buffer)
        except Exception as e:
            raise HTTPException(status_code=500, detail="Failed to save image")

        icon_url = f"{BASE_URL}/static/marketing/images/{filename}"

    calendar_data = schema.CalendarCreate(
        name=name,
        timezone=timezone,
        store_id=store_id,
        branch_id=branch_id,
        user_id=user_id,
        icon=icon_url
    )

    return controller.create_calendar_controller(db, calendar_data)

#---------------------------------- Get all time zones Route -----------------------------------------------------------------------
# Get all available timezones
@router.get("/calendars/all-timezones", response_model=APIResponse[List[str]], dependencies=[Depends(get_current_user)])
def get_all_timezones() -> APIResponse[List[str]]:
    """
    Get all available timezones.
    """
    timezones =  controller.get_all_timezones_controller()
    return APIResponse(
        success=True,
        message="Timezones fetched successfully",
        data=timezones
    )

#---------------------------------------------------------------------------------------------------------

# Get a calendar by calendar_id
@router.get(
    "/calendars/{calendar_id}",
    response_model=APIResponse[schema.CalendarOut], 
    status_code=status.HTTP_200_OK,
    dependencies=[Depends(get_current_user)]
)
def get_calendar_by_id(
    calendar_id: int,
    db: Session = Depends(get_db)
) -> dict:  
    """
    Get a calendar by ID.
    """
    if not calendar_id:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "success": False,
                "message": "Calendar ID is required",
                "data": []
            }
        )
    
    result = controller.get_calendar_by_id_controller(db, calendar_id)
    
    return {
        "success": True,
        "message": "Calendar fetched successfully",
        "data": result
    }

#-------------------------------------------------------------------------------------------------------

# get calendars by branch_id with optional query parameters
@router.get("/calendars", response_model=APIResponse[List[schema.CalendarOut]])
def get_calendars_by_branch_id(
    branch_id: int,
    show_connected_accounts: Optional[bool] = False,
    show_posts: Optional[bool] = False,
    show_post_types: Optional[bool] = False,
    db: Session = Depends(get_db),
    depends: get_current_user = Depends(get_current_user)
):
    if not branch_id:
        raise HTTPException(status_code=400, detail="Branch ID is required")

    calendars = controller.get_calendar_by_branch_id_controller(
        db=db,
        branch_id=branch_id,
        show_connected_accounts=show_connected_accounts,
        show_posts=show_posts,
        show_post_types=show_post_types
    )

    return {
        "success": True,
        "message": "Calendars fetched successfully",
        "data": calendars
    }

#---------------------------------------------------------------------------------------------------------
# Update a calendar 
@router.put("/calendars/{calendar_id}", response_model=APIResponse[schema.CalendarOut],dependencies=[Depends(get_current_user)])
def update_calendar(
    calendar_id: int,
    calendar_data: schema.CalendarUpdate,
    db: Session = Depends(get_db)
) -> dict:
    """
    update a calendar.
    """
    result = controller.update_calendar_controller(db, calendar_id, calendar_data)
    return {
        "success": True,
        "message": "Calendar updated successfully",
        "data": result
    }
#---------------------------------------------------------------------------------------------------------
# Partially update a calendar
@router.patch("/calendars/{calendar_id}", response_model=APIResponse[schema.CalendarOut],dependencies=[Depends(get_current_user)])
def partially_update_calendar(
    calendar_id: int,
    calendar_data: schema.CalendarUpdate,
    db: Session = Depends(get_db)
) -> schema.CalendarOut:
    """
    Partially update a calendar.
    """
    result =  controller.update_calendar_controller(db, calendar_id, calendar_data)
    return {
        "success": True,
        "message": "Calendar updated successfully",
        "data": result
    }


#---------------------------------------------------------------------------------------------------------
# Delete a calendar by ID
@router.delete("/calendars/{calendar_id}", status_code=status.HTTP_204_NO_CONTENT, dependencies=[Depends(get_current_user)])
def delete_calendar(
    calendar_id: int,
    db: Session = Depends(get_db)
):
    """
    Delete a calendar by ID.
    """
    controller.delete_calendar_controller(db, calendar_id)
    return {"detail": "Calendar deleted successfully"}