from typing import Any, Dict, List, Union
from fastapi import HTTPException
import requests
from app.api.vessel.schemas import VesselFilter
class VesselService:
    def __init__(self):
       self.seafarer_api_url = "https://cms.marinerskills.com/api/get-seafarer-based-on-vessel"
       self.seafarer_security_key = "FslKvipEQ3hT2PfdZla00hp"
       
    def get_roles_by_vessel(self, vessel_id: int) -> Dict[str, Union[int, List[str]]]:
        try:
            payload = {"VesselID": str(vessel_id), "SecurityKey": self.seafarer_security_key}
            response = requests.post(self.seafarer_api_url, json=payload, timeout=10)
            response.raise_for_status()
            data = response.json()

            if isinstance(data, list):
                seafarers = data
            elif isinstance(data, dict) and "data" in data:
                seafarers = data["data"]
            else:
                raise ValueError("Unexpected API format")

            roles = [s.get("Role") for s in seafarers if s.get("Role")]
            if not roles:
                raise HTTPException(status_code=404, detail="No roles found for this vessel")

            return {"vesselId": vessel_id, "roles": sorted(set(roles))}
        except requests.RequestException as e:
            raise HTTPException(status_code=502, detail=f"External API error: {e}")
        except Exception as e:
            raise HTTPException(status_code=500, detail=str(e))
        

    def get_roles_functional_areas_and_courses(self, filters: VesselFilter) -> Dict[str, Any]:
        vessel_id = filters.vesselId
        from app.api.course.service import CourseService  
        course_service = CourseService(vessel_service=self)

        # --- Step 1: Fetch vessel seafarer roles ---
        try:
            payload = {"VesselID": str(vessel_id), "SecurityKey": self.seafarer_security_key}
            response = requests.post(self.seafarer_api_url, json=payload, timeout=10)
            response.raise_for_status()
            data = response.json()

            if isinstance(data, list):
                seafarers = data
            elif isinstance(data, dict) and "data" in data and isinstance(data["data"], list):
                seafarers = data["data"]
            else:
                raise HTTPException(status_code=500, detail=f"Unexpected API response format: {data}")

            vessel_roles = [s.get("Role") for s in seafarers if s.get("Role")]
            if not vessel_roles:
                raise HTTPException(status_code=404, detail="No roles found for this vessel")

        except requests.RequestException as e:
            raise HTTPException(status_code=502, detail=f"Error contacting seafarer API: {e}")

        # --- Step 2: Load full course list ---
        full_data = course_service.sync_full_course_list(vessel_id=vessel_id)
        matched_courses = full_data.get("matched_courses", [])

        if not matched_courses:
            raise HTTPException(status_code=404, detail="No course data available")

        # --- Step 3: Filter courses by vessel roles ---
        vessel_courses = [
            c for c in matched_courses
            if any(role in c.get("roles", []) for role in vessel_roles)
        ]

        if not vessel_courses:
            raise HTTPException(status_code=404, detail=f"No courses found for vessel {vessel_id}")

        # --- Step 4: Build structure grouped by series ---
        result_data = {}

        for course in vessel_courses:
            series = course.get("series", "Unknown Series")
            func_area = course.get("functional_area", "Uncategorized")
            category_name = course.get("category_name", "Uncategorized")
            course_name = course.get("cms_course_name", course.get("lms_course", "Unnamed Course"))

            if series not in result_data:
                result_data[series] = {
                    "roles": {},
                    "functional_areas": {}
                }

            # --- Add course under matching roles ---
            for role in course.get("roles", []):
                if role in vessel_roles:
                    result_data[series]["roles"].setdefault(role, [])
                    if course_name not in result_data[series]["roles"][role]:
                        result_data[series]["roles"][role].append(course_name)
            # ------ add catogoty before funcitional areas
            if category_name not in result_data[series]["functional_areas"]:
                result_data[series]["functional_areas"][category_name] = {}


            # --- Add course under functional area ---
            result_data[series]["functional_areas"][category_name].setdefault(func_area, [])
            if course_name not in result_data[series]["functional_areas"][category_name][func_area]:
                result_data[series]["functional_areas"][category_name][func_area].append(course_name)

        # --- Step 5: Return final JSON ---
        return {
            "status": "1",
            "message": f"Roles and functional areas for vessel {vessel_id}",
            "vesselId": vessel_id,
            "data": result_data
        }