from fastapi import FastAPI, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import HTMLResponse
import logging
from classCAN import CANBackend  # Your real backend

app = FastAPI()
logging.basicConfig(level=logging.INFO)

can_backend = CANBackend()

# Serve static files (HTML, JS, CSS)
app.mount("/static", StaticFiles(directory="static"), name="static")

@app.post("/connect_toggle")
def connect_toggle():
    """Toggle CAN connection."""
    logging.info("Toggling CAN connection...")
    if can_backend.connected:
        can_backend.shutdown()
        return {"connected": False}
    else:
        success = can_backend.connect(
            node_id=0x02,
            eds_path=r"/eds_file/processBoard_0.eds"
        )
        if not success:
            raise HTTPException(status_code=500, detail="Connection failed.")
        return {"connected": True}

@app.post("/command/{state}/pu/{pu_number}")
def send_command(state: str, pu_number: int):
    """Send a state command to a specific PU."""
    logging.info(f"Sending state '{state}' to PU {pu_number}")
    try:
        can_backend.send_state_command(state.upper(), pu_number)
        return {"status": "success", "command": state.upper(), "pu": pu_number}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/monitor")
def get_monitor_data():
    data = can_backend.get_latest_data()
    print(f"[MONITOR] Latest SDO: {data}")
    return {
        "Qperm": [0.0, data.get("FM2", 0.0), 0.0],
        "Pdilute": [data.get("PS1", 0.0), 0.0, 0.0],
        "Conductivity": [0.0, 0.0, 0.0],
        "Pro": [0.0, 0.0, 0.0],
    }



#
# @app.get("/monitor")
# def get_monitor_values():
#     """
#     Returns current machine monitoring data.
#     Expected structure:
#       Q_perm: [Q1, Q2, Q3]
#       Pdilute: [P1, P2, P3]
#       Conductivity: [C1, C2, C3]
#       Pro: [PR1, PR2, PR3]
#     """
#     try:
#         return {
#             "Q_perm": can_backend.get_q_perm(),
#             "Pdilute": can_backend.get_pdilute(),
#             "Conductivity": can_backend.get_conductivity(),
#             "Pro": can_backend.get_pro(),
#         }
#     except Exception as e:
#         raise HTTPException(status_code=500, detail=str(e))

@app.get("/can_status")
def can_status():
    """Return current CAN connection status."""
    return {"connected": can_backend.connected}

@app.get("/", response_class=HTMLResponse)
async def read_root():
    """Serve main HTML page."""
    with open("static/index.html", "r") as file:
        return HTMLResponse(content=file.read(), status_code=200)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=8000,
        reload=True,
        reload_dirs=["."],
    )