from flask.views import MethodView
from flask_smorest import Blueprint
from src.models.models import User
from src.views.users.utils import UserManager
from flask import request
from src.models.schema import (
    UserSchema,
    UserUpdateSchema,
    LoginSchema,
    OTPVerifySchema,
    PasswordResetRequestSchema,
    PasswordResetVerifySchema,
    PasswordResetCompleteSchema,
    TwoFactorEnableSchema,
    NotificationPreferenceSchema
)

user_router = Blueprint("User Management Routes", __name__)

@user_router.route("/users")
class UserRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200, schema=UserSchema(many=True))
    def get(self):
        """Get all users with pagination"""
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        return self.user_manager.fetchAll(page=page, per_page=per_page)

    @user_router.response(status_code=201)
    def post(self):
        """Create a new user"""
        payload = request.get_json()
        return self.user_manager.create(payload)

@user_router.route("/users/chat")
class ChatUsersRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self):
        """Get all users for chat system (without pagination)"""
        return self.user_manager.fetchAllForChat()

@user_router.route("/users/<string:id>")
class UserDetailRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200, schema=UserSchema)
    def get(self, id):
        """Get a user by ID"""
        return self.user_manager.get(id)

    @user_router.response(status_code=200)
    def put(self, id):
        """Update a user"""
        payload = request.get_json()
        return self.user_manager.update(id, payload)

    @user_router.response(status_code=204)
    def delete(self, id):
        """Delete (deactivate) a user"""
        return self.user_manager.delete(id)

@user_router.route("/auth/login")
class AuthLoginRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=LoginSchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload):
        """User login"""
        return self.user_manager.login(payload)

@user_router.route("/auth/logout")
class AuthLogoutRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self):
        """User logout"""
        return self.user_manager.logout()

@user_router.route("/auth/verify")
class AuthVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self):
        """Verify authentication token"""
        return self.user_manager.verify_auth_token()

@user_router.route("/auth/otp/verify")
class AuthOTPVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=OTPVerifySchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload):
        """Verify OTP for 2FA"""
        return self.user_manager.verify_otp(payload)

@user_router.route("/auth/password/reset/request")
class AuthPasswordResetRequestRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=PasswordResetRequestSchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload):
        """Request password reset"""
        return self.user_manager.request_password_reset(payload)

@user_router.route("/auth/password/reset/verify")
class AuthPasswordResetVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=PasswordResetVerifySchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload):
        """Verify password reset token"""
        return self.user_manager.verify_reset_token(payload)

@user_router.route("/auth/password/reset/complete")
class AuthPasswordResetCompleteRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=PasswordResetCompleteSchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload):
        """Complete password reset"""
        return self.user_manager.reset_password(payload)

@user_router.route("/users/<string:user_id>/2fa/enable")
class TwoFactorEnableRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.arguments(schema=TwoFactorEnableSchema, location='json')
    @user_router.response(status_code=200)
    def post(self, payload, user_id):
        """Enable two-factor authentication"""
        return self.user_manager.enable_two_factor(user_id, payload.get('method'))

@user_router.route("/users/<string:user_id>/2fa/disable")
class TwoFactorDisableRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def post(self, user_id):
        """Disable two-factor authentication"""
        return self.user_manager.disable_two_factor(user_id)

@user_router.route("/users/<string:user_id>/notifications")
class UserNotificationPreferencesRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200, schema=NotificationPreferenceSchema)
    def get(self, user_id):
        """Get notification preferences"""
        return self.user_manager.get_notification_preferences(user_id)

    @user_router.arguments(schema=NotificationPreferenceSchema, location='json')
    @user_router.response(status_code=200)
    def put(self, payload, user_id):
        """Update notification preferences"""
        return self.user_manager.update_notification_preferences(user_id, payload)

@user_router.route("/users/<string:user_id>/dashboard")
class UserDashboardRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self, user_id):
        """Get user dashboard summary"""
        return self.user_manager.get_user_dashboard_summary(user_id)

@user_router.route("/debug/enrollment")
class DebugEnrollmentRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self):
        """Debug endpoint to check enrollment data"""
        return self.user_manager.debug_enrollment_data()

@user_router.route("/users/password/update")
class UserPasswordUpdateRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def post(self):
        """Update user password by email"""
        payload = request.get_json()
        return self.user_manager.update_password_by_email(payload)

@user_router.route("/users/remote-unlock")
class UserRemoteUnlockRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def post(self):
        """Remote unlock a temporarily locked account"""
        payload = request.get_json()
        return self.user_manager.remote_unlock_account(payload)

@user_router.route("/users/disable-2fa")
class UserDisable2FARouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def post(self):
        """Disable 2FA for all users (migration)"""
        return self.user_manager.disable_2fa_for_all_users()

@user_router.route("/auth/current-user/department")
class AuthCurrentUserDepartmentRouter(MethodView):
    def __init__(self) -> None:
        self.user_manager = UserManager()

    @user_router.response(status_code=200)
    def get(self):
        """Get current user's department"""
        user_id = request.args.get('user_id')
        if not user_id:
            return custom_response(
                success=False,
                data="User ID is required",
                status_code=400
            )
        return self.user_manager.get_user_department(user_id)