import os
import zipfile
from fastapi import APIRouter, Depends
from fastapi.responses import FileResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session
from app.api.company_mapping.schemas import CompanyCourseRoleCreateList, CompanyRoleCreateList
from app.api.company_mapping.service import ComapanyMappingService
from app.database.main.mysql import get_db
from app.dependency.authantication import JWTManager

company_mapping_router = APIRouter()

templates = Jinja2Templates(directory="app/templates")

@company_mapping_router.post("/role_mapping", response_model_exclude_none=True)
async def create_roles(request: CompanyRoleCreateList,db: Session = Depends(get_db),token: dict = Depends(JWTManager.verify_token)):
    return await ComapanyMappingService(db, token).create_role_mappings(request.roles)

@company_mapping_router.get("/company/{company_id}/roles", response_model_exclude_none=True)
async def get_company_roles(company_id: int,db: Session = Depends(get_db),token: dict = Depends(JWTManager.verify_token)):
    return await ComapanyMappingService(db,token).get_company_roles(company_id)

@company_mapping_router.post("/course_mapping", response_model_exclude_none=True)
async def create_course_roles(request: CompanyCourseRoleCreateList,db: Session = Depends(get_db),token: dict = Depends(JWTManager.verify_token)):
    return await ComapanyMappingService(db, token).create_course_mappings(request.mappings)

@company_mapping_router.get("/company/{company_id}/courses-roles")
async def get_company_courses_roles(company_id: int, role_id: int , db: Session = Depends(get_db),token: dict = Depends(JWTManager.verify_token)):
    return await ComapanyMappingService(db, token).get_company_courses_roles(company_id,role_id)

@company_mapping_router.get("/company/course-role/{role_map_id}")
async def get_company_course_role(role_map_id: int, db: Session = Depends(get_db), token: dict = Depends(JWTManager.verify_token)):
    return await ComapanyMappingService(db, token).get_courses_by_role_mapid(role_map_id)
    

templates = Jinja2Templates(directory="templates")

# @company_mapping_router.get("/courses/download")
# async def download_courses(
#     company_id: int,
#     role_id: int,
#     db: Session = Depends(get_db),
#     token: dict = Depends(JWTManager.verify_token)
# ):
#     service = ComapanyMappingService(db, token)
#     response = await service.get_company_courses_roles(company_id, role_id)
#     if response.status != "1" or not response.data:
#         return {"message": "No courses found for the selected company/role."}
#     courses = response.data
#     html_content = templates.get_template("courses.html").render(courses=courses)
#     output_dir = os.path.join("files", "ASTAPI_STRUCTURE/Offline_Content/eLearning/MSTS-400")
#     os.makedirs(output_dir, exist_ok=True)
#     filename = f"courses_{company_id}_{role_id}.html"
#     file_path = os.path.join(output_dir, filename)
#     with open(file_path, "w", encoding="utf-8") as f:
#         f.write(html_content)
#     return FileResponse(file_path, media_type="text/html", filename=filename)


# @company_mapping_router.get("/courses/download")
# async def download_courses(
#     company_id: int,
#     role_id: int,
#     db: Session = Depends(get_db),
#     token: dict = Depends(JWTManager.verify_token)
# ):
#     # 1. Fetch courses
#     service = ComapanyMappingService(db, token)
#     response = await service.get_company_courses_roles(company_id, role_id)

#     if response.status != "1" or not response.data:
#         return {"message": "No courses found for the selected company/role."}

#     courses = response.data

#     # 2. Render HTML using Jinja2
#     html_content = templates.get_template("courses.html").render(courses=courses)

#     # 3. Save into Offline_Content
#     offline_root = os.path.join("files", "ASTAPI_STRUCTURE", "Offline_Content")
#     output_dir = os.path.join(offline_root, "eLearning", "MSTS-400")
#     os.makedirs(output_dir, exist_ok=True)

#     filename = f"courses_{company_id}_{role_id}.html"
#     file_path = os.path.join(output_dir, filename)

#     with open(file_path, "w", encoding="utf-8") as f:
#         f.write(html_content)

#     # 4. Zip the Offline_Content folder
#     zip_filename = f"Offline_Content_{company_id}_{role_id}.zip"
#     zip_path = os.path.join("files", zip_filename)

#     if os.path.exists(zip_path):
#         os.remove(zip_path)  # clean old file

#     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
#         for root, _, files in os.walk(offline_root):
#             for file in files:
#                 file_full_path = os.path.join(root, file)

#                 # ✅ Skip invalid/missing files
#                 if not os.path.exists(file_full_path):
#                     continue  

#                 # ✅ Skip MacOS/hidden files like "._filename"
#                 if file.startswith("._") or file.startswith("~$"):
#                     continue

#                 arcname = os.path.relpath(file_full_path, start=offline_root)
#                 zipf.write(file_full_path, arcname)

#     # 5. Return the zip as download
#     return FileResponse(
#         zip_path,
#         media_type="application/zip",
#         filename=zip_filename
#     )