import os
import sys
import logging

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    stream=sys.stdout,
)
log = logging.getLogger("ff1000-api")

log.info("Starting FF1000 API server...")
log.info(f"PYTHONPATH: {os.environ.get('PYTHONPATH', 'not set')}")
log.info(f"Current directory: {os.getcwd()}")
log.info(f"Directory contents: {os.listdir('.')}")

from typing import Dict, Any
from flask import Flask, request, jsonify
from werkzeug.exceptions import HTTPException

# Try to import models with error handling
MODELS: Dict[str, Any] = {}

try:
    log.info("Attempting to import machine_learning models...")
    from machine_learning.load_models import (
        not_for_me,
        recommended_for_you,
        similarity,
    )
    MODELS = {
        "nfm": not_for_me,
        "rfy": recommended_for_you,
        "similarity": similarity,
    }
    log.info("Successfully loaded ML models!")
except Exception as e:
    log.error(f"Failed to import ML models: {e}")
    import traceback
    traceback.print_exc()


def create_app() -> Flask:
    log.info("Creating Flask app...")
    app = Flask(__name__)

    @app.errorhandler(Exception)
    def handle_exception(e):
        if isinstance(e, HTTPException):
            return jsonify(error=e.name, message=e.description), e.code
        log.exception("Unhandled exception")
        return jsonify(error="InternalServerError", message=str(e)), 500

    @app.route("/")
    def root():
        return jsonify(
            status="ok",
            message="FF1000 Recommendation Service",
            models_loaded=len(MODELS) > 0,
            available_models=list(MODELS.keys()) if MODELS else []
        )

    @app.route("/health")
    @app.get("/health")
    def healthz():
        return jsonify(status="ok", models_loaded=len(MODELS) > 0)

    @app.route("/predict/<model_name>", methods=["POST"])
    def predict(model_name: str):
        if not MODELS:
            return jsonify(error="ModelsNotLoaded", message="ML models failed to load"), 500
        
        if model_name not in MODELS:
            return jsonify(error="UnknownModel", message=f"valid models: {list(MODELS.keys())}"), 400

        try:
            payload = request.get_json(force=True, silent=False)
        except Exception:
            return jsonify(error="InvalidJSON", message="body must be valid JSON"), 400

        if not isinstance(payload, dict) or "items" not in payload:
            return jsonify(error="BadRequest", message="json must have key 'items'"), 400

        inputs = payload["items"]
        if not isinstance(inputs, list):
            return jsonify(error="BadRequest", message="'items' must be a list"), 400

        model = MODELS[model_name]
        try:
            preds = model.predict([inputs])
        except Exception as e:
            log.exception("Prediction failed")
            return jsonify(error="PredictionError", message=str(e)), 500

        return jsonify(model=model_name, predictions=preds)

    log.info(f"Flask app created with routes: {[rule.rule for rule in app.url_map.iter_rules()]}")
    return app


log.info("Creating app instance...")
app = create_app()
log.info("App instance created successfully!")