from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import Response, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

from uvicorn import run as app_run
from pydantic import BaseModel

from typing import Optional
from visa_approval_prediction.constants import APP_HOST, APP_PORT
from visa_approval_prediction.pipeline.prediction_pipeline import visaData, visaClassifier

import os

app = FastAPI()

if os.path.isdir("static"):
    app.mount("/static", StaticFiles(directory="static"), name="static")

templates = Jinja2Templates(directory='templates')

origins = ["*"]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class DataForm:
    def __init__(self, request: Request):
        self.request: Request = request
        self.continent: Optional[str] = None
        self.education_of_employee: Optional[str] = None
        self.has_job_experience: Optional[str] = None
        self.requires_job_training: Optional[str] = None
        self.no_of_employees: Optional[str] = None
        self.company_age: Optional[str] = None
        self.region_of_employment: Optional[str] = None
        self.prevailing_wage: Optional[str] = None
        self.unit_of_wage: Optional[str] = None
        self.full_time_position: Optional[str] = None
        

    async def get_visa_data(self):
        form = await self.request.form()
        self.continent = form.get("continent")
        self.education_of_employee = form.get("education_of_employee")
        self.has_job_experience = form.get("has_job_experience")
        self.requires_job_training = form.get("requires_job_training")
        self.no_of_employees = form.get("no_of_employees")
        self.company_age = form.get("company_age")
        self.region_of_employment = form.get("region_of_employment")
        self.prevailing_wage = form.get("prevailing_wage")
        self.unit_of_wage = form.get("unit_of_wage")
        self.full_time_position = form.get("full_time_position")

@app.get("/", tags=["authentication"])
async def index(request: Request):

    return templates.TemplateResponse(
            request, name="visa.html", context={"context": "Rendering"})



class PredictRequest(BaseModel):
    continent: str
    education_of_employee: str
    has_job_experience: str
    requires_job_training: str
    no_of_employees: str
    company_age: str
    region_of_employment: str
    prevailing_wage: str
    unit_of_wage: str
    full_time_position: str


@app.post("/predict")
async def predict_api(data: PredictRequest):
    try:
        import traceback
        print(">>> Step 1: Building input data", flush=True)
        visa_data = visaData(
            continent=data.continent,
            education_of_employee=data.education_of_employee,
            has_job_experience=data.has_job_experience,
            requires_job_training=data.requires_job_training,
            no_of_employees=data.no_of_employees,
            company_age=data.company_age,
            region_of_employment=data.region_of_employment,
            prevailing_wage=data.prevailing_wage,
            unit_of_wage=data.unit_of_wage,
            full_time_position=data.full_time_position,
        )

        visa_df = visa_data.get_visa_input_data_frame()
        print(f">>> Step 2: DataFrame built, shape={visa_df.shape}, columns={list(visa_df.columns)}", flush=True)

        model_predictor = visaClassifier()
        print(">>> Step 3: Loading model...", flush=True)
        prediction, confidence = model_predictor.predict_with_confidence(dataframe=visa_df)
        print(f">>> Step 4: Prediction done: {prediction}, confidence={confidence}", flush=True)

        # TargetValueMapping: Certified=0, Denied=1
        result = "approved" if prediction == 0 else "denied"
        input_data = data.dict()
        insights = model_predictor.explain(visa_df, input_data, result)

        return JSONResponse({
            "result": result,
            "confidence": round(confidence, 1) if confidence else None,
            "insights": insights,
        })

    except Exception as e:
        import traceback
        traceback.print_exc()
        print(f">>> ERROR: {e}", flush=True)
        return JSONResponse({"result": "error", "message": str(e)}, status_code=500)


@app.post("/")
async def predictRouteClient(request: Request):
    try:
        form = DataForm(request)
        await form.get_visa_data()

        visa_data = visaData(
                                continent= form.continent,
                                education_of_employee = form.education_of_employee,
                                has_job_experience = form.has_job_experience,
                                requires_job_training = form.requires_job_training,
                                no_of_employees= form.no_of_employees,
                                company_age= form.company_age,
                                region_of_employment = form.region_of_employment,
                                prevailing_wage= form.prevailing_wage,
                                unit_of_wage= form.unit_of_wage,
                                full_time_position= form.full_time_position,
                                )

        visa_df = visa_data.get_visa_input_data_frame()

        model_predictor = visaClassifier()

        value = model_predictor.predict(dataframe=visa_df)[0]

        # TargetValueMapping: Certified=0, Denied=1
        status = None
        if value == 0:
            status = "Visa-approved"
        else:
            status = "Visa Not-Approved"

        return templates.TemplateResponse(
            request,
            name="visa.html",
            context={"context": status},
        )

    except Exception as e:
        return {"status": False, "error": f"{e}"}


if __name__ == "__main__":
    app_run(app, host=APP_HOST, port=APP_PORT)