# import joblib
# import pandas as pd
# import gradio as gr

# # Load the scaler and models
# scaler = joblib.load("models/scaler.joblib")
# models = {
#     "processing": joblib.load("models/svm_model_processing.joblib"),
#     "perception": joblib.load("models/svm_model_perception.joblib"),
#     "input": joblib.load("models/svm_model_input.joblib"),
#     "understanding": joblib.load("models/svm_model_understanding.joblib")
# }

# def predict(course_overview, reading_file, abstract_materiale, concrete_material, visual_materials,
#            self_assessment, exercises_submit, quiz_submitted, playing, paused, unstarted, buffering):
#     try:
#         input_data = {
#             "course overview": [course_overview],
#             "reading file": [reading_file],
#             "abstract materiale": [abstract_materiale],
#             "concrete material": [concrete_material],
#             "visual materials": [visual_materials],
#             "self-assessment": [self_assessment],
#             "exercises submit": [exercises_submit],
#             "quiz submitted": [quiz_submitted],
#             "playing": [playing],
#             "paused": [paused],
#             "unstarted": [unstarted],
#             "buffering": [buffering]
#         }

#         input_df = pd.DataFrame(input_data)
#         input_scaled = scaler.transform(input_df)

#         predictions = {}
#         for target, model in models.items():
#             pred = model.predict(input_scaled)
#             predictions[target] = pred[0]  # Return as is, without converting to int

#         return predictions

#     except Exception as e:
#         return {"error": str(e)}

# # Define Gradio interface using the latest syntax
# iface = gr.Interface(
#     fn=predict,
#     inputs=[
#         gr.Number(label="Course Overview"),
#         gr.Number(label="Reading File"),
#         gr.Number(label="Abstract Materiale"),
#         gr.Number(label="Concrete Material"),
#         gr.Number(label="Visual Materials"),
#         gr.Number(label="Self Assessment"),
#         gr.Number(label="Exercises Submit"),
#         gr.Number(label="Quiz Submitted"),
#         gr.Number(label="Playing"),
#         gr.Number(label="Paused"),
#         gr.Number(label="Unstarted"),
#         gr.Number(label="Buffering")
#     ],
#     outputs=gr.JSON(),
#     title="SVM Multi-Target Prediction",
#     description="Enter the feature values to get predictions for processing, perception, input, and understanding."
# )

# if __name__ == "__main__":
#     iface.launch()

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import pandas as pd

# Load the scaler and models
scaler = joblib.load("models/scaler.joblib")
models = {
    "processing": joblib.load("models/svm_model_processing.joblib"),
    "perception": joblib.load("models/svm_model_perception.joblib"),
    "input": joblib.load("models/svm_model_input.joblib"),
    "understanding": joblib.load("models/svm_model_understanding.joblib"),
}

# Initialize the FastAPI app
app = FastAPI(title="SVM Multi-Target Prediction API")

# Define the input data model
class InputData(BaseModel):
    course_overview: float
    reading_file: float
    abstract_materiale: float
    concrete_material: float
    visual_materials: float
    self_assessment: float
    exercises_submit: float
    quiz_submitted: float
    playing: float
    paused: float
    unstarted: float
    buffering: float

# Define the prediction endpoint
@app.post("/predict")
def predict(input_data: InputData):
    """
    Predict target values based on input features using pre-trained SVM models.
    """
    try:
        # Convert the input data to a DataFrame
        input_df = pd.DataFrame([input_data.dict()])
        
        # Scale the input data
        input_scaled = scaler.transform(input_df)
        
        # Generate predictions for each target
        predictions = {
            target: model.predict(input_scaled)[0]
            for target, model in models.items()
        }
        return {"predictions": predictions}

    except ValueError as ve:
        raise HTTPException(status_code=400, detail=f"Input value error: {ve}")
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Unexpected error: {e}")