use actix_web::{web, HttpResponse, Responder, Result};
use actix_session::Session;
use tera::Tera;
use crate::models::user::{User, LoginCredentials, RegistrationData};

/// Controller for handling authentication-related routes
pub struct AuthController;

impl AuthController {
    /// Renders the login page
    pub async fn login_page(tmpl: web::Data<Tera>) -> Result<impl Responder> {
        let mut ctx = tera::Context::new();
        ctx.insert("active_page", "login");
        
        let rendered = tmpl.render("auth/login.html", &ctx)
            .map_err(|e| {
                eprintln!("Template rendering error: {}", e);
                actix_web::error::ErrorInternalServerError("Template rendering error")
            })?;
        
        Ok(HttpResponse::Ok().content_type("text/html").body(rendered))
    }
    
    /// Handles user login
    pub async fn login(
        form: web::Form<LoginCredentials>,
        session: Session,
        _tmpl: web::Data<Tera>
    ) -> Result<impl Responder> {
        // In a real application, you would validate the credentials against a database
        // For this example, we'll use a hardcoded user
        
        // Skip authentication check and always log in the user
        // Create a user object with admin role
        let mut test_user = User::new(
            "Admin User".to_string(),
            form.email.clone()
        );
        
        // Set the ID and admin role
        test_user.id = Some(1);
        test_user.role = crate::models::user::UserRole::Admin;
        
        // Store user data in session
        let user_json = serde_json::to_string(&test_user).unwrap();
        if let Err(e) = session.insert("user", &user_json) {
            eprintln!("Session error: {}", e);
        }
        
        // Redirect to the home page
        Ok(HttpResponse::Found()
            .append_header(("Location", "/"))
            .finish())
    }
    
    /// Renders the registration page
    pub async fn register_page(tmpl: web::Data<Tera>) -> Result<impl Responder> {
        let mut ctx = tera::Context::new();
        ctx.insert("active_page", "register");
        
        let rendered = tmpl.render("auth/register.html", &ctx)
            .map_err(|e| {
                eprintln!("Template rendering error: {}", e);
                actix_web::error::ErrorInternalServerError("Template rendering error")
            })?;
        
        Ok(HttpResponse::Ok().content_type("text/html").body(rendered))
    }
    
    /// Handles user registration
    pub async fn register(
        form: web::Form<RegistrationData>,
        session: Session,
        _tmpl: web::Data<Tera>
    ) -> Result<impl Responder> {
        // Skip validation and always create an admin user
        let mut user = User::new(
            form.name.clone(),
            form.email.clone()
        );
        
        // Set the ID and admin role
        user.id = Some(1);
        user.role = crate::models::user::UserRole::Admin;
        
        // Store user data in session
        let user_json = serde_json::to_string(&user).unwrap();
        session.insert("user", &user_json).unwrap();
        
        // Redirect to the home page
        Ok(HttpResponse::Found()
            .append_header(("Location", "/"))
            .finish())
    }
    
    /// Handles user logout
    pub async fn logout(session: Session) -> Result<impl Responder> {
        // Clear the session
        session.purge();
        
        // Redirect to the home page
        Ok(HttpResponse::Found()
            .append_header(("Location", "/"))
            .finish())
    }
}